omlish 0.0.0.dev220__py3-none-any.whl → 0.0.0.dev222__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev220'
-__revision__ = '3af8855e48e09d340dd21835f45fe8a21a262fa9'
+__version__ = '0.0.0.dev222'
+__revision__ = '6f15b0f3bde72b207c93e58623da4bb444ff4003'
 
 
 #

omlish/algorithm/all.py

@@ -0,0 +1,13 @@
+from .distribute import (  # noqa
+    distribute_evenly,
+)
+
+from .toposort import (  # noqa
+    mut_toposort,
+    toposort,
+)
+
+from .unify import (  # noqa
+    mut_unify_sets,
+    unify_sets,
+)

omlish/algorithm/distribute.py

@@ -0,0 +1,46 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import collections
+import heapq
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def distribute_evenly(
+        items: ta.Iterable[ta.Tuple[T, float]],
+        n_bins: int,
+) -> ta.List[ta.List[ta.Tuple[T, float]]]:
+    """
+    Distribute items into n bins as evenly as possible in terms of total size.
+     - Sorting ensures larger items are placed first, preventing large leftover gaps in bins.
+     - A min-heap efficiently finds the least loaded bin in O(log n), keeping the distribution balanced.
+     - Each item is placed in the lightest bin, preventing a few bins from getting overloaded early.
+
+    :param items: List of tuples (item, size).
+    :param n_bins: Number of bins.
+    :return: List of n_bins lists, each containing items assigned to that bin.
+    """
+
+    # Sort items by size in descending order
+    items_sorted = sorted(items, key=lambda x: x[1], reverse=True)
+
+    # Min-heap to track bin loads (size, index)
+    bins = [(0, i) for i in range(n_bins)]  # (current size, bin index)
+    heapq.heapify(bins)
+
+    # Allocate items to bins
+    bin_contents = collections.defaultdict(list)
+
+    for item, size in items_sorted:
+        # Get the least loaded bin
+        bin_size, bin_index = heapq.heappop(bins)
+
+        # Assign item to this bin
+        bin_contents[bin_index].append((item, size))
+
+        # Update bin load and push back to heap
+        heapq.heappush(bins, (bin_size + size, bin_index))  # type: ignore
+
+    return [bin_contents[i] for i in range(n_bins)]

omlish/algorithm/toposort.py

@@ -0,0 +1,26 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def mut_toposort(data: ta.Dict[T, ta.Set[T]]) -> ta.Iterator[ta.Set[T]]:
+    for k, v in data.items():
+        v.discard(k)
+    extra_items_in_deps = functools.reduce(set.union, data.values()) - set(data.keys())
+    data.update({item: set() for item in extra_items_in_deps})
+    while True:
+        ordered = {item for item, dep in data.items() if not dep}
+        if not ordered:
+            break
+        yield ordered
+        data = {item: (dep - ordered) for item, dep in data.items() if item not in ordered}
+    if data:
+        raise ValueError('Cyclic dependencies exist among these items: ' + ' '.join(repr(x) for x in data.items()))
+
+
+def toposort(data: ta.Mapping[T, ta.AbstractSet[T]]) -> ta.Iterator[ta.Set[T]]:
+    return mut_toposort({k: set(v) for k, v in data.items()})

omlish/algorithm/unify.py

@@ -0,0 +1,31 @@
+import itertools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def mut_unify_sets(sets: ta.Iterable[set[T]]) -> list[set[T]]:
+    rem: list[set[T]] = list(sets)
+    ret: list[set[T]] = []
+    while rem:
+        cur = rem.pop()
+        while True:
+            moved = False
+            for i in range(len(rem) - 1, -1, -1):
+                if any(e in cur for e in rem[i]):
+                    cur.update(rem.pop(i))
+                    moved = True
+            if not moved:
+                break
+        ret.append(cur)
+    if ret:
+        all_ = set(itertools.chain.from_iterable(ret))
+        num = sum(map(len, ret))
+        if len(all_) != num:
+            raise ValueError('Length mismatch')
+    return ret
+
+
+def unify_sets(sets: ta.Iterable[ta.AbstractSet[T]]) -> list[set[T]]:
+    return mut_unify_sets([set(s) for s in sets])

