GNServer 0.0.0.0.34__py3-none-any.whl → 0.0.0.0.36__py3-none-any.whl

GNServer/_app.py

@@ -1,11 +1,8 @@
 
 
 
-import re
 import os
 import sys
-import uuid
-import decimal
 import asyncio
 import inspect
 import traceback
@@ -16,16 +13,17 @@ 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 typing import Any, AsyncGenerator, Union
 
 
 from gnobjects.net.objects import GNRequest, GNResponse, FileObject, CORSObject, TemplateObject
 from gnobjects.net.fastcommands import AllGNFastCommands, GNFastCommand
 
 
+from ._func_params_validation import register_schema_by_key, validate_params_by_key
+from ._cors_resolver import resolve_cors
 
-
-
+from ._routes import Route, _compile_path, _ensure_async, _convert_value
 
 
 
@@ -112,281 +110,11 @@ def guess_type(filename: str) -> str:
     return mime_map.get(ext, "application/octet-stream")
 
 
-import re
-from typing import List
-
-# regex для !{var}, поддерживает вложенность через точку
-TPL_VAR_RE = re.compile(r'(?<!\\)!\{([A-Za-z_][A-Za-z0-9_\.]*)\}')
-
-# список mime, которые считаем текстовыми
-TEXTUAL_MIME_PREFIXES = [
-    "text/",                       # text/html, text/css, text/plain
-]
-TEXTUAL_MIME_EXACT = {
-    "application/javascript",
-    "application/json",
-    "application/xml",
-    "application/xhtml+xml"
-}
-TEXTUAL_MIME_SUFFIXES = (
-    "+xml",  # например application/rss+xml
-    "+json", # application/ld+json
-)
-
-def extract_template_vars(filedata: bytes, mime: str) -> List[str]:
-    """
-    Ищет все !{var} в тексте, если MIME относится к текстовым.
-    """
-    mime = (mime or "").lower().strip()
-
-    # определяем, текстовый ли mime
-    is_textual = (
-        mime.startswith(tuple(TEXTUAL_MIME_PREFIXES))
-        or mime in TEXTUAL_MIME_EXACT
-        or mime.endswith(TEXTUAL_MIME_SUFFIXES)
-        or "javascript" in mime
-        or "json" in mime
-        or "xml" in mime
-    )
-
-    if not is_textual:
-        return []
-
-    try:
-        text = filedata.decode("utf-8", errors="ignore")
-    except Exception:
-        return []
-
-    return list(set(m.group(1) for m in TPL_VAR_RE.finditer(text)))
-
-
-import re
-from urllib.parse import urlparse
-
-def resolve_cors(origin_url: str, rules: list[str]) -> bool:
-    """
-    Возвращает origin_url если он матчится хотя бы с одним правилом.
-    Правила:
-      - "*.example.com"    -> wildcard (одна метка)
-      - "**.example.com"   -> globstar (0+ меток)
-      - "pages.*.core.gn"  -> смешанное
-      - "gn://*.site.tld" -> с проверкой схемы
-      - "!<regex>"         -> полное соответствие по regex к origin_url
-    """
-
-    if origin_url == 'gn:proxy:sys':
-        return True
-
-
-
 
 
-    origin = origin_url.rstrip("/")
-    pu = urlparse(origin)
-    scheme = (pu.scheme or "").lower()
-    host = (pu.hostname or "").lower()
-    port = pu.port  # может быть None
 
-    if not host:
-        return False
-
-    for rule in rules:
-        rule = rule.rstrip("/")
-
-        # 1) Регекс-правило
-        if rule.startswith("!"):
-            pattern = rule[1:]
-            if re.fullmatch(pattern, origin):
-                return True
-            continue
-
-        # 2) Разбор схемы/хоста в правиле
-        r_scheme = ""
-        r_host = ""
-        r_port = None
-
-        if "://" in rule:
-            pr = urlparse(rule)
-            r_scheme = (pr.scheme or "").lower()
-            # pr.netloc может содержать порт
-            netloc = pr.netloc.lower()
-            # разберём порт, если есть
-            if ":" in netloc and not netloc.endswith("]"):  # простая обработка IPv6 не требуется здесь
-                name, _, p = netloc.rpartition(":")
-                r_host = name
-                try:
-                    r_port = int(p)
-                except ValueError:
-                    r_port = None
-            else:
-                r_host = netloc
-        else:
-            r_host = rule.lower()
 
-        # схема в правиле задана -> должна совпасть
-        if r_scheme and r_scheme != scheme:
-            continue
-        # порт в правиле задан -> должен совпасть
-        if r_port is not None and r_port != port:
-            continue
 
