omlish 0.0.0.dev4__py3-none-any.whl → 0.0.0.dev5__py3-none-any.whl

omlish/graphs/domination.py

@@ -0,0 +1,268 @@
+import abc
+import contextlib
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+V = ta.TypeVar('V')
+MK = ta.TypeVar('MK')
+MV = ta.TypeVar('MV')
+SetMap = ta.Mapping[MK, ta.AbstractSet[MV]]
+
+
+class DirectedGraph(ta.Generic[V], lang.Abstract):
+
+    @abc.abstractmethod
+    def get_successors(self, vertex: V) -> ta.Collection[V]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def yield_depth_first(self, root: V) -> ta.Iterator[V]:
+        raise NotImplementedError
+
+
+class ListDictDirectedGraph(DirectedGraph[V]):
+
+    def __init__(self, items: ta.Iterable[tuple[V, ta.Iterable[V]]]) -> None:
+        super().__init__()
+
+        lst_dct: dict[V, list[V]] = {}
+        all_children = set()
+        for parent, children in items:
+            check.not_in(parent, lst_dct)
+            lst = []
+            seen = set()
+            for child in children:
+                if child not in seen:
+                    seen.add(child)
+                    lst.append(child)
+                    all_children.add(child)
+            lst_dct[parent] = lst
+        check.empty(all_children - set(lst_dct))
+        self._lst_dct = lst_dct
+
+    def get_successors(self, vertex: V) -> ta.Collection[V]:
+        return self._lst_dct[vertex]
+
+    def yield_depth_first(self, root: V) -> ta.Iterator[V]:
+        stack: list[V] = [root]
+        seen: set[V] = set()
+        while stack:
+            cur = stack.pop()
+            yield cur
+            for child in self._lst_dct[cur]:
+                if child not in seen:
+                    seen.add(child)
+                    stack.append(child)
+
+
+class DominatorTree(ta.Generic[V]):
+
+    def __init__(self, graph: DirectedGraph[V], root: V) -> None:
+        super().__init__()
+
+        self._graph = check.not_none(graph)
+        self._root = check.not_none(root)
+        check.not_none(self._graph.get_successors(root))
+        self._dfs = _Dfs(graph, root)
+
+    @lang.cached_property
+    def immediate_dominators(self) -> ta.Mapping[V, V]:
+        return _ImmediateDominanceComputer(self._dfs).immediate_dominators
+
+    @lang.cached_property
+    def dominator_tree(self) -> SetMap[V, V]:
+        tree: dict[V, set[V]] = {}
+        for node, dom in self.immediate_dominators.items():
+            tree.setdefault(dom, set()).add(node)
+        return tree
+
+    @lang.cached_property
+    def deep_dominated(self) -> SetMap[V, V]:
+        seen: set[V] = set()
+        ret: dict[V, set[V]] = {}
+
+        def rec(node: V) -> ta.Collection[V]:
+            check.not_in(node, seen)
+            seen.add(node)
+            # FIXME: pyrsistent
+            st = set()
+            for child in self.dominator_tree.get(node, []):
+                st.add(child)
+                st.update(rec(child))
+            if st:
+                ret[node] = st
+            return st
+
+        rec(self._root)
+        return ret
+
+    @lang.cached_property
+    def dominance_frontiers(self) -> SetMap[V, V]:
+        dominance_frontiers: dict[V, set[V]] = {}
+
+        for x in self.reverse_topological_traversal:
+            dfx = dominance_frontiers.setdefault(x, set())
+
+            for y in self._graph.get_successors(x):
+                if self.immediate_dominators[y] != x:
+                    dfx.add(y)
+
+            for z in self.dominator_tree.get(x, []):
+                for y in dominance_frontiers.get(z, []):
+                    if self.immediate_dominators[y] != x:
+                        dfx.add(y)
+
+        return {k: v for k, v in dominance_frontiers.items() if v}
+
+    @lang.cached_property
+    def topological_traversal(self) -> list[V]:
+        # FIXME: LinkedList
+        lst: list[V] = []
+
+        for node in self._dfs.vertex:
+            try:
+                idx = lst.index(self.immediate_dominators[node])
+            except (KeyError, ValueError):
+                lst.append(node)
+            else:
+                lst.insert(idx + 1, node)
+
+        return lst
+
+    @lang.cached_property
+    def reverse_topological_traversal(self) -> list[V]:
+        return list(reversed(self.topological_traversal))
+
+
+class _Dfs(ta.Generic[V]):
+
+    def __init__(self, graph: DirectedGraph[V], root: V) -> None:
+        super().__init__()
+
+        semi: dict[V, int] = {}
+        vertex: list[V] = []
+        parent: dict[V, V] = {}
+        pred: dict[V, set[V]] = {}
+        label: dict[V, V] = {}
+
+        for node in graph.yield_depth_first(root):
+            if node not in semi:
+                vertex.append(node)
+
+                check.not_in(node, semi)
+                semi[node] = len(semi)
+                check.not_in(node, label)
+                label[node] = node
+
+                for child in graph.get_successors(node):
+                    pred.setdefault(child, set()).add(node)
+                    if child not in semi:
+                        check.not_in(child, parent)
+                        parent[child] = node
+
+        self._semi = semi
+        self._vertex = vertex
+        self._parent = parent
+        self._pred = pred
+        self._label = label
+
+    @property
+    def semi(self) -> dict[V, int]:
+        return self._semi
+
+    @property
+    def vertex(self) -> list[V]:
+        return self._vertex
+
+    @property
+    def parent(self) -> dict[V, V]:
+        return self._parent
+
+    @property
+    def pred(self) -> dict[V, set[V]]:
+        return self._pred
+
+    @property
+    def label(self) -> dict[V, V]:
+        return self._label
+
+
+class _ImmediateDominanceComputer(ta.Generic[V]):
+
+    def __init__(self, dfs: _Dfs[V]) -> None:
+        super().__init__()
+
+        self._dfs: _Dfs[V] = check.isinstance(dfs, _Dfs)  # type: ignore
+
+        self._ancestor: dict[V, V] = {}
+        self._semi = dict(self._dfs.semi)
+        self._label = dict(self._dfs.label)
+
+    @lang.cached_property
+    def immediate_dominators(self) -> ta.Mapping[V, V]:
+        idom: dict[V, V] = {}
+        bucket: dict[V, set[V]] = {}
+
+        last_semi_number = len(self._semi) - 1
+
+        for i in range(last_semi_number, 0, -1):
+            w = self._dfs.vertex[i]
+            p = self._dfs.parent[w]
+
+            semidominator = self._semi[w]
+            for v in self._dfs.pred.get(w, []):
+                semidominator = min(semidominator, self._semi[self._eval(v)])
+
+            self._semi[w] = semidominator
+            bucket.setdefault(self._dfs.vertex[semidominator], set()).add(w)
+
+            self._ancestor[w] = p
+
+            for v in bucket.get(p, []):
+                u = self._eval(v)
+
+                if self._semi[u] < self._semi[v]:
+                    idom[v] = u
+                else:
+                    idom[v] = p
+
+            with contextlib.suppress(KeyError):
+                del bucket[p]
+
+        for i in range(1, last_semi_number + 1):
+            w = self._dfs.vertex[i]
+
+            if idom[w] != self._dfs.vertex[self._semi[w]]:
+                idom[w] = idom[idom[w]]
+
+        return idom
+
+    def _eval(self, v: V) -> V:
+        self._compress(v)
+        return self._label[v]
+
+    def _compress(self, v: V) -> None:
+        worklist: list[V] = [v]
+
+        a = self._ancestor.get(v)
+
+        while a in self._ancestor:
+            worklist.append(a)
+            a = self._ancestor[a]
+
+        ancestor = worklist.pop()
+        least_semi = self._semi[self._label[ancestor]]
+
+        while worklist:
+            descendent = worklist.pop()
+            current_semi = self._semi[self._label[descendent]]
+
+            if current_semi > least_semi:
+                self._label[descendent] = self._label[ancestor]
+            else:
+                least_semi = current_semi
+
+            ancestor = descendent

