gnobjects 0.0.0.0.1__tar.gz

gnobjects-0.0.0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 KeyisB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 NONINFRINGEMENT. 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-0.0.0.0.1/MANIFEST.in

@@ -0,0 +1,4 @@
+graft gnobjects
+global-exclude __pycache__ *.py[cod] .DS_Store
+include LICENSE
+include README.md

gnobjects-0.0.0.0.1/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: gnobjects
+Version: 0.0.0.0.1
+Summary: gnobjects
+Home-page: https://github.com/KeyisB/libs/tree/main/gnobjects
+Author: KeyisB
+Author-email: keyisb.pip@gmail.com
+License: MMB License v1.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: KeyisBTools
+Requires-Dist: ast
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+GW and MMB Project libraries

gnobjects-0.0.0.0.1/gnobjects/LICENSE

@@ -0,0 +1,28 @@
+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 
+1. Copying, modification, merging, publishing, distribution,
+sublicensing, and/or selling copies of the Software are
+strictly prohibited.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:
+
+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-0.0.0.0.1/gnobjects/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-0.0.0.0.1/gnobjects/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-0.0.0.0.1/gnobjects/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'}>"
+        )