CheeseAPI 0.2.17__tar.gz → 0.2.19__tar.gz

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/CheeseAPI/app.py

@@ -50,15 +50,14 @@ class App:
             sock.bind((self.server.host, self.server.port))
             sock.set_inheritable(True)
 
-            asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-            asyncio.run(_run(app, sock, managers))
-
             multiprocessing.allow_connection_pickling()
             for i in range(0, self.server.workers - 1):
                 process = multiprocessing.Process(target = run, args = (app, sock, managers), name = f'CheeseAPI_Subprocess<{i}>', daemon = True)
                 process.start()
                 os.setpgid(process.pid, os.getpid())
 
+            run(app, sock, managers)
+
             while managers['startedWorkerNum'].value != 0:
                 time.sleep(0.1)
         except Exception as e:

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/CheeseAPI/handle.py

@@ -41,29 +41,28 @@ class Handle:
                 except:
                     ...
 
-            funcs = paths.match(protocol.request.path)
-
-            if not funcs:
-                await self._http_responseHandle(protocol, app, await self._http_404Handle(protocol, app))
-                return
+            try:
+                func, kwargs = paths.match(protocol.request.path, protocol.request.method)
 
-            if protocol.request.method not in funcs:
-                await self._http_responseHandle(protocol, app, await self._http_405Handle(protocol, app))
-                return
+                for http_beforeRequestHandle in self.http_beforeRequestHandles:
+                    await http_beforeRequestHandle(**{ 'request': protocol.request })
+                if signal.receiver('http_beforeRequestHandle'):
+                    await signal.async_send('http_beforeRequestHandle', { 'request': protocol.request })
 
-            for http_beforeRequestHandle in self.http_beforeRequestHandles:
-                await http_beforeRequestHandle(**{ 'request': protocol.request })
-            if signal.receiver('http_beforeRequestHandle'):
-                await signal.async_send('http_beforeRequestHandle', { 'request': protocol.request })
+                kwargs['request'] = protocol.request
+                response = await func(**kwargs)
+                if await self._http_responseHandle(protocol, app, response):
+                    return
 
-            func = funcs[protocol.request.method][0]
-            kwargs = funcs[protocol.request.method][1]
-            kwargs['request'] = protocol.request
-            response = await func(**kwargs)
-            if await self._http_responseHandle(protocol, app, response):
-                return
+                await self._http_responseHandle(protocol, app, await self._http_noResponseHandle(protocol, app))
+            except KeyError as e:
+                if e.args[0] == 0:
+                    await self._http_responseHandle(protocol, app, await self._http_404Handle(protocol, app))
+                    return
 
-            await self._http_responseHandle(protocol, app, await self._http_noResponseHandle(protocol, app))
+                if e.args[0] == 1:
+                    await self._http_responseHandle(protocol, app, await self._http_405Handle(protocol, app))
+                    return
         except BaseException as e:
             await self._http_responseHandle(protocol, app, await self._http_500Handle(protocol, app, e))
 