omlish/collections/__init__.py

@@ -126,8 +126,6 @@ from .utils import (  # noqa
     make_map_by,
     multi_map,
     multi_map_by,
-    mut_toposort,
     partition,
-    toposort,
     unique,
 )

omlish/collections/utils.py

@@ -1,8 +1,5 @@
-import functools
-import itertools
 import typing as ta
 
-from .. import check
 from .. import lang
 from .exceptions import DuplicateKeyError
 from .identity import IdentityKeyDict
@@ -17,28 +14,6 @@ V = ta.TypeVar('V')
 ##
 
 
-def mut_toposort(data: dict[T, set[T]]) -> ta.Iterator[set[T]]:
-    for k, v in data.items():
-        v.discard(k)
-    extra_items_in_deps = functools.reduce(set.union, data.values()) - set(data.keys())
-    data.update({item: set() for item in extra_items_in_deps})
-    while True:
-        ordered = {item for item, dep in data.items() if not dep}
-        if not ordered:
-            break
-        yield ordered
-        data = {item: (dep - ordered) for item, dep in data.items() if item not in ordered}
-    if data:
-        raise ValueError('Cyclic dependencies exist among these items: ' + ' '.join(repr(x) for x in data.items()))
-
-
-def toposort(data: ta.Mapping[T, ta.AbstractSet[T]]) -> ta.Iterator[set[T]]:
-    return mut_toposort({k: set(v) for k, v in data.items()})
-
-
-##
-
-
 class PartitionResult(ta.NamedTuple, ta.Generic[T]):
     t: list[T]
     f: list[T]
