gnobjects 0.0.0.0.1__py3-none-any.whl

gnobjects/__init__.py

@@ -0,0 +1,31 @@
+"""
+Copyright (C) 2024 KeyisB. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to use the Software exclusively for
+projects related to the GN or GW systems, including personal,
+educational, and commercial purposes, subject to the following
+conditions:
+
+1. Copying, modification, merging, publishing, distribution,
+sublicensing, and/or selling copies of the Software are
+strictly prohibited.
+2. The licensee may use the Software only in its original,
+unmodified form.
+3. All copies or substantial portions of the Software must
+remain unaltered and include this copyright notice and these terms of use.
+4. Use of the Software for projects not related to GN or
+GW systems is strictly prohibited.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR
+A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+"""
+

gnobjects/net/_func.py

@@ -0,0 +1,192 @@
+
+def guess_type(filename: str) -> str:
+    """
+    Возвращает актуальный MIME-тип по расширению файла.
+    Только современные и часто используемые типы.
+    """
+    ext = filename.lower().rsplit('.', 1)[-1] if '.' in filename else ''
+
+    mime_map = {
+        # 🔹 Текст и данные
+        "txt": "text/plain",
+        "html": "text/html",
+        "css": "text/css",
+        "csv": "text/csv",
+        "xml": "application/xml",
+        "json": "application/json",
+        "js": "application/javascript",
+
+        # 🔹 Изображения (актуальные для веба)
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "png": "image/png",
+        "gif": "image/gif",
+        "webp": "image/webp",
+        "svg": "image/svg+xml",
+        "avif": "image/avif",
+
+        # 🔹 Видео (современные форматы)
+        "mp4": "video/mp4",
+        "webm": "video/webm",
+
+        # 🔹 Аудио (современные форматы)
+        "mp3": "audio/mpeg",
+        "ogg": "audio/ogg",
+        "oga": "audio/ogg",
+        "m4a": "audio/mp4",
+        "flac": "audio/flac",
+
+        # 🔹 Архивы
+        "zip": "application/zip",
+        "gz": "application/gzip",
+        "tar": "application/x-tar",
+        "7z": "application/x-7z-compressed",
+        "rar": "application/vnd.rar",
+
+        # 🔹 Документы (актуальные офисные)
+        "pdf": "application/pdf",
+        "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+
+        # 🔹 Шрифты
+        "woff": "font/woff",
+        "woff2": "font/woff2",
+        "ttf": "font/ttf",
+        "otf": "font/otf",
+    }
+
+    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
+import asyncio
+from functools import lru_cache
+from typing import Dict, Any
+
+_SIGILS = (b'%', b'!', b'&')
+_PATTERNS: dict[bytes, re.Pattern[bytes]] = {
+    s: re.compile(rb'(?<!\\)' + re.escape(s) + rb'\{([A-Za-z_][A-Za-z0-9_\.]*)\}')
+    for s in _SIGILS
+}
+
+@lru_cache(maxsize=4096)
+def _split_path(path: str) -> tuple[str, ...]:
+    return tuple(path.split('.'))
+
+def _resolve(path: str, ctx: Dict[str, Any]) -> Any:
+    cur: Any = ctx
+    for k in _split_path(path):
+        if not isinstance(cur, dict) or k not in cur:
+            raise KeyError(path)
+        cur = cur[k]
+    return cur
+
+def make_renderer(sigil: bytes = b'%'):
+    """
+    Возвращает рендер для одного сигила. Работает с bytes.
+    """
+    if sigil not in _PATTERNS:
+        raise ValueError(f"unsupported sigil: {sigil!r}")
+    rx = _PATTERNS[sigil]
+    esc_seq = b'\\' + sigil + b'{'
+    unesc_seq = sigil + b'{'
+
+    def render(data: bytes, ctx: Dict[str, Any], *, keep_unresolved: bool = False) -> bytes:
+        parts: list[bytes] = []
+        append = parts.append
+        last = 0
+        finditer = rx.finditer
+
+        for m in finditer(data):
+            start, end = m.span()
+            append(data[last:start])
+
+            key = m.group(1).decode('utf-8')
+            try:
+                val = _resolve(key, ctx)
+                append(b"" if val is None else str(val).encode('utf-8'))
+            except KeyError:
+                if keep_unresolved:
+                    append(data[start:end])
+                else:
+                    raise
+            last = end
+
+        if last < len(data):
+            append(data[last:])
+
+        out = b''.join(parts)
+        if esc_seq in out:
+            out = out.replace(esc_seq, unesc_seq)
+        return out
+
+    return render
+
+# предсобранные
+render_pct = make_renderer(b'%')
+render_bang = make_renderer(b'!')
+render_amp = make_renderer(b'&')
+
+# асинхронные обёртки
+_BIG = 256 * 1024
+
+async def render_pct_async(data: bytes, ctx: Dict[str, Any], *, keep_unresolved: bool = False) -> bytes:
+    return render_pct(data, ctx, keep_unresolved=keep_unresolved) if len(data) < _BIG \
+        else await asyncio.to_thread(render_pct, data, ctx, keep_unresolved=keep_unresolved)
+
+async def render_bang_async(data: bytes, ctx: Dict[str, Any], *, keep_unresolved: bool = False) -> bytes:
+    return render_bang(data, ctx, keep_unresolved=keep_unresolved) if len(data) < _BIG \
+        else await asyncio.to_thread(render_bang, data, ctx, keep_unresolved=keep_unresolved)
+
+async def render_amp_async(data: bytes, ctx: Dict[str, Any], *, keep_unresolved: bool = False) -> bytes:
+    return render_amp(data, ctx, keep_unresolved=keep_unresolved) if len(data) < _BIG \
+        else await asyncio.to_thread(render_amp, data, ctx, keep_unresolved=keep_unresolved)