omlish/graphs/trees.py

@@ -79,7 +79,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         nodes: list[NodeT] = []
         node_set: ta.MutableSet[NodeT] = self._set_fac()
         children_by_node: ta.MutableMapping[NodeT | None, ta.Sequence[NodeT]] = self._dict_fac()
-        child_sets_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = self._dict_fac()
+        child_sets_by_node: ta.MutableMapping[NodeT | None, ta.AbstractSet[NodeT]] = self._dict_fac()
         parents_by_node: ta.MutableMapping[NodeT, NodeT | None] = self._dict_fac()
 
         children_by_node[None] = [root]
@@ -190,7 +190,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         e: ta.Any
         d: ta.Any
         if identity:
-            e, d = id, col.unique_dict((id(n), n) for n, _ in pairs)
+            e, d = id, col.unique_map((id(n), n) for n, _ in pairs)
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}

omlish/http/__init__.py

@@ -0,0 +1,25 @@
+from . import consts  # noqa
+
+from .cookies import (  # noqa
+    CookieTooBigError,
+    dump_cookie,
+    parse_cookie,
+)
+
+from .dates import (  # noqa
+    http_date,
+    parse_date,
+)
+
+from .encodings import (  # noqa
+    latin1_decode,
+    latin1_encode,
+)
+
+from .json import (  # noqa
+    JSON_TAGGER,
+    JsonTag,
+    JsonTagger,
+    json_dumps,
+    json_loads,
+)