-        # 3) Сопоставление хоста по шаблону с * и ** (по меткам)
-        if _host_matches_pattern(host, r_host):
-            return True
-
-    return False
-
-
-def _host_matches_pattern(host: str, pattern: str) -> bool:
-    """
-    Матчит host против pattern по доменным меткам:
-      - '*'  -> ровно одна метка
-      - '**' -> ноль или больше меток
-      Остальные метки — точное совпадение (без внутр. вайлдкардов).
-    Примеры:
-      host=pages.static.core.gn, pattern=**.core.gn -> True
-      host=pages.static.core.gn, pattern=pages.*.core.gn -> True
-      host=pages.static.core.gn, pattern=*.gn.gn -> False
-      host=abc.def.example.com, pattern=*.example.com -> False (нужно **.example.com)
-      host=abc.example.com,     pattern=*.example.com -> True
-    """
-    host_labels = host.split(".")
-    pat_labels = pattern.split(".")
-
-    # быстрый путь: точное совпадение без вайлдкардов
-    if "*" not in pattern:
-        return host == pattern
-
-    # рекурсивный матч с поддержкой ** (globstar)
-    def match(hi: int, pi: int) -> bool:
-        # оба дошли до конца
-        if pi == len(pat_labels) and hi == len(host_labels):
-            return True
-        # закончился паттерн — нет
-        if pi == len(pat_labels):
-            return False
-
-        token = pat_labels[pi]
-        if token == "**":
-            # два варианта:
-            #  - пропустить '**' (ноль меток)
-            if match(hi, pi + 1):
-                return True
-            #  - съесть одну метку (если есть) и остаться на '**'
-            if hi < len(host_labels) and match(hi + 1, pi):
-                return True
-            return False
-        elif token == "*":
-            # нужно съесть ровно одну метку
-            if hi < len(host_labels):
-                return match(hi + 1, pi + 1)
-            return False
-        else:
-            # точное совпадение метки
-            if hi < len(host_labels) and host_labels[hi] == token:
-                return match(hi + 1, pi + 1)
-            return False
-
-    return match(0, 0)
-
-
-
-
-@dataclass
-class Route:
-    method: str
-    path_expr: str
-    regex: Pattern[str]
-    param_types: dict[str, Callable[[str], Any]]
-    handler: Callable[..., Any]
-    name: str
-    cors: Optional[CORSObject]
-
-_PARAM_REGEX: dict[str, str] = {
-    "str":   r"[^/]+",
-    "path":  r".+",
-    "int":   r"\d+",
-    "float": r"[+-]?\d+(?:\.\d+)?",
-    "bool":  r"(?:true|false|1|0)",
-    "uuid":  r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-"
-             r"[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
-             r"[0-9a-fA-F]{12}",
-    "datetime": r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?",
-    "date":     r"\d{4}-\d{2}-\d{2}",
-    "time":     r"\d{2}:\d{2}:\d{2}(?:\.\d+)?",
-    "decimal":  r"[+-]?\d+(?:\.\d+)?",
-}
-
-_CONVERTER_FUNC: dict[str, Callable[[str], Any]] = {
-    "int":     int,
-    "float":   float,
-    "bool":    lambda s: s.lower() in {"1","true","yes","on"},
-    "uuid":    uuid.UUID,
-    "decimal": decimal.Decimal,
-    "datetime": datetime.datetime.fromisoformat,
-    "date":     datetime.date.fromisoformat,
-    "time":     datetime.time.fromisoformat,
-}
-
-def _compile_path(path: str) -> tuple[Pattern[str], dict[str, Callable[[str], Any]]]:
-    param_types: dict[str, Callable[[str], Any]] = {}
-    rx_parts: list[str] = ["^"]
-    i = 0
-    while i < len(path):
-        if path[i] != "{":
-            rx_parts.append(re.escape(path[i]))
-            i += 1
-            continue
-        j = path.index("}", i)
-        spec = path[i+1:j]
-        i = j + 1
-
-        if ":" in spec:
-            name, conv = spec.split(":", 1)
-        else:
-            name, conv = spec, "str"
-
-        if conv.startswith("^"):
-            rx = f"(?P<{name}>{conv})"
-            typ = str
-        else:
-            rx = f"(?P<{name}>{_PARAM_REGEX.get(conv, _PARAM_REGEX['str'])})"
-            typ = _CONVERTER_FUNC.get(conv, str)
-
-        rx_parts.append(rx)
-        param_types[name] = typ
-
-    rx_parts.append("$")
-    return re.compile("".join(rx_parts)), param_types
-
-def _convert_value(raw: str | list[str], ann: Any, fallback: Callable[[str], Any]) -> Any:
-    origin = get_origin(ann)
-    args   = get_args(ann)
-
-    if isinstance(raw, list) or origin is list:
-        subtype = args[0] if (origin is list and args) else str
-        if not isinstance(raw, list):
-            raw = [raw]
-        return [_convert_value(r, subtype, fallback) for r in raw]
-
-    # --- fix Union ---
-    if origin is Union:
-        for subtype in args:
-            try:
-                return _convert_value(raw, subtype, fallback)
-            except Exception:
-                continue
-        return raw  # если ни один тип не подошёл
-
-    conv = _CONVERTER_FUNC.get(ann, ann) if ann is not inspect._empty else fallback
-    return conv(raw) if callable(conv) else raw
-
-def _ensure_async(fn: Callable[..., Any]) -> Callable[..., Any]:
-    if inspect.iscoroutinefunction(fn) or inspect.isasyncgenfunction(fn):
-        return fn
-    async def wrapper(*args, **kw):
-        return fn(*args, **kw)
-    return wrapper
 
 class App:
     def __init__(self):
