CheeseAPI 2.0.8b4__tar.gz → 2.0.8b6__tar.gz

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/CheeseAPI/app.py

@@ -361,7 +361,7 @@ class AppProxy:
                     'request': request
                 })
 
-                if request._proxy.protocol is None or not self.app.keep_alive or (request._proxy.protocol == 'HTTP/1.0' and request.headers.get('Connection') != 'keep-alive') or (request._proxy.protocol == 'HTTP/1.1' and request.headers.get('Connection') == 'close'):
+                if request._proxy.protocol is None or not self.app.keep_alive or (request._proxy.protocol == 'HTTP/1.0' and request.headers.get('connection') != 'keep-alive') or (request._proxy.protocol == 'HTTP/1.1' and request.headers.get('connection') == 'close'):
                     break
 
             client_socket, addr = await self.before_request(client_socket, addr)

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/CheeseAPI/cors.py

@@ -19,31 +19,31 @@ class CORS:
         self.max_age: int | None = max_age
 
     def get_response(self, request: 'Request'):
-        origin = request.headers.get('Origin', '')
+        origin = request.headers.get('origin', '')
         if '*' not in self.allow_origins and origin not in self.allow_origins:
             return Response(status = 403)
 
         headers = {}
 
         if origin in self.allow_origins:
-            headers['Access-Control-Allow-Origin'] = origin
+            headers['access-control-allow-origin'] = origin
         elif '*' in self.allow_origins and not self.allow_credentials:
-            headers['Access-Control-Allow-Origin'] = '*'
+            headers['access-control-allow-origin'] = '*'
 
-        headers['Access-Control-Allow-Methods'] = ', '.join(self.allow_methods)
+        headers['access-control-allow-methods'] = ', '.join(self.allow_methods)
 
         if '*' in self.allow_headers:
-            headers['Access-Control-Allow-Headers'] = request.headers.get('Access-Control-Request-Headers') or '*'
+            headers['access-control-allow-headers'] = request.headers.get('access-control-request-headers') or '*'
         else:
-            headers['Access-Control-Allow-Headers'] = ', '.join(self.allow_headers)
+            headers['access-control-allow-headers'] = ', '.join(self.allow_headers)
 
         if self.allow_credentials:
-            headers['Access-Control-Allow-Credentials'] = 'true'
+            headers['access-control-allow-credentials'] = 'true'
 
         if self.expose_headers:
-            headers['Access-Control-Expose-Headers'] = ', '.join(self.expose_headers)
+            headers['access-control-expose-headers'] = ', '.join(self.expose_headers)
 
         if self.max_age is not None:
-            headers['Access-Control-Max-Age'] = str(self.max_age)
+            headers['access-control-max-age'] = str(self.max_age)
 
         return Response(status = 204, headers = headers)

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/CheeseAPI/request.py

@@ -150,34 +150,34 @@ class RequestProxy:
         self.request._headers = {}
         for line in lines[1:]:
             key, value = line.split(': ', 1)
-            self.request.headers[key] = value
+            self.request.headers[key.lower()] = value
 
-        if 'Cookie' in self.request.headers:
+        if 'cookie' in self.request.headers:
             self.request._cookies = {}
-            for cookie in self.request.headers['Cookie'].split(';'):
+            for cookie in self.request.headers['cookie'].split(';'):
                 key, value = cookie.strip().split('=', 1)
                 self.request.cookies[key] = value
 
-        if 'X-Real-IP' in self.request.headers:
-            self.request._ip = self.request.headers['X-Real-IP']
-        elif 'X-Forwarded-For' in self.request.headers:
-            self.request._ip = self.request.headers['X-Forwarded-For'].split(',')[0].strip()
+        if 'x-real-ip' in self.request.headers:
+            self.request._ip = self.request.headers['x-real-ip']
+        elif 'x-forwarded-for' in self.request.headers:
+            self.request._ip = self.request.headers['x-forwarded-for'].split(',')[0].strip()
 
-        if 'Range' in self.request.headers:
+        if 'range' in self.request.headers:
             self.request._ranges = []
-            for range_part in self.request.headers['Range'][6:].split(','):
+            for range_part in self.request.headers['range'][6:].split(','):
                 range_part = range_part.strip()
                 if '-' in range_part:
                     start, end = range_part.split('-', 1)
                     self.request.ranges.append((int(start) if start else 0, int(end) if end else None))
 