omlish/http/asgi.py

@@ -0,0 +1,131 @@
+import abc
+import logging
+import typing as ta
+import urllib.parse
+
+from .. import check
+from . import consts
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+AsgiScope: ta.TypeAlias = ta.Mapping[str, ta.Any]
+AsgiMessage: ta.TypeAlias = ta.Mapping[str, ta.Any]
+AsgiRecv: ta.TypeAlias = ta.Callable[[], ta.Awaitable[AsgiMessage]]
+AsgiSend: ta.TypeAlias = ta.Callable[[AsgiMessage], ta.Awaitable[None]]
+AsgiApp: ta.TypeAlias = ta.Callable[[AsgiScope, AsgiRecv, AsgiSend], ta.Awaitable[None]]
+
+
+class AbstractAsgiApp(abc.ABC):
+    @abc.abstractmethod
+    async def __call__(self, scope: AsgiScope, recv: AsgiRecv, send: AsgiSend) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+async def stub_lifespan(scope: AsgiScope, recv: AsgiRecv, send: AsgiSend, *, verbose: bool = False) -> None:
+    while True:
+        message = await recv()
+        if message['type'] == 'lifespan.startup':
+            if verbose:
+                log.info('Lifespan starting up')
+            await send({'type': 'lifespan.startup.complete'})
+
+        elif message['type'] == 'lifespan.shutdown':
+            if verbose:
+                log.info('Lifespan shutting down')
+            await send({'type': 'lifespan.shutdown.complete'})
+            return
+
+
+##
+
+
+async def start_response(
+        send: AsgiSend,
+        status: int,
+        content_type: bytes = consts.CONTENT_TYPE_TEXT_UTF8,
+        headers: ta.Sequence[tuple[bytes, bytes]] | None = None,
+) -> None:
+    await send({
+        'type': 'http.response.start',
+        'status': status,
+        'headers': [
+            (b'content-type', content_type),
+            *(headers or ()),
+        ],
+    })
+
+
+async def finish_response(
+        send: AsgiSend,
+        body: bytes = b'',
+) -> None:
+    await send({
+        'type': 'http.response.body',
+        'body': body,
+    })
+
+
+async def send_response(
+        send: AsgiSend,
+        status: int,
+        content_type: bytes = consts.CONTENT_TYPE_TEXT_UTF8,
+        headers: ta.Sequence[tuple[bytes, bytes]] | None = None,
+        body: bytes = b'',
+) -> None:
+    await start_response(
+        send,
+        status=status,
+        content_type=content_type, headers=headers,
+    )
+    await finish_response(
+        send,
+        body=body,
+    )
+
+
+async def redirect_response(
+        send: AsgiSend,
+        url: str,
+        headers: ta.Sequence[tuple[bytes, bytes]] | None = None,
+) -> None:
+    log.info('Redirecting to %s', url)
+    await send({
+        'type': 'http.response.start',
+        'status': 302,
+        'headers': [
+            (b'content-type', consts.CONTENT_TYPE_TEXT_UTF8),
+            (b'location', url.encode()),
+            *(headers or ()),
+        ],
+    })
+    await send({
+        'type': 'http.response.body',
+        'body': b'',
+    })
+
+
+##
+
+
+async def read_body(recv: AsgiRecv) -> bytes:
+    body = b''
+    more_body = True
+    while more_body:
+        message = await recv()
+        body += message.get('body', b'')
+        more_body = message.get('more_body', False)
+    return body
+
+
+async def read_form_body(recv: AsgiRecv) -> dict[bytes, bytes]:
+    body = await read_body(recv)
+    dct = urllib.parse.parse_qs(body)  # noqa
+    return {k: check.single(v) for k, v in dct.items()}

omlish/http/consts.py

@@ -1,20 +1,47 @@
 import http  # noqa
 
 