@@ -412,6 +140,7 @@ class App:
                     cors
                 )
             )
+            register_schema_by_key(fn)
             return fn
         return decorator
 
@@ -490,7 +219,7 @@ class App:
                     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:
+                if r.cors.allow_methods is not None and 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)
@@ -515,6 +244,12 @@ class App:
             params = set(sig.parameters.keys())
             kw = {k: v for k, v in kw.items() if k in params}
 
+            
+            rv = validate_params_by_key(kw, r.handler)
+            if rv is not None:
+                AllGNFastCommands.UnprocessableEntity({'dev_error': rv, 'user_error': f'Server request error {self.domain}'})
+
+
             if inspect.isasyncgenfunction(r.handler):
                 return r.handler(**kw)
 
@@ -532,7 +267,7 @@ class App:
                         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:
+                    if result._cors.allow_methods is not None and 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:
@@ -579,7 +314,6 @@ class App:
     def _init_sys_routes(self):
         @self.post('/!gn-vm-host/ping', cors=CORSObject())
         async def r_ping(request: GNRequest):
-            
             if request.client.ip != '127.0.0.1':
                 raise AllGNFastCommands.Forbidden()
             return GNResponse('ok', {'time': datetime.datetime.now(datetime.UTC).isoformat()})
@@ -615,11 +349,6 @@ class App:
                 if not stream: # если не стрим, то ждем конец quic стрима и запускаем обработку ответа
                     if event.end_stream:
                         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  # type: ignore
                         asyncio.create_task(self._handle_request(request, mode))
                         logger.debug(f'Отправлена задача разрешения пакета {request} route -> {request.route}')
@@ -660,9 +389,6 @@ class App:
                                 logger.debug(f'Закрываем стрим [{event.stream_id}]')
                                 return
 
-
-
-
                 queue.put_nowait(request)
 
                 # отдаем очередь в интерфейс
@@ -684,7 +410,6 @@ class App:
             request.client._data['remote_addr'] = self._quic._network_paths[0].addr
 
             try:
-                
                 response = await self._api.dispatchRequest(request)
 
                 if inspect.isasyncgen(response):
@@ -764,8 +489,6 @@ class App:
             if run is not None:
                 await run()
 
-            
-
 
             if wait:
                 await asyncio.Event().wait()

GNServer/_client.py

@@ -76,15 +76,15 @@ class GNExceptions:
                     
 
 from KeyisBTools import TTLDict
-from KeyisBTools.cryptography.sign import S1
-from KeyisBTools.cryptography import m1, hash
+from KeyisBTools.cryptography.sign import s2
+from KeyisBTools.cryptography import m1
+from KeyisBTools.cryptography.bytes import hash
 from KeyisBTools.models.serialization import serialize, deserialize
 from gnobjects.net.objects import GNRequest, GNResponse, Url
 
 from ._crt import crt_client
 
 
-s1 = S1()
 
 
 async def chain_async(first_item, rest: AsyncIterable) -> AsyncGenerator:
@@ -124,6 +124,9 @@ class AsyncClient:
             resuilt = self._dns_cache.get(domain)
             if resuilt is not None:
                 return resuilt
+            
+        if domain == 'api.dns.core':
+            return self.__dns_core__ipv4
 
         if ':' in domain and domain.split('.')[-1].split(':')[0].isdigit() and domain.split(':')[-1].isdigit():
             return domain
@@ -133,7 +136,7 @@ class AsyncClient:
                 self.__dns_client = AsyncClient()
 
             if self.__server_key is not None:
-                s = s1.sign(self.__server_key)
+                s = s2.sign(self.__server_key)
                 data = m1.encrypt(s, domain.encode(), serialize({'domain': domain}), hash(self.__server_key))
                 payload = {'sign': {'alg': 'KeyisB-c-s-m1', 'data': s}, 'data': data}
             else:

GNServer/_cors_resolver.py