-        if 'Upgrade' in self.request.headers and self.request.headers['Upgrade'] == 'websocket':
+        if 'upgrade' in self.request.headers and self.request.headers['upgrade'] == 'websocket':
             self.request._method = 'WEBSOCKET'
 
     async def recv_body(self, get_all: bool = False) -> bool | Response | None:
         loop = asyncio.get_event_loop()
 
-        content_length = self.request.headers.get('Content-Length')
+        content_length = self.request.headers.get('content-length')
         if content_length:
             self.request._body = self.buffer
             self.buffer = b''
@@ -193,7 +193,7 @@ class RequestProxy:
                     raise ConnectionAbortedError()
             return True
 
-        is_chunked = self.request.headers.get('Transfer-Encoding') == 'chunked'
+        is_chunked = self.request.headers.get('transfer-encoding') == 'chunked'
         if is_chunked:
             if self.request._body is None:
                 self.request._body = b''
@@ -213,7 +213,7 @@ class RequestProxy:
                     return Response(status = 400)
 
                 if chunk_size == 0:
-                    if self.request.headers.get('Trailer'):
+                    if self.request.headers.get('trailer'):
                         while b'\r\n\r\n' not in self.buffer:
                             try:
                                 data = await asyncio.wait_for(loop.sock_recv(self.client_socket, self.app.socket_receive_buffer_size), self.app.request_timeout)
@@ -224,7 +224,7 @@ class RequestProxy:
                             self.buffer += data
 
                         trailer, self.buffer = self.buffer.split(b'\r\n\r\n', 1)
-                        if trailer and trailer.startswith('Content-MD5: ') and trailer[13:] not in (base64.b64encode(hashlib.md5(self.request._body).digest()).decode(), hashlib.md5(self.request._body).hexdigest()):
+                        if trailer and trailer.startswith('content-md5: ') and trailer[13:] not in (base64.b64encode(hashlib.md5(self.request._body).digest()).decode(), hashlib.md5(self.request._body).hexdigest()):
                             return Response(status = 400)
 
                     self.buffer = b''
@@ -246,7 +246,7 @@ class RequestProxy:
         if self.request.body is None:
             return
 
-        content_type = self.request.headers.get('Content-Type')
+        content_type = self.request.headers.get('content-type')
         if content_type == 'text/plain' or content_type is None:
             self.request._body = self.request.body.decode()
         elif content_type == 'application/json':
@@ -287,7 +287,7 @@ class RequestProxy:
                             self.request._form = {}
                         self.request._form[name] = data.decode()
 
-        if self.request.headers.get('Content-Disposition'):
-            match = re.search(r'filename="([^"]*)"', self.request.headers['Content-Disposition'])
+        if self.request.headers.get('content-disposition'):
+            match = re.search(r'filename="([^"]*)"', self.request.headers['content-disposition'])
             if match:
                 self.request._file = File(match.group(1), self.request.body)

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/CheeseAPI/response.py

@@ -125,7 +125,7 @@ class RedirectResponse(Response):
     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
+        headers['location'] = location
 
         super().__init__(status, body, headers)
 
@@ -173,14 +173,14 @@ class ResponseProxy:
         bytes.extend(['', ''])
         bytes = '\r\n'.join(bytes).encode()
         if not no_body:
-            if self.response.headers.get('Transfer-Encoding') == 'chunked':
+            if self.response.headers.get('transfer-encoding') == 'chunked':
                 bytes += hex(len(data)).encode() + b'\r\n' + data + b'\r\n'
             else:
                 bytes += data
         await loop.sock_sendall(client_socket, bytes)
 
         if not no_body:
-            if self.response.headers.get('Transfer-Encoding') == 'chunked':
+            if self.response.headers.get('transfer-encoding') == 'chunked':
                 async for _, _, data in gen:
                     await loop.sock_sendall(client_socket, hex(len(data)).encode() + b'\r\n' + data + b'\r\n')
                 await loop.sock_sendall(client_socket, b'0\r\n\r\n')