+##
+
+
 def format_status(status: http.HTTPStatus) -> str:
     return '%d %s' % (int(status), status.phrase)
 
 
 STATUS_OK = format_status(http.HTTPStatus.OK)
+
+STATUS_FOUND = format_status(http.HTTPStatus.FOUND)
+STATUS_TEMPORARY_REDIRECT = format_status(http.HTTPStatus.TEMPORARY_REDIRECT)
+
 STATUS_BAD_REQUEST = format_status(http.HTTPStatus.BAD_REQUEST)
+STATUS_UNAUTHORIZED = format_status(http.HTTPStatus.UNAUTHORIZED)
 STATUS_FORBIDDEN = format_status(http.HTTPStatus.FORBIDDEN)
 STATUS_NOT_FOUND = format_status(http.HTTPStatus.NOT_FOUND)
 STATUS_METHOD_NOT_ALLOWED = format_status(http.HTTPStatus.METHOD_NOT_ALLOWED)
+STATUS_REQUEST_TIMEOUT = format_status(http.HTTPStatus.REQUEST_TIMEOUT)
+
+STATUS_INTERNAL_SERVER_ERROR = format_status(http.HTTPStatus.INTERNAL_SERVER_ERROR)
+STATUS_NOT_IMPLEMENTED = format_status(http.HTTPStatus.NOT_IMPLEMENTED)
+STATUS_BAD_GATEWAY = format_status(http.HTTPStatus.BAD_GATEWAY)
+STATUS_SERVICE_UNAVAILABLE = format_status(http.HTTPStatus.SERVICE_UNAVAILABLE)
+STATUS_GATEWAY_TIMEOUT = format_status(http.HTTPStatus.GATEWAY_TIMEOUT)
+
+
+##
 
 
 HEADER_CONTENT_TYPE = b'Content-Type'
-CONTENT_TYPE_TEXT = b'text/plain'
-CONTENT_TYPE_TEXT_UTF8 = CONTENT_TYPE_TEXT + b'; charset=utf-8'
-CONTENT_TYPE_JSON = b'application/json'
-CONTENT_TYPE_ICON = b'image/x-icon'
+CONTENT_CHARSET_UTF8 = b'charset=utf-8'
+
 CONTENT_TYPE_BYTES = b'application/octet-stream'
+
+CONTENT_TYPE_HTML = b'text/html'
+CONTENT_TYPE_HTML_UTF8 = b'; '.join([CONTENT_TYPE_HTML, CONTENT_CHARSET_UTF8])
+
+CONTENT_TYPE_ICON = b'image/x-icon'
+
+CONTENT_TYPE_JSON = b'application/json'
+CONTENT_TYPE_JSON_UTF8 = b'; '.join([CONTENT_TYPE_JSON, CONTENT_CHARSET_UTF8])
+
+CONTENT_TYPE_TEXT = b'text/plain'
+CONTENT_TYPE_TEXT_UTF8 = b'; '.join([CONTENT_TYPE_TEXT, CONTENT_CHARSET_UTF8])

omlish/http/cookies.py