@@ -0,0 +1,129 @@
+
+import re
+from urllib.parse import urlparse
+
+def resolve_cors(origin_url: str, rules: list[str]) -> bool:
+    """
+    Возвращает origin_url если он матчится хотя бы с одним правилом.
+    Правила:
+      - "*.example.com"    -> wildcard (одна метка)
+      - "**.example.com"   -> globstar (0+ меток)
+      - "pages.*.core.gn"  -> смешанное
+      - "gn://*.site.tld" -> с проверкой схемы
+      - "!<regex>"         -> полное соответствие по regex к origin_url
+    """
+
+    if origin_url == 'gn:proxy:sys':
+        return True
+
+    if rules in ('*', ['*']):
+        return True
+
+
+
+    origin = origin_url.rstrip("/")
+    pu = urlparse(origin)
+    scheme = (pu.scheme or "").lower()
+    host = (pu.hostname or "").lower()
+    port = pu.port  # может быть None
+
+    if not host:
+        return False
+
+    for rule in rules:
+        rule = rule.rstrip("/")
+
+        # 1) Регекс-правило
+        if rule.startswith("!"):
+            pattern = rule[1:]
+            if re.fullmatch(pattern, origin):
+                return True
+            continue
+
+        # 2) Разбор схемы/хоста в правиле
+        r_scheme = ""
+        r_host = ""
+        r_port = None
+
+        if "://" in rule:
+            pr = urlparse(rule)
+            r_scheme = (pr.scheme or "").lower()
+            # pr.netloc может содержать порт
+            netloc = pr.netloc.lower()
+            # разберём порт, если есть
+            if ":" in netloc and not netloc.endswith("]"):  # простая обработка IPv6 не требуется здесь
+                name, _, p = netloc.rpartition(":")
+                r_host = name
+                try:
+                    r_port = int(p)
+                except ValueError:
+                    r_port = None
+            else:
+                r_host = netloc
+        else:
+            r_host = rule.lower()
+
+        # схема в правиле задана -> должна совпасть
+        if r_scheme and r_scheme != scheme:
+            continue
+        # порт в правиле задан -> должен совпасть
+        if r_port is not None and r_port != port:
+            continue
+
+        # 3) Сопоставление хоста по шаблону с * и ** (по меткам)
+        if _host_matches_pattern(host, r_host):
+            return True
+
+    return False
+
+def _host_matches_pattern(host: str, pattern: str) -> bool:
+    """
+    Матчит host против pattern по доменным меткам:
+      - '*'  -> ровно одна метка
+      - '**' -> ноль или больше меток
+      Остальные метки — точное совпадение (без внутр. вайлдкардов).
+    Примеры:
+      host=pages.static.core.gn, pattern=**.core.gn -> True
+      host=pages.static.core.gn, pattern=pages.*.core.gn -> True
+      host=pages.static.core.gn, pattern=*.gn.gn -> False
+      host=abc.def.example.com, pattern=*.example.com -> False (нужно **.example.com)
+      host=abc.example.com,     pattern=*.example.com -> True
+    """
+    host_labels = host.split(".")
+    pat_labels = pattern.split(".")
+
+    # быстрый путь: точное совпадение без вайлдкардов
+    if "*" not in pattern:
+        return host == pattern
+
+    # рекурсивный матч с поддержкой ** (globstar)
+    def match(hi: int, pi: int) -> bool:
+        # оба дошли до конца
+        if pi == len(pat_labels) and hi == len(host_labels):
+            return True
+        # закончился паттерн — нет
+        if pi == len(pat_labels):
+            return False
+
+        token = pat_labels[pi]
+        if token == "**":
+            # два варианта:
+            #  - пропустить '**' (ноль меток)
+            if match(hi, pi + 1):
+                return True
+            #  - съесть одну метку (если есть) и остаться на '**'
+            if hi < len(host_labels) and match(hi + 1, pi):
+                return True
+            return False
+        elif token == "*":
+            # нужно съесть ровно одну метку
+            if hi < len(host_labels):
+                return match(hi + 1, pi + 1)
+            return False
+        else:
+            # точное совпадение метки
+            if hi < len(host_labels) and host_labels[hi] == token:
+                return match(hi + 1, pi + 1)
+            return False
+
+    return match(0, 0)

GNServer/_func_params_validation.py