gnobjects/net/_transport_pr_obj.py

@@ -0,0 +1,294 @@
+import re
+from typing import Iterable, Optional, List, NamedTuple
+from functools import lru_cache
+
+_VERSION_RE = re.compile(r"^\d+(?:\.\d+)*(?:-\d+(?:\.\d+)*)?$").match
+_is_ver = _VERSION_RE
+
+
+def _to_list(v: str) -> List[int]:
+    return [int(x) for x in v.split(".")] if v else []
+
+
+def _cmp(a: List[int], b: List[int]) -> int:
+    n = max(len(a), len(b))
+    a += [0] * (n - len(a))
+    b += [0] * (n - len(b))
+    return (a > b) - (a < b)
+
+
+class _VersionRange:
+    """Одиночная версия, диапазон a‑b, 'last' или wildcard (None)."""
+
+    __slots__ = ("raw", "kind", "lo", "hi", "single")
+
+    def __init__(self, raw: Optional[str]):
+        self.raw = raw             # None == wildcard
+        if raw is None:
+            self.kind = "wild"
+            return
+        if raw.lower() == "last":
+            self.kind = "single_last"
+            return
+        if "-" in raw:
+            self.kind = "range"
+            lo, hi = raw.split("-", 1)
+            self.lo = _to_list(lo)
+            self.hi = _to_list(hi)
+        else:
+            self.kind = "single"
+            self.single = _to_list(raw)
+
+    def contains(self, ver: Optional[str]) -> bool:  # noqa: C901
+        if self.kind == "wild":
+            return True
+        ver = ver or "last"
+        if self.kind == "single_last":
+            return ver.lower() == "last"
+        if ver.lower() == "last":
+            return False
+        v = _to_list(ver)
+        if self.kind == "single":
+            return _cmp(self.single[:], v) == 0
+        return _cmp(self.lo[:], v) <= 0 <= _cmp(v, self.hi[:])
+
+    # for debugging / logs
+    def __str__(self) -> str:
+        return self.raw or "last"
+
+
+class _Pat(NamedTuple):
+    gn_ver: _VersionRange
+    p1_name: Optional[str]
+    p1_ver: _VersionRange
+    p1_need_last: bool
+    p2_name: Optional[str]
+    p2_ver: _VersionRange
+    p2_need_last: bool
+
+
+@lru_cache(maxsize=2048)
+def _compile_full_pattern(pat: str) -> _Pat:
+    t = pat.split(":")
+    gn_ver = _VersionRange(None)
+    if t and t[0].lower() == "gn":
+        t.pop(0)
+        gn_ver = _VersionRange(t.pop(0)) if t and (_is_ver(t[0]) or t[0].lower() == "last") else _VersionRange(None)
+
+    p2_name = p2_ver = p1_name = p1_ver = None
+    p2_need_last = p1_need_last = False
+
+    if t:
+        if _is_ver(t[-1]) or t[-1].lower() == "last":
+            p2_ver = _VersionRange(t.pop())
+        else:
+            p2_need_last = True
+        p2_name = t.pop() if t else None
+
+    if t:
+        if _is_ver(t[-1]) or t[-1].lower() == "last":
+            p1_ver = _VersionRange(t.pop())
+        else:
+            p1_need_last = True
+        p1_name = t.pop() if t else None
+
+    if t:
+        raise ValueError(f"bad pattern {pat!r}")
+
+    return _Pat(
+        gn_ver=gn_ver,
+        p1_name=None if p1_name is None else p1_name.lower(),
+        p1_ver=p1_ver or _VersionRange(None),
+        p1_need_last=p1_need_last,
+        p2_name=None if p2_name is None else p2_name.lower(),
+        p2_ver=p2_ver or _VersionRange(None),
+        p2_need_last=p2_need_last,
+    )
+
+
+class _LeafPat(NamedTuple):
+    name: Optional[str]
+    ver: _VersionRange
+    need_last: bool
+
+
+@lru_cache(maxsize=4096)
+def _compile_leaf_pattern(pat: str) -> _LeafPat:
+    """
+    pattern ::= NAME
+              | NAME ':' VERSION
+              | VERSION             (# имя опущено)
+    """
+    if ":" not in pat:
+        if _is_ver(pat) or pat.lower() == "last":
+            return _LeafPat(name=None, ver=_VersionRange(pat), need_last=False)
+        return _LeafPat(name=pat.lower(), ver=_VersionRange(None), need_last=True)
+
+    name, ver = pat.split(":", 1)
+    name = name.lower() or None
+    need_last = False
+    if not ver:
+        need_last = True
+        ver_range = _VersionRange(None)
+    else:
+        ver_range = _VersionRange(ver)
+    return _LeafPat(name=name, ver=ver_range, need_last=need_last)
+
+
+class GNProtocol:
+    """
+    Строка формата  gn[:gnVer]:transport[:ver1]:route[:ver2]
+    """
+
+    __slots__ = (
+        "raw",
+        "gn_ver_raw",
+        "gn_ver",
+        "trnsp_name",
+        "trnsp_ver_raw",
+        "trnsp_ver",
+        "route_name",
+        "route_ver_raw",
+        "route_ver",
+        "_gn_leaf",
+        "_trnsp_leaf",
+        "_route_leaf",
+    )
+
+    # ---------------------------------------------------------------- init ---
+    def __init__(self, raw: str):
+        self.raw = raw
+        self._parse()
+        self._gn_leaf = self._LeafProto("gn", self.gn_ver_raw)
+        self._trnsp_leaf = self._LeafProto(self.trnsp_name, self.trnsp_ver_raw)
+        self._route_leaf = self._LeafProto(self.route_name, self.route_ver_raw)
+
+    # ---------------------------------------------------------------- parse --
+    @staticmethod
+    def _take_ver(tokens: List[str]) -> Optional[str]:
+        return tokens.pop(0) if tokens and (_is_ver(tokens[0]) or tokens[0].lower() == "last") else None
+
+    def _parse(self) -> None:
+        t = self.raw.split(":")
+        if not t or t[0].lower() != "gn":
+            raise ValueError("must start with 'gn'")
+        t.pop(0)
+
+        self.gn_ver_raw = self._take_ver(t)
+        self.gn_ver = _VersionRange(self.gn_ver_raw)
+
+        if not t:
+            raise ValueError("missing transport proto")
+        self.trnsp_name = t.pop(0).lower()
+        self.trnsp_ver_raw = self._take_ver(t)
+        self.trnsp_ver = _VersionRange(self.trnsp_ver_raw)
+
+        if not t:
+            raise ValueError("missing route proto")
+        self.route_name = t.pop(0).lower()
+        self.route_ver_raw = self._take_ver(t)
+        self.route_ver = _VersionRange(self.route_ver_raw)
+
+        if t:
+            raise ValueError(f"extra tokens: {t!r}")
+
+    def structure(self) -> dict:
+        return {
+            "gn": {"version": str(self.gn_ver)},
+            self.trnsp_name: {"version": str(self.trnsp_ver)},
+            self.route_name: {"version": str(self.route_ver)},
+        }
+
+    def matches_any(self, patterns: Iterable[str]) -> bool:
+        gv = self.gn_ver_raw
+        c_name, c_ver = self.trnsp_name, self.trnsp_ver_raw
+        r_name, r_ver = self.route_name, self.route_ver_raw
+
+        for pat in patterns:
+            gn_v, p1n, p1v, p1need, p2n, p2v, p2need = _compile_full_pattern(pat)
+
+            # gn
+            if not gn_v.contains(gv):
+                continue
+
+            # transport
+            if p1n and p1n != c_name:
+                continue
+            if p1need:
+                if c_ver is not None:
+                    continue
+            elif not p1v.contains(c_ver):
+                continue
+
+            # route
+            if p2n and p2n != r_name:
+                continue
+            if p2need:
+                if r_ver is not None:
+                    continue
+            elif not p2v.contains(r_ver):
+                continue
+
+            return True
+        return False
+
+    class _LeafProto:
+        __slots__ = ("_name", "_ver_raw")
+
+        def __init__(self, name: str, ver_raw: Optional[str]):
+            self._name = name
+            self._ver_raw = ver_raw  # None == 'last'
+
+        def protocol(self) -> str:
+            return self._name
+
+        def version(self) -> str:
+            return self._ver_raw or "last"
+
+        def matches_any(self, *patterns) -> bool:
+            if len(patterns) == 1 and not isinstance(patterns[0], str):
+                patterns_iter = patterns[0]
+            else:
+                patterns_iter = patterns
+
+            nm = self._name
+            vr = self._ver_raw
+
+            for p in patterns_iter:
+                pat = _compile_leaf_pattern(p)
+
+                if pat.name is not None and pat.name != nm:
+                    continue
+
+                if pat.need_last:
+                    if vr is not None:
+                        continue
+                    return True
+
+                if pat.ver.contains(vr):
+                    return True
+
+            return False
+
+        def __repr__(self) -> str:
+            return f"<Proto {self._name}:{self.version()}>"
+
+    @property
+    def gn(self) -> _LeafProto:
+        """Top‑level 'gn' protocol."""
+        return self._gn_leaf
+
+    @property
+    def transport(self) -> _LeafProto:
+        return self._trnsp_leaf
+
+    @property
+    def route(self) -> _LeafProto:
+        return self._route_leaf
+
+    def __repr__(self) -> str:
+        return (
+            f"<GNProtocol gn:{self.gn_ver_raw or 'last'} "
+            f"{self.trnsp_name}:{self.trnsp_ver_raw or 'last'} "
+            f"{self.route_name}:{self.route_ver_raw or 'last'}>"
+        )