@@ -265,19 +264,16 @@ A usable BaseResponse is not returned''')
         self.http_afterResponseHandles.append(func)
 
     async def _websocket_requestHandle(self, protocol: 'WebsocketProtocol', app: 'App') -> Tuple[Callable, Dict[str, Any]] | HTTPResponse:
-        funcs = paths.match(protocol.request.path)
-
-        if not funcs:
-            return await self._websocket_responseHandle(protocol, app, await self._websocket_404Handle(protocol, app))
-
-        if 'WEBSOCKET' not in funcs:
-            return await self._websocket_responseHandle(protocol, app, await self._websocket_405Handle(protocol, app))
-
-        func = funcs['WEBSOCKET'][0]()
-        kwargs = funcs['WEBSOCKET'][1]
-        kwargs['request'] = protocol.request
+        try:
+            func, kwargs = paths.match(protocol.request.path, 'WEBSOCKET')
+            kwargs['request'] = protocol.request
+            return func(), kwargs
+        except KeyError as e:
+            if e.args[0] == 0:
+                return await self._websocket_responseHandle(protocol, app, await self._websocket_404Handle(protocol, app))
 
-        return func, kwargs
+            if e.args[0] == 1:
+                return await self._websocket_responseHandle(protocol, app, await self._websocket_405Handle(protocol, app))
 
     async def _websocket_404Handle(self, protocol: 'WebsocketProtocol', app: 'App') -> Response:
         return Response(status = http.HTTPStatus.NOT_FOUND)

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/CheeseAPI/protocol.py

@@ -1,4 +1,4 @@
-import asyncio, http, traceback
+import asyncio, http
 from typing import TYPE_CHECKING, Dict, Any, Tuple, Deque, Self
 from multiprocessing import Manager
 from collections import deque

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/CheeseAPI/route.py

@@ -1,5 +1,5 @@
 import re, uuid, http
-from typing import Callable, Dict, List, Tuple, Any
+from typing import Callable, Dict, List, Tuple, Any, Literal
 from urllib.parse import unquote
 
 patterns: Dict[str, re.Pattern] = {
@@ -25,7 +25,7 @@ class PathNode:
     def __init__(self):
         self.children: Dict[str, PathNode] = None
         self.key: str | None = None
-        self.methods: Dict[str, Callable] | None = None
+        self.methods: Dict[str, Tuple[str, Callable]] | None = None
 
 class Path:
     def __init__(self):
@@ -57,29 +57,40 @@ class Path:
         if not node.methods:
             node.methods = {}
         for method in methods:
-            node.methods[method] = func
+            node.methods[method] = path, func
 
-    def match(self, path: str) -> Dict[http.HTTPMethod, Tuple[Callable, Dict[str, Any]]]:
+    def match(self, path: str, method: http.HTTPMethod | Literal['WEBSOCKET']) -> Tuple[Callable, Dict[str, Any]]:
         paths = path.split('/')[1:]
         if paths[-1] == '' and path != '/':
             paths = paths[:-1]
-        results = self._match(self.root, paths, {}, {})
-        return results
 
-    def _match(self, node: PathNode, paths: List[str], kwargs: Dict[str, Any], results: Dict[http.HTTPMethod, Tuple[Callable, Dict[str, Any]]]) -> List[Tuple[http.HTTPMethod, Callable, Dict[str, Any]]]:
+        results = self._match(self.root, paths, {})
+        if not results:
+            raise KeyError(0)
+        if method not in results:
+            raise KeyError(1)
+        results = results[method]
+        kwargs = {}
+        _paths = results[0].split('/')
+        for i in range(len(paths)):
+            if re.match(r'<.*?:.*?>', _paths[i + 1]):
+                kwargs[_paths[i + 1][1:].split(':')[0]] = unquote(paths[i])
+
+        return results[1], kwargs
+
+    def _match(self, node: PathNode, paths: List[str], results: Dict[http.HTTPMethod, Tuple[str, Callable]]) -> Dict[http.HTTPMethod, Tuple[str, Callable]]:
         if paths and node.children:
-            paths[0] = unquote(paths[0])
             if paths[0] in node.children:
-                results = self._match(node.children[paths[0]], paths[1:], kwargs, results)
+                results = self._match(node.children[paths[0]], paths[1:], results)
+            paths[0] = unquote(paths[0])
             for key, value in patterns.items():
                 if re.fullmatch(value['pattern'], paths[0]) and f'<:{key}>' in node.children:
-                    kwargs[node.children[f'<:{key}>'].key] = value['type'](paths[0])
-                    results = self._match(node.children[f'<:{key}>'], paths[1:], kwargs, results)
+                    results = self._match(node.children[f'<:{key}>'], paths[1:], results)
 
         if not paths and node.methods:
             for key, value in node.methods.items():
                 if key not in results:
-                    results[key] = (value, kwargs)
+                    results[key] = value
         return results
 
 paths: Path = Path()

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/CheeseAPI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CheeseAPI
-Version: 0.2.17
+Version: 0.2.19
 Summary: 一款web协程框架
 Home-page: https://github.com/CheeseUnknown/CheeseAPI
 Author: Cheese Unknown

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CheeseAPI
-Version: 0.2.17
+Version: 0.2.19
 Summary: 一款web协程框架
 Home-page: https://github.com/CheeseUnknown/CheeseAPI
 Author: Cheese Unknown

{CheeseAPI-0.2.17 → CheeseAPI-0.2.19}/setup.py

@@ -5,7 +5,7 @@ with open('./README.md', 'r', encoding = 'utf-8') as f:
 
 setuptools.setup(
     name = 'CheeseAPI',
-    version = '0.2.17',
+    version = '0.2.19',
     author = 'Cheese Unknown',
     author_email = 'cheese@cheese.ren',
     description = '一款web协程框架',