@@ -0,0 +1,254 @@
+# fast_validate.py
+import inspect, datetime, functools, threading
+from inspect import Parameter, _empty
+from typing import Any, Union, get_origin, get_args
+
+_NoneType = type(None)
+_KEYTYPES = (str, bytes, int)
+
+def _is_int_not_bool(v): return isinstance(v, int) and not isinstance(v, bool)
+
+def _serializable_ok(v) -> bool:
+    if v is None or isinstance(v, (bool, float, str, bytes, datetime.datetime, datetime.time)):
+        return True
+    if _is_int_not_bool(v): return True
+    t = type(v)
+    if t is list:
+        for x in v:
+            if not _serializable_ok(x): return False
+        return True
+    if t is set:
+        for x in v:
+            if not _serializable_ok(x): return False
+        return True
+    if t is tuple:
+        for x in v:
+            if not _serializable_ok(x): return False
+        return True
+    if t is dict:
+        for k, vv in v.items():
+            if not isinstance(k, _KEYTYPES): return False
+            if not _serializable_ok(vv): return False
+        return True
+    return False
+
+@functools.lru_cache(maxsize=8192)
+def _compile_checker(ann: Any):
+    """
+    Компилирует аннотацию в быстрый чекер: (value) -> None | str.
+    Возвращает None, если значение валидно; иначе — строку/многострочную строку с ошибками.
+    Поддерживаются только типы из SerializableType.
+    """
+    if ann is _empty:
+        def chk(v):
+            if _serializable_ok(v):
+                return None
+            return f"значение не SerializableType: {type(v).__name__}({v!r})"
+        return chk
+
+    origin = get_origin(ann)
+    if origin is Union:
+        alts = tuple(_compile_checker(a) for a in get_args(ann))
+        types_str = " | ".join(_ann_to_str(a) for a in get_args(ann))
+        def chk(v):
+            for c in alts:
+                if c(v) is None:
+                    return None
+            return f"ожидалось {types_str}, получено {type(v).__name__}({v!r})"
+        return chk
+
+    # Примитивы
+    if ann is type(None) or ann is None:
+        return lambda v: None if v is None else f"ожидалось None, получено {type(v).__name__}({v!r})"
+    if ann is bool:
+        return lambda v: None if isinstance(v, bool) else f"ожидалось bool, получено {type(v).__name__}({v!r})"
+    if ann is int:
+        return lambda v: None if _is_int_not_bool(v) else f"ожидалось int, получено {type(v).__name__}({v!r})"
+    if ann is float:
+        return lambda v: None if isinstance(v, float) else f"ожидалось float, получено {type(v).__name__}({v!r})"
+    if ann is str:
+        return lambda v: None if isinstance(v, str) else f"ожидалось str, получено {type(v).__name__}({v!r})"
+    if ann is bytes:
+        return lambda v: None if isinstance(v, bytes) else f"ожидалось bytes, получено {type(v).__name__}({v!r})"
+    if ann is datetime.datetime:
+        return lambda v: None if isinstance(v, datetime.datetime) else f"ожидалось datetime.datetime, получено {type(v).__name__}({v!r})"
+    if ann is datetime.time:
+        return lambda v: None if isinstance(v, datetime.time) else f"ожидалось datetime.time, получено {type(v).__name__}({v!r})"
+
+    # Контейнеры
+    if origin is list:
+        (elem_t,) = get_args(ann) or (_empty,)
+        elem_chk = _compile_checker(elem_t)
+        def chk(v):
+            if type(v) is not list:
+                return f"ожидался list, получено {type(v).__name__}({v!r})"
+            i = 0
+            for x in v:
+                # сначала гейт SerializableType для элемента
+                if not _serializable_ok(x):
+                    return f"[{i}]: значение не SerializableType: {type(x).__name__}({x!r})"
+                e = elem_chk(x)
+                if e:
+                    return f"[{i}]: {e}"
+                i += 1
+            return None
+        return chk
+
+    if origin is set:
+        (elem_t,) = get_args(ann) or (_empty,)
+        elem_chk = _compile_checker(elem_t)
+        def chk(v):
+            if type(v) is not set:
+                return f"ожидался set, получено {type(v).__name__}({v!r})"
+            for x in v:
+                if not _serializable_ok(x):
+                    return f"set-elem: значение не SerializableType: {type(x).__name__}({x!r})"
+                e = elem_chk(x)
+                if e:
+                    return f"set-elem: {e}"
+            return None
+        return chk
+
+    if origin is tuple:
+        args = get_args(ann)
+        # Только Tuple[T, ...]
+        if len(args) == 2 and args[1] is ...:
+            elem_chk = _compile_checker(args[0])
+            def chk(v):
+                if type(v) is not tuple:
+                    return f"ожидался tuple, получено {type(v).__name__}({v!r})"
+                i = 0
+                for x in v:
+                    if not _serializable_ok(x):
+                        return f"[{i}]: значение не SerializableType: {type(x).__name__}({x!r})"
+                    e = elem_chk(x)
+                    if e:
+                        return f"[{i}]: {e}"
+                    i += 1
+                return None
+            return chk
+        return lambda _: "разрешён только Tuple[T, ...]"
+
+    if origin is dict:
+        kt, vt = (get_args(ann) + (_empty, _empty))[:2]
+        kchk = _compile_checker(kt) if kt is not _empty else None
+        vchk = _compile_checker(vt)
+        def chk(v):
+            if type(v) is not dict:
+                return f"ожидался dict, получено {type(v).__name__}({v!r})"
+            loc_errs = []
+            append = loc_errs.append
+            for k, vv in v.items():
+                # 1) базовое правило SerializableKey
+                if not isinstance(k, _KEYTYPES):
+                    append(f"некорректный ключ {k!r} ({type(k).__name__}); разрешены str|bytes|int")
+                # 2) если схема уточняет тип ключа — проверяем отдельно
+                if kchk:
+                    ek = kchk(k)
+                    if ek:
+                        # точная причина
+                        append(f"key: {ek}")
+                        # и общая подсказка, чтобы совпало с ожидаемым форматом из тестов
+                        append(f"некорректный ключ {k!r} ({type(k).__name__}); разрешены str|bytes|int")
+                # 3) проверка значения по схеме (всегда выполняем, даже если ключ сломан)
+                ev = vchk(vv)
+                if ev:
+                    for line in str(ev).splitlines():
+                        append(f"{k!r}: {line}")
+            if loc_errs:
+                return "\n".join(loc_errs)
+            return None
+        return chk
+
+    return lambda _: f"неподдерживаемая аннотация: {ann!r} (разрешены только типы из SerializableType)"
+
+
+def _ann_to_str(t):
+    o = get_origin(t)
+    if o is Union: return " | ".join(_ann_to_str(a) for a in get_args(t))
+    try: return t.__name__
+    except Exception: return str(t)
+
+class _Field:
+    __slots__ = ("name","required","checker")
+    def __init__(self, name, required, checker): self.name=name; self.required=required; self.checker=checker
+
+class Schema:
+    __slots__ = ("fields","names","has_kwargs")
+    def __init__(self, fields, names, has_kwargs): self.fields=fields; self.names=names; self.has_kwargs=has_kwargs
+
+_SCHEMA_CACHE: dict[Any, Schema] = {}
+_SCHEMA_LOCK = threading.Lock()
+
+def _build_schema_from_params(func_params) -> Schema:
+    pmap = dict(func_params)
+    fields = []
+    names = set()
+    has_kwargs = False
+    for name, p in pmap.items():
+        if p.kind == Parameter.VAR_KEYWORD:
+            has_kwargs = True; continue
+        if p.kind == Parameter.VAR_POSITIONAL:
+            continue
+        required = (p.default is _empty)  # Optional[...] не делает параметр необязательным
+        checker = _compile_checker(p.annotation)
+        fields.append(_Field(name, required, checker))
+        names.add(name)
+    return Schema(tuple(fields), frozenset(names), has_kwargs)
+
+def register_schema_by_key(func) -> Schema:
+    """Регистрируем схему по самой функции (делать на старте)."""
+    sc = _SCHEMA_CACHE.get(func)
+    if sc is not None: return sc
+    with _SCHEMA_LOCK:
+        sc = _SCHEMA_CACHE.get(func)
+        if sc is not None: return sc
+        sc = _build_schema_from_params(inspect.signature(func).parameters)
+        _SCHEMA_CACHE[func] = sc
+        return sc
+
+def get_schema_for_func(func) -> Schema:
+    sc = _SCHEMA_CACHE.get(func)
+    if sc is not None: return sc
+    # На всякий случай (если забыли зарегистрировать) — соберём и закешируем
+    return register_schema_by_key(func)
+
+def validate_params(params: dict, schema: Schema) -> str | None:
+    """
+    Валидирует dict по заранее скомпилированной Schema.
+    Возвращает None, если всё ок; иначе — многострочную строку со ВСЕМИ ошибками.
+    Гарантирует, что каждая строка ошибки начинается с "'<param>': ..." (полный путь виден).
+    """
+    errors = []
+    names = schema.names
+    has_kwargs = schema.has_kwargs
+
+    # Лишние ключи (если нет **kwargs) — собираем все
+    if not has_kwargs:
+        for k in params.keys():
+            if k not in names:
+                errors.append(f"Лишний параметр: '{k}' не принят сигнатурой.")
+
+    get = params.get
+    for f in schema.fields:
+        v = get(f.name, _empty)
+        if v is _empty:
+            if f.required:
+                errors.append(f"Отсутствует обязательный параметр '{f.name}'.")
+            continue
+
+        # Всегда зовём чекер, чтобы получить детальные сообщения по вложенным частям.
+        e = f.checker(v)
+        if e:
+            # Префиксуем КАЖДУЮ строку именем параметра, чтобы тесты видели "'d': b'k': ..."
+            lines = str(e).splitlines()
+            for line in lines:
+                errors.append(f"'{f.name}': {line}")
+
+    return None if not errors else "\n".join(errors)
+
+
+
+def validate_params_by_key(params: dict, func) -> str | None:
+    """В рантайме: передаём dict и саму функцию (схема уже в кеше)."""
+    return validate_params(params, get_schema_for_func(func))