@@ -193,7 +193,7 @@ class ResponseProxy:
 
     async def get_status(self, status: int, headers: dict[str, str], body: dict | list | str | bytes | None) -> tuple[int, dict[str, str], dict | list | str | bytes | None]:
         if isinstance(self.response, FileResponse):
-            if self.request.headers.get('Range') is not None:
+            if self.request.headers.get('range') is not None:
                 max_range = -1
                 for range in self.request.ranges:
                     if range[1] is not None:
@@ -229,36 +229,36 @@ class ResponseProxy:
             elif self.response.transmission_type == 'CHUNKED':
                 body = self.file_response_chunked_body()
 
-            if 'Content-Type' not in headers and 'Content-Disposition' not in headers:
+            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}"'
+                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}"'
 
         if isinstance(self.response.body, AsyncIterable):
-            if 'Transfer-Encoding' not in headers:
-                headers['Transfer-Encoding'] = 'chunked'
+            if 'transfer-encoding' not in headers:
+                headers['transfer-encoding'] = 'chunked'
 
-        if 'Date' not in headers:
+        if 'date' not in headers:
             now = datetime.datetime.now(datetime.timezone.utc)
-            headers['Date'] = (now.strftime('%a, %d %b %Y %H:%M:%S.') + f'{now.microsecond:06d} GMT') if self.response.high_precision_date else now.strftime('%a, %d %b %Y %H:%M:%S GMT')
+            headers['date'] = (now.strftime('%a, %d %b %Y %H:%M:%S.') + f'{now.microsecond:06d} GMT') if self.response.high_precision_date else now.strftime('%a, %d %b %Y %H:%M:%S GMT')
 
-        if 'Connection' not in headers:
-            if self.app.keep_alive and self.request and ((self.request._proxy.protocol == 'HTTP/1.1' and self.request.headers.get('Connection', '') != 'close') or (self.request._proxy.protocol == 'HTTP/1.0' and self.request.headers.get('Connection', '') == 'keep-alive')):
-                headers['Connection'] = 'keep-alive'
-                headers['Keep-Alive'] = f'timeout={self.app.keep_alive_timeout}, max={self.app.keep_alive_max_requests}'
+        if 'connection' not in headers:
+            if self.app.keep_alive and self.request and ((self.request._proxy.protocol == 'HTTP/1.1' and self.request.headers.get('connection', '') != 'close') or (self.request._proxy.protocol == 'HTTP/1.0' and self.request.headers.get('connection', '') == 'keep-alive')):
+                headers['connection'] = 'keep-alive'
+                headers['keep-alive'] = f'timeout={self.app.keep_alive_timeout}, max={self.app.keep_alive_max_requests}'
             else:
-                headers['Connection'] = 'close'
+                headers['connection'] = 'close'
 
         if self.request.ranges:
             if status == 206:
-                headers.setdefault('Accept-Ranges', 'bytes')
+                headers.setdefault('accept-ranges', 'bytes')
         else:
             encodings = []
             encoding_quality = False
-            if self.app.compress and self.request and self.request.headers and self.request.headers.get('Accept-Encoding'):
-                for encoding in self.request.headers.get('Accept-Encoding').split(','):
+            if self.app.compress and self.request and self.request.headers and self.request.headers.get('accept-encoding'):
+                for encoding in self.request.headers.get('accept-encoding').split(','):
                     encoding_split = encoding.strip().split(';')
                     if len(encoding_split) == 1:
                         encoding_split.append(1)
@@ -270,26 +270,26 @@ class ResponseProxy:
                 encodings = [encoding[0] for encoding in encodings]
 
             if self.response.compress is not None:
-                headers.setdefault('Content-Encoding', self.response.compress)
+                headers.setdefault('content-encoding', self.response.compress)
             elif encodings:
                 if encoding_quality is True:
                     for encoding in encodings:
                         if encoding in self.app.compress:
-                            headers.setdefault('Content-Encoding', encoding)
+                            headers.setdefault('content-encoding', encoding)
                             break
                         if encoding == '*':
-                            headers.setdefault('Content-Encoding', self.app.compress[0])
+                            headers.setdefault('content-encoding', self.app.compress[0])
                             break
                 else:
                     if encodings[0] == '*':