@@ -153,24 +128,3 @@ def key_cmp(fn: ta.Callable[[K, K], int]) -> ta.Callable[[tuple[K, V], tuple[K,
 
 def indexes(it: ta.Iterable[T]) -> dict[T, int]:
     return {e: i for i, e in enumerate(it)}
-
-
-def mut_unify_sets(sets: ta.Iterable[set[T]]) -> list[set[T]]:
-    rem: list[set[T]] = list(sets)
-    ret: list[set[T]] = []
-    while rem:
-        cur = rem.pop()
-        while True:
-            moved = False
-            for i in range(len(rem) - 1, -1, -1):
-                if any(e in cur for e in rem[i]):
-                    cur.update(rem.pop(i))
-                    moved = True
-            if not moved:
-                break
-        ret.append(cur)
-    if ret:
-        all_ = set(itertools.chain.from_iterable(ret))
-        num = sum(map(len, ret))
-        check.equal(len(all_), num)
-    return ret

omlish/graphs/trees.py

@@ -10,6 +10,7 @@ from .. import cached
 from .. import check
 from .. import collections as col
 from .. import lang
+from ..algorithm import all as alg
 
 
 T = ta.TypeVar('T')
@@ -194,7 +195,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}
-        ts = list(col.mut_toposort(tsd))
+        ts = list(alg.mut_toposort(tsd))
         root = d(check.single(ts[0]))
 
         return cls(

omlish/http/coro/server.py

@@ -421,50 +421,59 @@ class CoroHttpServer:
     #
 
     def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], None]:
-        while True:
-            gen = self.coro_handle_one()
+        return self._coro_run_handler(self._coro_handle_one())
 
-            i: ta.Optional[bytes]
-            o: ta.Any = next(gen)
-            while True:
-                try:
-                    if isinstance(o, self.AnyLogIo):
-                        i = None
-                        yield o
+    def _coro_run_handler(
+            self,
+            gen: ta.Generator[
+                ta.Union[AnyLogIo, AnyReadIo, _Response],
+                ta.Optional[bytes],
+                None,
+            ],
+    ) -> ta.Generator[Io, ta.Optional[bytes], None]:
+        i: ta.Optional[bytes]
+        o: ta.Any = next(gen)
+        while True:
+            try:
+                if isinstance(o, self.AnyLogIo):
+                    i = None
+                    yield o
 
-                    elif isinstance(o, self.AnyReadIo):
-                        i = check.isinstance((yield o), bytes)
+                elif isinstance(o, self.AnyReadIo):
+                    i = check.isinstance((yield o), bytes)
 
-                    elif isinstance(o, self._Response):
-                        i = None
+                elif isinstance(o, self._Response):
+                    i = None
 
-                        r = self._preprocess_response(o)
-                        hb = self._build_response_head_bytes(r)
-                        check.none((yield self.WriteIo(hb)))
+                    r = self._preprocess_response(o)
+                    hb = self._build_response_head_bytes(r)
+                    check.none((yield self.WriteIo(hb)))
 
-                        for b in self._yield_response_data(r):
-                            yield self.WriteIo(b)
+                    for b in self._yield_response_data(r):
+                        yield self.WriteIo(b)
 
-                        o.close()
-                        o = None
+                    o.close()
+                    if o.close_connection:
+                        break
+                    o = None
 
-                    else:
-                        raise TypeError(o)  # noqa
+                else:
+                    raise TypeError(o)  # noqa
 
-                    try:
-                        o = gen.send(i)
-                    except EOFError:
-                        return
-                    except StopIteration:
-                        break
+                try:
+                    o = gen.send(i)
+                except EOFError:
+                    return
+                except StopIteration:
+                    break
 
-                except Exception:  # noqa
-                    if hasattr(o, 'close'):
-                        o.close()
+            except Exception:  # noqa
+                if hasattr(o, 'close'):
+                    o.close()
 
-                    raise
+                raise
 
-    def coro_handle_one(self) -> ta.Generator[
+    def _coro_handle_one(self) -> ta.Generator[
         ta.Union[AnyLogIo, AnyReadIo, _Response],
         ta.Optional[bytes],
         None,

omlish/http/{simple.py → coro/simple.py}

@@ -5,23 +5,23 @@ import contextlib
 import functools
 import typing as ta
 
-from ..lite.check import check
-from ..sockets.addresses import SocketAndAddress
-from ..sockets.bind import CanSocketBinder
-from ..sockets.bind import SocketBinder
-from ..sockets.server.handlers import ExecutorSocketServerHandler
-from ..sockets.server.handlers import SocketHandlerSocketServerHandler
-from ..sockets.server.handlers import SocketServerHandler
-from ..sockets.server.handlers import SocketWrappingSocketServerHandler
-from ..sockets.server.handlers import StandardSocketServerHandler
-from ..sockets.server.server import SocketServer
-from ..sockets.server.threading import ThreadingSocketServerHandler
-from .coro.server import CoroHttpServer
-from .coro.server import CoroHttpServerSocketHandler
-from .handlers import HttpHandler
-from .parsing import HttpRequestParser
-from .versions import HttpProtocolVersion
-from .versions import HttpProtocolVersions
+from ...lite.check import check
+from ...sockets.addresses import SocketAndAddress
+from ...sockets.bind import CanSocketBinder
+from ...sockets.bind import SocketBinder
+from ...sockets.server.handlers import ExecutorSocketServerHandler
+from ...sockets.server.handlers import SocketHandlerSocketServerHandler
+from ...sockets.server.handlers import SocketServerHandler
+from ...sockets.server.handlers import SocketWrappingSocketServerHandler
+from ...sockets.server.handlers import StandardSocketServerHandler
+from ...sockets.server.server import SocketServer
+from ...sockets.server.threading import ThreadingSocketServerHandler
+from ..handlers import HttpHandler
+from ..parsing import HttpRequestParser
+from ..versions import HttpProtocolVersion
+from ..versions import HttpProtocolVersions
+from .server import CoroHttpServer
+from .server import CoroHttpServerSocketHandler
 
 
 if ta.TYPE_CHECKING:

omlish/specs/irc/format/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2016-2021 Daniel Oaks
+Copyright (c) 2018-2021 Shivaram Lingamneni
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

omlish/specs/irc/format/__init__.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2016-2021 Daniel Oaks
+# Copyright (c) 2018-2021 Shivaram Lingamneni
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby
+# granted, provided that the above copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+# AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+#
+# https://github.com/ergochat/irc-go/blob/9beac2d29dc5f998c5a53e5db7a6426d7d083a79/ircmsg/
+from .consts import (  # noqa
+    MAX_LEN_CLIENT_TAG_DATA,
+    MAX_LEN_SERVER_TAG_DATA,
+    MAX_LEN_TAGS,
+    MAX_LEN_TAGS_FROM_CLIENT,
+    MAX_LEN_TAG_DATA,
+)
+
+from .errors import (  # noqa
+    BadCharactersError,
+    BadParamError,
+    CommandMissingError,
+    Error,
+    InvalidTagContentError,
+    LineEmptyError,
+    MalformedNuhError,
+    TagsTooLongError,
+)
+
+from .message import (  # noqa
+    Message,
+)
+
+from .nuh import (  # noqa
+    Nuh,
+)
+
+from .parsing import (  # noqa
+    ParsedLine,
+    parse_line,
+    parse_line_,
+    parse_line_strict,
+)
+
+from .rendering import (  # noqa
+    RenderedLine,
+    render_line,
+    render_line_,
+    render_line_strict,
+)
+
+from .tags import (  # noqa
+    escape_tag_value,
+    parse_tags,
+    unescape_tag_value,
+    validate_tag_name,
+    validate_tag_value,
+)

omlish/specs/irc/format/consts.py

@@ -0,0 +1,6 @@
+# Constants
+MAX_LEN_TAGS = 8191
+MAX_LEN_TAG_DATA = MAX_LEN_TAGS - 2
+MAX_LEN_CLIENT_TAG_DATA = 4094
+MAX_LEN_SERVER_TAG_DATA = 4094
+MAX_LEN_TAGS_FROM_CLIENT = MAX_LEN_CLIENT_TAG_DATA + 2

omlish/specs/irc/format/errors.py

@@ -0,0 +1,30 @@
+class Error(Exception):
+    pass
+
+
+class LineEmptyError(Error):
+    pass
+
+
+class BadCharactersError(Error):
+    pass
+
+
+class TagsTooLongError(Error):
+    pass
+
+
+class InvalidTagContentError(Error):
+    pass
+
+
+class CommandMissingError(Error):
+    pass
+
+
+class BadParamError(Error):
+    pass
+
+
+class MalformedNuhError(Error):
+    pass

omlish/specs/irc/format/message.py

@@ -0,0 +1,18 @@
+"""
+TODO:
+ - https://github.com/ergochat/irctest/blob/master/irctest/irc_utils/message_parser.py ?
+"""
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class Message:
+    source: str | None
+    command: str
+    params: ta.Sequence[str]
+
+    force_trailing: bool = False
+
+    tags: ta.Mapping[str, str] | None = None
+    client_only_tags: ta.Mapping[str, str] | None = None

omlish/specs/irc/format/nuh.py

@@ -0,0 +1,52 @@
+import dataclasses as dc
+import typing as ta
+
+from .errors import MalformedNuhError
+
+
+@dc.dataclass(frozen=True)
+class Nuh:
+    name: str | None = None
+    user: str | None = None
+    host: str | None = None
+
+    @property
+    def tuple(self) -> tuple[str | None, ...]:
+        return (self.name, self.user, self.host)
+
+    def __iter__(self) -> ta.Iterator[str | None]:
+        return iter(self.tuple)
+
+    @classmethod
+    def parse(cls, inp: str) -> 'Nuh':
+        if not inp:
+            raise MalformedNuhError
+
+        host: str | None = None
+        host_start = inp.find('@')
+        if host_start != -1:
+            host = inp[host_start + 1:]
+            inp = inp[:host_start]
+
+        user_start = inp.find('!')
+        user: str | None = None
+        if user_start != -1:
+            user = inp[user_start + 1:]
+            inp = inp[:user_start]
+
+        return cls(
+            name=inp or None,
+            user=user,
+            host=host,
+        )
+
+    @property
+    def canonical(self) -> str:
+        parts = []
+        if (n := self.name) is not None:
+            parts.append(n)
+        if (u := self.user) is not None:
+            parts.append(f'!{u}')
+        if (h := self.host) is not None:
+            parts.append(f'@{h}')
+        return ''.join(parts)