GNServer/_routes.py

@@ -0,0 +1,107 @@
+
+import re
+import uuid
+import decimal
+import inspect
+import datetime
+from typing import Any, Callable, Dict, List, Optional, Pattern, Tuple, Union, AsyncGenerator
+from dataclasses import dataclass
+from typing import Any, Union, get_origin, get_args
+
+
+from gnobjects.net.objects import CORSObject
+
+@dataclass
+class Route:
+    method: str
+    path_expr: str
+    regex: Pattern[str]
+    param_types: dict[str, Callable[[str], Any]]
+    handler: Callable[..., Any]
+    name: str
+    cors: Optional[CORSObject]
+
+_PARAM_REGEX: dict[str, str] = {
+    "str":   r"[^/]+",
+    "path":  r".+",
+    "int":   r"\d+",
+    "float": r"[+-]?\d+(?:\.\d+)?",
+    "bool":  r"(?:true|false|1|0)",
+    "uuid":  r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-"
+             r"[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+             r"[0-9a-fA-F]{12}",
+    "datetime": r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?",
+    "date":     r"\d{4}-\d{2}-\d{2}",
+    "time":     r"\d{2}:\d{2}:\d{2}(?:\.\d+)?",
+    "decimal":  r"[+-]?\d+(?:\.\d+)?",
+}
+
+_CONVERTER_FUNC: dict[str, Callable[[str], Any]] = {
+    "int":     int,
+    "float":   float,
+    "bool":    lambda s: s.lower() in {"1","true","yes","on"},
+    "uuid":    uuid.UUID,
+    "decimal": decimal.Decimal,
+    "datetime": datetime.datetime.fromisoformat,
+    "date":     datetime.date.fromisoformat,
+    "time":     datetime.time.fromisoformat,
+}
+
+def _compile_path(path: str) -> tuple[Pattern[str], dict[str, Callable[[str], Any]]]:
+    param_types: dict[str, Callable[[str], Any]] = {}
+    rx_parts: list[str] = ["^"]
+    i = 0
+    while i < len(path):
+        if path[i] != "{":
+            rx_parts.append(re.escape(path[i]))
+            i += 1
+            continue
+        j = path.index("}", i)
+        spec = path[i+1:j]
+        i = j + 1
+
+        if ":" in spec:
+            name, conv = spec.split(":", 1)
+        else:
+            name, conv = spec, "str"
+
+        if conv.startswith("^"):
+            rx = f"(?P<{name}>{conv})"
+            typ = str
+        else:
+            rx = f"(?P<{name}>{_PARAM_REGEX.get(conv, _PARAM_REGEX['str'])})"
+            typ = _CONVERTER_FUNC.get(conv, str)
+
+        rx_parts.append(rx)
+        param_types[name] = typ
+
+    rx_parts.append("$")
+    return re.compile("".join(rx_parts)), param_types
+
+def _convert_value(raw: str | list[str], ann: Any, fallback: Callable[[str], Any]) -> Any:
+    origin = get_origin(ann)
+    args   = get_args(ann)
+
+    if isinstance(raw, list) or origin is list:
+        subtype = args[0] if (origin is list and args) else str
+        if not isinstance(raw, list):
+            raw = [raw]
+        return [_convert_value(r, subtype, fallback) for r in raw]
+
+    if origin is Union:
+        for subtype in args:
+            try:
+                return _convert_value(raw, subtype, fallback)
+            except Exception:
+                continue
+        return raw  # если ни один тип не подошёл
+
+    conv = _CONVERTER_FUNC.get(ann, ann) if ann is not inspect._empty else fallback
+    return conv(raw) if callable(conv) else raw
+
+def _ensure_async(fn: Callable[..., Any]) -> Callable[..., Any]:
+    if inspect.iscoroutinefunction(fn) or inspect.isasyncgenfunction(fn):
+        return fn
+    async def wrapper(*args, **kw):
+        return fn(*args, **kw)
+    return wrapper