gnobjects/net/fastcommands.py

@@ -0,0 +1,165 @@
+from typing import Optional, Union, List
+
+from KeyisBTools.models.serialization import SerializableType
+
+from .objects import GNResponse, FileObject, CORSObject
+
+
+
+class GNFastCommand(GNResponse):
+    """
+    # Быстрый ответ
+    """
+    def __init__(self,
+                 payload: Optional[SerializableType] = None,
+                 files: Optional[Union[str, FileObject, List[FileObject]]] = None,
+                 cors: Optional[CORSObject] = None):
+
+        command = getattr(self, "cls_command", None)
+        if command is None:
+            command = 'gn:code-error:undefined'
+
+        super().__init__(command=command, payload=payload, files=files, cors=cors)
+
+
+class AllGNFastCommands:
+    class ok(GNFastCommand):
+        """
+        # Корректный ответ
+        """
+        cls_command = True
+       
+        
+    class UnprocessableEntity(GNFastCommand):
+        """
+        # Некорректные данные
+        Ошибка указывает, что сервер понял запрос, но не может его обработать из-за неверного содержания. 
+        Пример: передан payload с правильной структурой, но поля содержат некорректные значения (например, строка вместо числа).
+        Используется, когда данные формально корректны, но нарушают бизнес-логику.
+        """
+        cls_command = "gn:origin:422"
+
+
+    class BadRequest(GNFastCommand):
+        """
+        # Неправильный синтаксис url или параметров
+        Сервер не может понять запрос из-за ошибок в структуре или параметрах. 
+        Пример: отсутствует обязательный параметр или указан некорректный формат даты.
+        Часто используется при валидации входных данных на уровне запроса.
+        """
+        cls_command = "gn:origin:400"
+
+
+    class Forbidden(GNFastCommand):
+        """
+        # Доступ запрещён, даже при наличии авторизации
+        Клиент аутентифицирован, но не имеет прав для выполнения действия. 
+        Пример: пользователь вошёл в систему, но пытается изменить чужие данные.
+        Используется для разграничения прав доступа.
+        """
+        cls_command = "gn:origin:403"
+
+
+    class Unauthorized(GNFastCommand):
+        """
+        # Требуется авторизация
+        Ошибка возвращается, если запрос требует входа, но клиент не предоставил или предоставил неверные данные авторизации. 
+        Пример: отсутствует заголовок Authorization или токен недействителен.
+        Используется для защиты закрытых API-эндпоинтов.
+        """
+        cls_command = "gn:origin:401"
+
+
+    class NotFound(GNFastCommand):
+        """
+        # Ресурс не найден
+        Запрошенный объект или путь не существует на сервере. 
+        Пример: попытка получить пользователя с несуществующим ID.
+        Часто используется для API-ответов на невалидные ссылки.
+        """
+        cls_command = "gn:origin:404"
+
+
+    class MethodNotAllowed(GNFastCommand):
+        """
+        # Метод запроса не поддерживается данным ресурсом
+        Ресурс существует, но используемый gn-метод недопустим. 
+        Пример: к ресурсу разрешён только GET, а клиент делает POST.
+        Используется для ограничения набора действий над конкретными ресурсами.
+        """
+        cls_command = "gn:origin:405"
+
+
+    class Conflict(GNFastCommand):
+        """
+        # Конфликт состояния ресурса (например, дубликат)
+        Возникает, когда операция не может быть выполнена из-за противоречия с текущим состоянием ресурса. 
+        Пример: попытка зарегистрировать пользователя с уже существующим email.
+        Используется для предотвращения логических коллизий.
+        """
+        cls_command = "gn:origin:409"
+
+
+    class InternalServerError(GNFastCommand):
+        """
+        # Внутренняя ошибка сервера
+        Сервер столкнулся с непредвиденной ситуацией, которая не позволяет выполнить запрос. 
+        Пример: необработанное исключение в коде приложения.
+        Используется как универсальная ошибка для внутренних сбоев.
+        """
+        cls_command = "gn:origin:500"
+
+
+    class NotImplemented(GNFastCommand):
+        """
+        # Метод или функционал ещё не реализован
+        Сервер распознаёт запрос, но не поддерживает требуемый функционал. 
+        Пример: метод API описан в документации, но ещё не реализован.
+        Используется для обозначения незавершённых частей системы.
+        """
+        cls_command = "gn:origin:501"
+
+
+    class BadGateway(GNFastCommand):
+        """
+        # Ошибка шлюза или прокси при обращении к апстриму
+        Промежуточный сервер получил некорректный ответ от апстрим-сервера. 
+        Пример: API-шлюз обращается к backend, но тот вернул ошибку.
+        """
+        cls_command = "gn:origin:502"
+
+
+    class ServiceUnavailable(GNFastCommand):
+        """
+        # Сервис временно недоступен
+        Сервер не может обработать запрос из-за перегрузки или обслуживания. 
+        Пример: база данных недоступна или сервис в режиме обновления.
+        Используется для сигнализации о временных проблемах.
+        """
+        cls_command = "gn:origin:503"
+
+
+    class GatewayTimeout(GNFastCommand):
+        """
+        # Таймаут при обращении к апстриму
+        Прокси или шлюз не дождался ответа от вышестоящего сервера в установленный срок. 
+        Пример: запрос к медленному backend-сервису превысил лимит времени.
+        Используется для контроля SLA и таймаутов в распределённых системах.
+        """
+        cls_command = "gn:origin:504"
+
+
+
+
+globals().update({
+    name: obj
+    for name, obj in AllGNFastCommands.__dict__.items()
+    if isinstance(obj, type) and issubclass(obj, GNFastCommand)
+})
+
+
+
+
+
+
+