-                        headers.setdefault('Content-Encoding', self.app.compress[0])
+                        headers.setdefault('content-encoding', self.app.compress[0])
                     else:
                         for encoding in self.app.compress:
                             if encoding in encodings:
-                                headers.setdefault('Content-Encoding', encoding)
+                                headers.setdefault('content-encoding', encoding)
                                 break
 
-        if self.response.cookies and 'Set-Cookie' not in headers:
+        if self.response.cookies and 'set-cookie' not in headers:
             cookies = []
             for key, cookie in self.response.cookies.items():
                 _cookie = f'{key}={cookie["value"]}'
@@ -304,7 +304,7 @@ class ResponseProxy:
                 if cookie['http_only']:
                     _cookie += '; HttpOnly'
                 cookies.append(_cookie)
-            headers['Set-Cookie'] = ', '.join(cookies)
+            headers['set-cookie'] = ', '.join(cookies)
 
         return status, headers, body
 
@@ -321,13 +321,13 @@ class ResponseProxy:
                     handler.seek(self.request.ranges[0][0] or 0)
                     data = handler.read((self.request.ranges[0][1] or size) - (self.request.ranges[0][0]))
                     handler.close()
-                headers['Content-Length'] = str(len(data))
-                headers['Content-Range'] = f'bytes {self.request.ranges[0][0]}-{(self.request.ranges[0][1] or size) - 1}/{size}'
+                headers['content-length'] = str(len(data))
+                headers['content-range'] = f'bytes {self.request.ranges[0][0]}-{(self.request.ranges[0][1] or size) - 1}/{size}'
                 yield status, headers, data
             else:
                 boundary = uuid.uuid4().hex
-                content_type = headers['Content-Type']
-                headers['Content-Type'] = f'multipart/byteranges; boundary={boundary}'
+                content_type = headers['content-type']
+                headers['content-type'] = f'multipart/byteranges; boundary={boundary}'
                 if self.response.file._data is not None:
                     size = len(self.response.file.data)
                 else:
@@ -336,10 +336,10 @@ class ResponseProxy:
                 content_length = 0
                 for range in self.request.ranges:
                     content_length += 2 + 32 + 2 + 14 + len(content_type) + 2 + 21 + (1 if range[0] == 0 else int(math.log10(range[0]))) + 1 + 1 + int(math.log10(range[1] or size)) + 1 + 1 + int(math.log10(size)) + 1 + 4 + (range[1] or size) - range[0] + 1
-                headers['Content-Length'] = str(content_length)
+                headers['content-length'] = str(content_length)
 
                 for range in self.request.ranges:
-                    data = [b'--', boundary.encode(), b'\r\n', b'Content-Type: ', content_type.encode(), b'\r\n', b'Content-Range: bytes ', str(range[0]).encode(), b'-', str(range[1] or size).encode(), b'/', str(size).encode() + b'\r\n\r\n']
+                    data = [b'--', boundary.encode(), b'\r\n', b'content-type: ', content_type.encode(), b'\r\n', b'content-range: bytes ', str(range[0]).encode(), b'-', str(range[1] or size).encode(), b'/', str(size).encode() + b'\r\n\r\n']
                     if self.response.file._data is not None:
                         data.append(self.response.file.data[range[0]:range[1] or size + 1])
                     else:
@@ -357,22 +357,22 @@ class ResponseProxy:
 
             if isinstance(data, (dict, list)):
                 data = json.dumps(data).encode()
-                headers.setdefault('Content-Type', 'application/json; charset=utf-8')
+                headers.setdefault('content-type', 'application/json; charset=utf-8')
             elif isinstance(data, str):
                 data = data.encode()
-                headers.setdefault('Content-Type', 'text/plain; charset=utf-8')
+                headers.setdefault('content-type', 'text/plain; charset=utf-8')
             elif data is None:
                 data = HTTP_STATUS[status].encode()
-                headers.setdefault('Content-Type', 'text/plain; charset=utf-8')
+                headers.setdefault('content-type', 'text/plain; charset=utf-8')
             elif isinstance(data, bytes):
-                headers.setdefault('Content-Type', 'application/octet-stream; charset=utf-8')
+                headers.setdefault('content-type', 'application/octet-stream; charset=utf-8')
 
             if isinstance(body, AsyncIterable) is False:
-                headers['Content-Length'] = str(len(data))
+                headers['content-length'] = str(len(data))
 
             status, headers, data = await self.get_encode_body(status, headers, data)
             if isinstance(body, AsyncIterable) is False:
-                headers['Content-Length'] = str(len(data))
+                headers['content-length'] = str(len(data))
             yield status, headers, data
 
             if isinstance(body, AsyncIterable):
@@ -385,25 +385,25 @@ class ResponseProxy:
                     yield status, headers, data
 
     async def get_encode_body(self, status: int, headers: dict[str, str], body: bytes) -> tuple[int, dict[str, str], bytes]:
-        content_length = headers.get('Content-Length')
+        content_length = headers.get('content-length')
         if content_length and int(content_length) < self.app.compress_min_length:
-            if 'Content-Encoding' in headers:
-                del headers['Content-Encoding']
+            if 'content-encoding' in headers:
+                del headers['content-encoding']
 
-        if 'Content-Encoding' in headers and 'Content-Length' in headers and (int(headers['Content-Length']) > self.app.compress_min_length or self.response.compress is not None):
+        if 'content-encoding' in headers and 'content-length' in headers and (int(headers['content-length']) > self.app.compress_min_length or self.response.compress is not None):
             compress_level = self.response.compress_level if self.response.compress_level is not None else self.app.compress_level
-            if headers['Content-Encoding'] == 'gzip':
+            if headers['content-encoding'] == 'gzip':
                 body = gzip.compress(body, compress_level)
-            elif headers['Content-Encoding'] == 'deflate':
+            elif headers['content-encoding'] == 'deflate':
                 body = zlib.compress(body, level = compress_level)
-            elif headers['Content-Encoding'] == 'br':
+            elif headers['content-encoding'] == 'br':
                 body = brotli.compress(body, quality = compress_level)
-            elif headers['Content-Encoding'] == 'zstd':
+            elif headers['content-encoding'] == 'zstd':
                 body = zstandard.ZstdCompressor(level = compress_level).compress(body)
 
-            headers['Content-Length'] = str(len(body))
+            headers['content-length'] = str(len(body))
         else:
-            if 'Content-Encoding' in headers:
-                del headers['Content-Encoding']
+            if 'content-encoding' in headers:
+                del headers['content-encoding']
 
         return status, headers, body

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/CheeseAPI/websocket.py

@@ -109,6 +109,8 @@ class Websocket:
     close = DualMethod(_static_close, _instance_close)
 
 class WebsocketProxy:
+    _sync_tasks: dict[str, asyncio.Task] = {}
+
     @staticmethod
     def _static_send(path: str, data: bytes | list | str | dict, *, websocket_key_or_keys: str | list[str] | None = None):
         if static.websocket_sync_servers is not None:
@@ -244,7 +246,7 @@ class WebsocketProxy:
         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, socket_timeout = self.app.sync_server_timeout, socket_connect_timeout = self.app.sync_server_timeout)
-            asyncio.create_task(self.sync_server_running())
+            WebsocketProxy._sync_tasks[self.websocket.request.path] = asyncio.create_task(self.sync_server_running())
 
         loop = asyncio.get_running_loop()
         self.reader = asyncio.StreamReader()
@@ -259,10 +261,18 @@ class WebsocketProxy:
         await self.websocket.on_connect()
 
     async def sync_server_running(self):
+        pubsub = None
         try:
             if self.app.sync_server_url.startswith('redis'):
                 while True:
                     try:
+                        if pubsub is not None:
+                            try:
+                                await pubsub.aclose()
+                            except Exception:
+                                pass
+                            pubsub = None
+
                         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():
@@ -302,6 +312,13 @@ class WebsocketProxy:
                         await asyncio.sleep(self.app.sync_server_timeout)
         except (KeyboardInterrupt, SystemExit, asyncio.CancelledError):
             ...
+        finally:
+            WebsocketProxy._sync_tasks.pop(self.websocket.request.path, None)
+            if pubsub is not None:
+                try:
+                    await pubsub.aclose()
+                except Exception:
+                    pass
 
     async def message(self):
         while True:

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/PKG-INFO

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

{cheeseapi-2.0.8b4 → cheeseapi-2.0.8b6}/pyproject.toml

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