GNServer/_template_resolver.py

@@ -0,0 +1,48 @@
+
+import re
+from typing import List
+
+# regex для !{var}, поддерживает вложенность через точку
+TPL_VAR_RE = re.compile(r'(?<!\\)!\{([A-Za-z_][A-Za-z0-9_\.]*)\}')
+
+# список mime, которые считаем текстовыми
+TEXTUAL_MIME_PREFIXES = [
+    "text/",                       # text/html, text/css, text/plain
+]
+TEXTUAL_MIME_EXACT = {
+    "application/javascript",
+    "application/json",
+    "application/xml",
+    "application/xhtml+xml"
+}
+TEXTUAL_MIME_SUFFIXES = (
+    "+xml",  # например application/rss+xml
+    "+json", # application/ld+json
+)
+
+def extract_template_vars(filedata: bytes, mime: str) -> List[str]:
+    """
+    Ищет все !{var} в тексте, если MIME относится к текстовым.
+    """
+    mime = (mime or "").lower().strip()
+
+    # определяем, текстовый ли mime
+    is_textual = (
+        mime.startswith(tuple(TEXTUAL_MIME_PREFIXES))
+        or mime in TEXTUAL_MIME_EXACT
+        or mime.endswith(TEXTUAL_MIME_SUFFIXES)
+        or "javascript" in mime
+        or "json" in mime
+        or "xml" in mime
+    )
+
+    if not is_textual:
+        return []
+
+    try:
+        text = filedata.decode("utf-8", errors="ignore")
+    except Exception:
+        return []
+
+    return list(set(m.group(1) for m in TPL_VAR_RE.finditer(text)))
+

