GNServer 0.0.0.0.29__py3-none-any.whl → 0.0.0.0.31__py3-none-any.whl

GNServer/_app.py

@@ -2,32 +2,36 @@
 
 
 import re
+import os
 import sys
 import uuid
-import anyio
 import decimal
 import asyncio
 import inspect
 import traceback
 import datetime
-import KeyisBClient
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Pattern, Tuple, Union, AsyncGenerator
+from typing import Any, Callable, Dict, List, Optional, Pattern, Tuple, Union, AsyncGenerator
 from dataclasses import dataclass
 from aioquic.asyncio.server import serve
 from aioquic.asyncio.protocol import QuicConnectionProtocol
 from aioquic.quic.configuration import QuicConfiguration
 from aioquic.quic.events import QuicEvent, StreamDataReceived
 from typing import Any, AsyncGenerator, Union, get_origin, get_args
-from urllib.parse import parse_qs
 
-from KeyisBClient import gn
-import aiofiles
-import sys
-import os
+
+from gnobjects.net.objects import GNRequest, GNResponse, FileObject, CORSObject, TemplateObject
+from gnobjects.net.fastcommands import AllGNFastCommands, GNFastCommand
+
+
+
+
+
+
+
 
 try:
     if not sys.platform.startswith("win"):
-        import uvloop
+        import uvloop # type: ignore
         asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
 except ImportError:
     print("uvloop не установлен")
@@ -45,115 +49,7 @@ console = logging.StreamHandler()
 console.setLevel(logging.INFO)
 console.setFormatter(logging.Formatter("[GNServer] %(name)s: %(levelname)s: %(message)s"))
 