@@ -0,0 +1,194 @@
+"""
+https://github.com/pallets/werkzeug/blob/9e050f7750214d6779636813b8d661250804e811/src/werkzeug/http.py
+https://github.com/pallets/werkzeug/blob/9e050f7750214d6779636813b8d661250804e811/src/werkzeug/sansio/http.py
+"""
+# Copyright 2007 Pallets
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+#     disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# 3.  Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
+#     products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import datetime
+import re
+import typing as ta
+import urllib.parse
+
+from .. import collections as col
+from .dates import http_date
+
+
+##
+
+
+_COOKIE_RE = re.compile(
+    r"""
+    ([^=;]*)
+    (?:\s*=\s*
+      (
+        "(?:[^\\"]|\\.)*"
+      |
+        .*?
+      )
+    )?
+    \s*;\s*
+    """,
+    flags=re.ASCII | re.VERBOSE,
+)
+_COOKIE_UNSLASH_RE = re.compile(rb'\\([0-3][0-7]{2}|.)')
+
+
+def _cookie_unslash_replace(m: ta.Match[bytes]) -> bytes:
+    v = m.group(1)
+
+    if len(v) == 1:
+        return v
+
+    return int(v, 8).to_bytes(1, 'big')
+
+
+def parse_cookie(
+        cookie: str | None = None,
+        *,
+        no_latin1: bool = False,
+) -> ta.MutableMapping[str, list[str]]:
+    if (not no_latin1) and cookie:
+        cookie = cookie.encode('latin1').decode()
+
+    if not cookie:
+        return {}
+
+    cookie = f'{cookie};'
+    out = []
+
+    for ck, cv in _COOKIE_RE.findall(cookie):
+        ck = ck.strip()
+        cv = cv.strip()
+
+        if not ck:
+            continue
+
+        if len(cv) >= 2 and cv[0] == cv[-1] == '"':
+            # Work with bytes here, since a UTF-8 character could be multiple bytes.
+            cv = _COOKIE_UNSLASH_RE.sub(
+                _cookie_unslash_replace,
+                cv[1:-1].encode(),
+            ).decode(errors='replace')
+
+        out.append((ck, cv))
+
+    return col.multi_map(out)
+
+
+##
+
+
+_COOKIE_NO_QUOTE_RE = re.compile(r"[\w!#$%&'()*+\-./:<=>?@\[\]^`{|}~]*", re.ASCII)
+_COOKIE_SLASH_RE = re.compile(rb'[\x00-\x19\",;\\\x7f-\xff]', re.ASCII)
+_COOKIE_SLASH_MAP = {b'"': b'\\"', b'\\': b'\\\\'}
+_COOKIE_SLASH_MAP.update(
+    (v.to_bytes(1, 'big'), b'\\%03o' % v)
+    for v in [*range(0x20), *b',;', *range(0x7F, 256)]
+)
+
+
+class CookieTooBigError(Exception):
+    pass
+
+
+def dump_cookie(
+        key: str,
+        value: str = '',
+        *,
+        max_age: datetime.timedelta | int | None = None,
+        expires: str | datetime.datetime | float | None = None,
+        path: str | None = '/',
+        domain: str | None = None,
+        secure: bool = False,
+        httponly: bool = False,
+        sync_expires: bool = True,
+        max_size: int = 4093,
+        samesite: str | None = None,
+        partitioned: bool = False,
+) -> str:
+    if path is not None:
+        # safe = https://url.spec.whatwg.org/#url-path-segment-string as well as percent for things that are already
+        # quoted excluding semicolon since it's part of the header syntax
+        path = urllib.parse.quote(path, safe="%!$&'()*+,/:=@")
+
+    if domain:
+        domain = domain.partition(':')[0].lstrip('.').encode('idna').decode('ascii')
+
+    if isinstance(max_age, datetime.timedelta):
+        max_age = int(max_age.total_seconds())
+
+    if expires is not None:
+        if not isinstance(expires, str):
+            expires = http_date(expires)
+    elif max_age is not None and sync_expires:
+        expires = http_date(datetime.datetime.now(tz=datetime.UTC).timestamp() + max_age)
+
+    if samesite is not None:
+        samesite = samesite.title()
+
+        if samesite not in {'Strict', 'Lax', 'None'}:
+            raise ValueError("SameSite must be 'Strict', 'Lax', or 'None'.")
+
+    if partitioned:
+        secure = True
+
+    # Quote value if it contains characters not allowed by RFC 6265. Slash-escape with
+    # three octal digits, which matches http.cookies, although the RFC suggests base64.
+    if not _COOKIE_NO_QUOTE_RE.fullmatch(value):
+        # Work with bytes here, since a UTF-8 character could be multiple bytes.
+        value = _COOKIE_SLASH_RE.sub(
+            lambda m: _COOKIE_SLASH_MAP[m.group()], value.encode(),
+        ).decode('ascii')
+        value = f'"{value}"'
+
+    # Send a non-ASCII key as mojibake. Everything else should already be ASCII.
+    # TODO Remove encoding dance, it seems like clients accept UTF-8 keys
+    buf = [f"{key.encode().decode('latin1')}={value}"]
+
+    for k, v in (
+            ('Domain', domain),
+            ('Expires', expires),
+            ('Max-Age', max_age),
+            ('Secure', secure),
+            ('HttpOnly', httponly),
+            ('Path', path),
+            ('SameSite', samesite),
+            ('Partitioned', partitioned),
+    ):
+        if v is None or v is False:
+            continue
+
+        if v is True:
+            buf.append(k)
+            continue
+
+        buf.append(f'{k}={v}')
+
+    rv = '; '.join(buf)
+
+    # Warn if the final value of the cookie is larger than the limit. If the cookie is too large, then it may be
+    # silently ignored by the browser, which can be quite hard to debug.
+    cookie_size = len(rv)
+    if max_size and cookie_size > max_size:
+        raise CookieTooBigError(cookie_size)
+
+    return rv