{gnserver-0.0.0.0.34.dist-info → gnserver-0.0.0.0.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GNServer
-Version: 0.0.0.0.34
+Version: 0.0.0.0.36
 Summary: GNServer
 Home-page: https://github.com/KeyisB/libs/tree/main/GNServer
 Author: KeyisB

gnserver-0.0.0.0.36.dist-info/RECORD

@@ -0,0 +1,13 @@
+GNServer/__init__.py,sha256=RCYh6f0lwh-Xh-5fv0jZvbUE6x7l8xYJhbn-o8_ITlE,1551
+GNServer/_app.py,sha256=yHnpR30gCSDG2WL1a8fiLYmDeEc8YEaRh9UMo0PiqUA,18841
+GNServer/_client.py,sha256=wK5F_ilMX70tYEcWYRHvWyKGMaKA0ivvsUeg6PrEk9s,30249
+GNServer/_cors_resolver.py,sha256=U9IFGN7vpVsEM2smhuf5QGj8vYgs7HeFQwDdzWVVy9c,4832
+GNServer/_crt.py,sha256=SOmyX7zBiCY9EhVSekksQtBHgTIZVvdqNZ8Ni-E5Zow,1390
+GNServer/_func_params_validation.py,sha256=QnSX74khneQpJer9uVFGG7JcqpquzSce6CrAxFA2hUY,11361
+GNServer/_routes.py,sha256=bJnmQ8uEhPVQgy2tTqE5TEIM8aFXV-lVI7c2nG0rQwk,3384
+GNServer/_template_resolver.py,sha256=vdJYb_7PjIeTWq-Clr7jyj7QIvPBxplU7EqeOuMJ64c,1409
+gnserver-0.0.0.0.36.dist-info/licenses/LICENSE,sha256=WH_t7dKZyWJ5Ld07eYIkUG4Tv6zZWXtAdsUqYAUesn0,1084
+gnserver-0.0.0.0.36.dist-info/METADATA,sha256=Dkc11JmXE5UQH-8sB29LYnMnioJcdQ_8G1xCS8ZRD_E,830
+gnserver-0.0.0.0.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gnserver-0.0.0.0.36.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
+gnserver-0.0.0.0.36.dist-info/RECORD,,

gnserver-0.0.0.0.34.dist-info/RECORD

@@ -1,9 +0,0 @@
-GNServer/__init__.py,sha256=RCYh6f0lwh-Xh-5fv0jZvbUE6x7l8xYJhbn-o8_ITlE,1551
-GNServer/_app.py,sha256=77g8nGa1-5faslltJeffpU585T9xZKf7D7wm8EjBMyU,27610
-GNServer/_client.py,sha256=fq-n322jWQZSYj1IR4UjDlmf9sMDYExVGMMIgtlMiAw,30123
-GNServer/_crt.py,sha256=SOmyX7zBiCY9EhVSekksQtBHgTIZVvdqNZ8Ni-E5Zow,1390
-gnserver-0.0.0.0.34.dist-info/licenses/LICENSE,sha256=WH_t7dKZyWJ5Ld07eYIkUG4Tv6zZWXtAdsUqYAUesn0,1084
-gnserver-0.0.0.0.34.dist-info/METADATA,sha256=83WIyIrJaW3uyTn2DWrUIxTqQpatFS6VEoATt2DOXvQ,830
-gnserver-0.0.0.0.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gnserver-0.0.0.0.34.dist-info/top_level.txt,sha256=-UOUBuD4u7Qkb1o5PdcwyA3kx8xCH2lwy0tJHi26Wb4,9
-gnserver-0.0.0.0.34.dist-info/RECORD,,