-PayloadType = Optional[Union[int, str, list, tuple, dict]]
-
-class _BaseEXception(Exception):
-    def __init__(self, code: str, name="", message: Optional[str] = None, payload: PayloadType = None):
-        self._code = code
-        self._name = name
-        self._message = message
-        self._payload = payload
-
-    def assembly(self):
-        """
-        Собирает ошибку в ответ типа `GNResponse`
-        """
-        payload: dict = {'name': self._name}
-
-        if self._message is not None:
-            payload['message'] = self._message
-
-        if self._payload is not None:
-            payload['payload'] = self._payload
-
-        return gn.GNResponse(f'gn:error:{self._code}', payload=payload)
-
-
-class GNExceptions:
-    class UnprocessableEntity(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Некорректные данные
-            """
-            super().__init__('422', "Unprocessable Entity", message=message, payload=payload)
-
-    class BadRequest(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # неправильного синтаксис url или параметров
-            """
-            super().__init__('400', "Bad Request", message=message, payload=payload)
 
-    class Forbidden(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Доступ запрещён, даже при наличии авторизации
-            """
-            super().__init__('403', "Forbidden", message=message, payload=payload)
-
-
-    class NotFound(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Ресурс не найден
-            """
-            super().__init__('404', "Not Found", message=message, payload=payload)
-
-
-    class MethodNotAllowed(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Метод запроса не поддерживается данным ресурсом
-            """
-            super().__init__('405', "Method Not Allowed", message=message, payload=payload)
-
-
-    class Conflict(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Конфликт состояния ресурса (например, дубликат)
-            """
-            super().__init__('409', "Conflict", message=message, payload=payload)
-
-
-    class InternalServerError(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Внутренняя ошибка сервера
-            """
-            super().__init__('500', "Internal Server Error", message=message, payload=payload)
-
-
-    class NotImplemented(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Метод или функционал ещё не реализован
-            """
-            super().__init__('501', "Not Implemented", message=message, payload=payload)
-
-
-    class BadGateway(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Ошибка шлюза или прокси при обращении к апстриму
-            """
-            super().__init__('502', "Bad Gateway", message=message, payload=payload)
-
-
-    class ServiceUnavailable(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Сервис временно недоступен
-            """
-            super().__init__('503', "Service Unavailable", message=message, payload=payload)
-
-
-    class GatewayTimeout(_BaseEXception):
-        def __init__(self, message: Optional[str] = None, payload: PayloadType = None):
-            """
-            # Таймаут при обращении к апстриму
-            """
-            super().__init__('504', "Gateway Timeout", message=message, payload=payload)
 
 def guess_type(filename: str) -> str:
     """
@@ -404,7 +300,7 @@ class Route:
     param_types: dict[str, Callable[[str], Any]]
     handler: Callable[..., Any]
     name: str
-    cors: Optional[gn.CORSObject]
+    cors: Optional[CORSObject]
 
 _PARAM_REGEX: dict[str, str] = {
     "str":   r"[^/]+",
@@ -495,12 +391,12 @@ def _ensure_async(fn: Callable[..., Any]) -> Callable[..., Any]:
 class App:
     def __init__(self):
         self._routes: List[Route] = []
-        self._cors: Optional[gn.CORSObject] = None
-        self._events: Dict[str, Dict[str, Union[str, Callable]]] = {}
+        self._cors: Optional[CORSObject] = None
+        self._events: Dict[str, List[Dict[str, Union[Any, Callable]]]] = {}
 
-        self.domain: str = None
+        self.domain: str = None # type: ignore
 
-    def route(self, method: str, path: str, cors: Optional[gn.CORSObject] = None):
+    def route(self, method: str, path: str, cors: Optional[CORSObject] = None):
         if path == '/':
             path = ''
         def decorator(fn: Callable[..., Any]):
@@ -519,25 +415,25 @@ class App:
             return fn
         return decorator
 
-    def get(self, path: str, *, cors: Optional[gn.CORSObject] = None):
+    def get(self, path: str, *, cors: Optional[CORSObject] = None):
         return self.route("GET", path, cors)
 
-    def post(self, path: str, *, cors: Optional[gn.CORSObject] = None):
+    def post(self, path: str, *, cors: Optional[CORSObject] = None):
         return self.route("POST", path, cors)
 
-    def put(self, path: str, *, cors: Optional[gn.CORSObject] = None):
+    def put(self, path: str, *, cors: Optional[CORSObject] = None):
         return self.route("PUT", path, cors)
 
-    def delete(self, path: str, *, cors: Optional[gn.CORSObject] = None):
+    def delete(self, path: str, *, cors: Optional[CORSObject] = None):
         return self.route("DELETE", path, cors)
 
     
-    def setRouteCors(self, cors: Optional[gn.CORSObject] = None):
+    def setRouteCors(self, cors: Optional[CORSObject] = None):
         self._cors = cors
 
 
     def addEventListener(self, name: str):
-        def decorator(fn: Callable[Optional[dict], Any]):
+        def decorator(fn: Callable[[Optional[dict]], Any]):
             events = self._events.get(name, [])
             events.append({
                 'func': fn,
@@ -557,12 +453,12 @@ class App:
                 is_async = data['async']
 
                 if not is_async:
-                    if payload in data['parameters']:
+                    if payload in data['parameters']: # type: ignore
                         func(payload=payload)
                     else:
                         func()
                 else:
-                    if payload in data['parameters']:
+                    if payload in data['parameters']: # type: ignore
                         await func(payload=payload)
                     else:
                         await func()
@@ -573,8 +469,8 @@ class App:
 
 
     async def dispatchRequest(
-        self, request: gn.GNRequest
-    ) -> Union[gn.GNResponse, AsyncGenerator[gn.GNResponse, None]]:
+        self, request: GNRequest
+    ) -> Union[GNResponse, AsyncGenerator[GNResponse, None]]:
         path    = request.url.path
         method  = request.method.upper()
         cand    = {path, path.rstrip("/") or "/", f"{path}/"}
@@ -589,13 +485,13 @@ class App:
             if r.method != method:
                 continue
 
-            if r.cors is not None and r.cors._allow_origins is not None:
+            if r.cors is not None and r.cors.allow_origins is not None:
                 if request._origin is None:
-                    return gn.GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url.'})
-                if not resolve_cors(request._origin, r.cors._allow_origins):
-                    return gn.GNResponse("gn:backend:802", {'error': 'Cors error: origin'})
-                if request.method not in r.cors._allow_methods and '*' not in r.cors._allow_methods:
-                    return gn.GNResponse("gn:backend:803", {'error': 'Cors error: method'})
+                    return GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url.'})
+                if not resolve_cors(request._origin, r.cors.allow_origins):
+                    return GNResponse("gn:backend:802", {'error': 'Cors error: origin'})
+                if request.method not in r.cors.allow_methods and '*' not in r.cors.allow_methods:
+                    return GNResponse("gn:backend:803", {'error': 'Cors error: method'})
 
             sig = inspect.signature(r.handler)
             def _ann(name: str):
@@ -607,7 +503,7 @@ class App:
                 for name, val in m.groupdict().items()
             }
 
-            for qn, qvals in parse_qs(request.url.query, keep_blank_values=True).items():
+            for qn, qvals in request.url.params.items():
                 if qn in kw:
                     continue
                 raw = qvals if len(qvals) > 1 else qvals[0]
@@ -623,21 +519,21 @@ class App:
                 return r.handler(**kw)
 
             result = await r.handler(**kw)
-            if isinstance(result, gn.GNResponse):
+            if isinstance(result, GNResponse):
                 if r.cors is None:
                     if result._cors is None:
                         result._cors = self._cors
                 else:
                     result._cors = r.cors
 
-                if result._cors is not None and result._cors != r.cors and result._cors._allow_origins is not None:
+                if result._cors is not None and result._cors != r.cors and result._cors.allow_origins is not None:
                     if request._origin is None:
-                        print(result._cors._allow_origins)
-                        return gn.GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url. [2]'})
-                    if not resolve_cors(request._origin, result._cors._allow_origins):
-                        return gn.GNResponse("gn:backend:802", {'error': 'Cors error: origin'})
-                    if request.method not in result._cors._allow_methods and '*' not in result._cors._allow_methods:
-                        return gn.GNResponse("gn:backend:803", {'error': 'Cors error: method'})
+                        print(result._cors.allow_origins)
+                        return GNResponse("gn:backend:801", {'error': 'Cors error. Route has cors but request has no origin url. [2]'})
+                    if not resolve_cors(request._origin, result._cors.allow_origins):
+                        return GNResponse("gn:backend:802", {'error': 'Cors error: origin'})
+                    if request.method not in result._cors.allow_methods and '*' not in result._cors.allow_methods:
+                        return GNResponse("gn:backend:803", {'error': 'Cors error: method'})
                 return result
             else:
                 raise TypeError(
@@ -645,11 +541,11 @@ class App:
                 )
 
         if allowed:
-            raise GNExceptions.MethodNotAllowed()
-        raise GNExceptions.NotFound()
+            raise AllGNFastCommands.MethodNotAllowed()
+        raise AllGNFastCommands.NotFound()
 
 
-    def fastFile(self, path: str, file_path: str, cors: Optional[gn.CORSObject] = None, template: Optional[gn.TemplateObject] = None, payload: Optional[dict] = None):
+    def fastFile(self, path: str, file_path: str, cors: Optional[CORSObject] = None, template: Optional[TemplateObject] = None, payload: Optional[dict] = None):
         @self.get(path)
         async def r_static():
             nonlocal file_path
@@ -657,13 +553,13 @@ class App:
                 file_path = file_path[:-1]
                 
             if not os.path.isfile(file_path):
-                raise GNExceptions.NotFound()
+                raise AllGNFastCommands.NotFound()
 
-            fileObject = gn.FileObject(file_path, template)
-            return gn.GNResponse('ok', payload=payload, files=fileObject, cors=cors)
+            fileObject = FileObject(file_path, template)
+            return GNResponse('ok', payload=payload, files=fileObject, cors=cors)
 
 
-    def static(self, path: str, dir_path: str, cors: Optional[gn.CORSObject] = None, template: Optional[gn.TemplateObject] = None, payload: Optional[dict] = None):
+    def static(self, path: str, dir_path: str, cors: Optional[CORSObject] = None, template: Optional[TemplateObject] = None, payload: Optional[dict] = None):
         @self.get(f"{path}/{{_path:path}}")
         async def r_static(_path: str):
             file_path = os.path.join(dir_path, _path)
@@ -672,21 +568,21 @@ class App:
                 file_path = file_path[:-1]
                 
             if not os.path.isfile(file_path):
-                raise GNExceptions.NotFound()
+                raise AllGNFastCommands.NotFound()
             
-            fileObject = gn.FileObject(file_path, template)
-            return gn.GNResponse('ok', payload=payload, files=fileObject, cors=cors)
+            fileObject = FileObject(file_path, template)
+            return GNResponse('ok', payload=payload, files=fileObject, cors=cors)
 
 
 
 
     def _init_sys_routes(self):
-        @self.post('/!gn-vm-host/ping', cors=gn.CORSObject(None))
-        async def r_ping(request: gn.GNRequest):
+        @self.post('/!gn-vm-host/ping', cors=CORSObject())
+        async def r_ping(request: GNRequest):
             
             if request.client.ip != '127.0.0.1':
-                raise GNExceptions.Forbidden()
-            return gn.GNResponse('ok', {'time': datetime.datetime.now(datetime.UTC).isoformat()})
+                raise AllGNFastCommands.Forbidden()
+            return GNResponse('ok', {'time': datetime.datetime.now(datetime.UTC).isoformat()})
 
 
 
@@ -695,7 +591,7 @@ class App:
             super().__init__(*a, **kw)
             self._api = api
             self._buffer: Dict[int, bytearray] = {}
-            self._streams: Dict[int, Tuple[asyncio.Queue[Optional[gn.GNRequest]], bool]] = {}
+            self._streams: Dict[int, Tuple[asyncio.Queue[Optional[GNRequest]], bool]] = {}
 
         def quic_event_received(self, event: QuicEvent):
             if isinstance(event, StreamDataReceived):
@@ -710,7 +606,7 @@ class App:
                 
                     
                 # получаем длинну пакета
-                mode, stream, lenght = gn.GNRequest.type(buf)
+                mode, stream, lenght = GNRequest.type(buf)
 
                 if mode not in (1, 2): # не наш пакет
                     logger.debug(f'Пакет отклонен: mode пакета {mode}. Разрешен 1, 2')
@@ -718,13 +614,13 @@ class App:
                 
                 if not stream: # если не стрим, то ждем конец quic стрима и запускаем обработку ответа
                     if event.end_stream:
-                        request = gn.GNRequest.deserialize(buf, mode)
+                        request = GNRequest.deserialize(buf, mode)
                         # request.stream_id = event.stream_id
                         # loop = asyncio.get_event_loop()
                         # request.fut = loop.create_future()
 
 
-                        request.stream_id = event.stream_id
+                        request.stream_id = event.stream_id  # type: ignore
                         asyncio.create_task(self._handle_request(request, mode))
                         logger.debug(f'Отправлена задача разрешения пакета {request} route -> {request.route}')
 
@@ -744,11 +640,11 @@ class App:
                 del buf[:lenght]
 
                 # формируем запрос
-                request = gn.GNRequest.deserialize(data, mode)
+                request = GNRequest.deserialize(data, mode)
 
                 logger.debug(request, f'event.stream_id -> {event.stream_id}')
 
-                request.stream_id = event.stream_id
+                request.stream_id = event.stream_id  # type: ignore
 
                 queue, inapi = self._streams.setdefault(event.stream_id, (asyncio.Queue(), False))
 
@@ -780,10 +676,10 @@ class App:
                                 break
                             yield chunk
 
-                    request._stream = w
+                    request._stream = w  # type: ignore
                     asyncio.create_task(self._handle_request(request, mode))
 
-        async def _handle_request(self, request: gn.GNRequest, mode: int):
+        async def _handle_request(self, request: GNRequest, mode: int):
 
             request.client._data['remote_addr'] = self._quic._network_paths[0].addr
 
@@ -794,43 +690,36 @@ class App:
                 if inspect.isasyncgen(response):
                     async for chunk in response:  # type: ignore[misc]
                         chunk._stream = True
-                        chunk = await self.resolve_response(chunk)
-                        self._quic.send_stream_data(request.stream_id, chunk.serialize(mode), end_stream=False)
-                        self.transmit()
+                        await self.sendResponse(request, chunk, mode, False)
                         
-                    l = gn.GNResponse('gn:end-stream')
-                    l._stream = True
-                    l = self.resolve_response(l)
-                    self._quic.send_stream_data(request.stream_id, l.serialize(mode), end_stream=True)
-                    self.transmit()
+                    resp = GNResponse('gn:end-stream')
+                    resp._stream = True
+
+                    await self.sendResponse(request, resp, mode)
                     return
 
+                if not isinstance(response, GNResponse):
+                    await self.sendResponse(request, AllGNFastCommands.InternalServerError(), mode)
+                    return
 
-                response = await self.resolve_response(response)
-                self._quic.send_stream_data(request.stream_id, response.serialize(mode), end_stream=True)
-                logger.debug(f'Отправлен на сервер ответ -> {response.command} {response.payload if response.payload and len((response.payload)) < 200 else ''}')
-                self.transmit()
+                await self.sendResponse(request, response, mode)
+                logger.debug(f'Отправлен на сервер ответ -> {response.command} {response.payload if response.payload and len(str(response.payload)) < 200 else ''}')
             except Exception as e:
-                if isinstance(e, _BaseEXception):
-                    e: GNExceptions.UnprocessableEntity = e
-                    r = e.assembly()
-                    return r
+                if isinstance(e, GNFastCommand):
+                    await self.sendResponse(request, e, mode)
                 else:
                     logger.error('GNServer: error\n'  + traceback.format_exc())
 
-                    response = gn.GNResponse('gn:backend:500')
-                    self._quic.send_stream_data(request.stream_id, response.serialize(mode), end_stream=True)
-                    self.transmit()
+                    await self.sendResponse(request, AllGNFastCommands.InternalServerError(), mode)
             
-        async def resolve_response(self, response: gn.GNResponse) -> gn.GNResponse:
-            await response.assembly()
-
-            return response
 
         
- 
+        async def sendResponse(self, request: GNRequest, response: GNResponse, mode: int, end_stream: bool = True):
+            await response.assembly()
 
 
+            self._quic.send_stream_data(request.stream_id, response.serialize(mode), end_stream=end_stream) # type: ignore
+            self.transmit()
 
     def run(
         self,
@@ -858,7 +747,7 @@ class App:
         cfg = QuicConfiguration(
             alpn_protocols=["gn:backend"], is_client=False, idle_timeout=idle_timeout
         )
-        cfg.load_cert_chain(cert_path, key_path)
+        cfg.load_cert_chain(cert_path, key_path) # type: ignore
 
         async def _main():