omlish 0.0.0.dev473__py3-none-any.whl → 0.0.0.dev474__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev473'
-__revision__ = '9f130fc70f42b7e2117fc6530397d1bd295b37e6'
+__version__ = '0.0.0.dev474'
+__revision__ = '5a7b02bc5884a6c8e41f2e2afd5aaf7f495cc28e'
 
 
 #
@@ -41,7 +41,7 @@ class Project(ProjectBase):
 
             'greenlet ~= 3.2',
 
-            'trio ~= 0.31',
+            'trio ~= 0.32',
             'trio-asyncio ~= 0.15',
         ],
 

omlish/diag/{lslocks.py → cmds/lslocks.py}

@@ -7,12 +7,12 @@ import dataclasses as dc
 import json
 import typing as ta
 
-from ..lite.check import check
-from ..lite.marshal import OBJ_MARSHALER_FIELD_KEY
-from ..lite.marshal import unmarshal_obj
-from ..subprocesses.run import SubprocessRun
-from ..subprocesses.run import SubprocessRunnable
-from ..subprocesses.run import SubprocessRunOutput
+from ...lite.check import check
+from ...lite.marshal import OBJ_MARSHALER_FIELD_KEY
+from ...lite.marshal import unmarshal_obj
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunnable
+from ...subprocesses.run import SubprocessRunOutput
 
 
 ##

omlish/diag/{lsof.py → cmds/lsof.py}

@@ -7,12 +7,12 @@ import dataclasses as dc
 import enum
 import typing as ta
 
-from ..lite.check import check
-from ..lite.dataclasses import dataclass_repr_omit_falsey
-from ..lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
-from ..subprocesses.run import SubprocessRun
-from ..subprocesses.run import SubprocessRunnable
-from ..subprocesses.run import SubprocessRunOutput
+from ...lite.check import check
+from ...lite.dataclasses import dataclass_repr_omit_falsey
+from ...lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunnable
+from ...subprocesses.run import SubprocessRunOutput
 
 
 ##

omlish/diag/{ps.py → cmds/ps.py}

@@ -4,12 +4,12 @@ import dataclasses as dc
 import os
 import typing as ta
 
-from ..lite.check import check
-from ..lite.timeouts import Timeout
-from ..subprocesses.run import SubprocessRun
-from ..subprocesses.run import SubprocessRunnable
-from ..subprocesses.run import SubprocessRunOutput
-from ..subprocesses.sync import subprocesses
+from ...lite.check import check
+from ...lite.timeouts import Timeout
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunnable
+from ...subprocesses.run import SubprocessRunOutput
+from ...subprocesses.sync import subprocesses
 
 
 ##

omlish/http/clients/coro/sync.py

@@ -157,7 +157,7 @@ class CoroHttpClient(HttpClient):
             else:
                 raise TypeError(o)
 
-        def read1(self, /, n: int = -1) -> bytes:
+        def read1(self, n: int = -1, /) -> bytes:
             return self._run_coro(check.not_none(self._resp).read(n if n >= 0 else None))
 
         def close(self) -> None:

omlish/http/clients/default.py

@@ -83,7 +83,7 @@ def client() -> HttpClient:
 
 
 @contextlib.contextmanager
-def manage_client(client: HttpClient | None) -> ta.Generator[HttpClient]:  # noqa
+def manage_client(client: HttpClient | None = None) -> ta.Generator[HttpClient]:  # noqa
     if client is not None:
         yield client
 
@@ -167,7 +167,7 @@ def async_client() -> AsyncHttpClient:
 
 
 @contextlib.asynccontextmanager
-async def manage_async_client(client: AsyncHttpClient | None) -> ta.AsyncGenerator[AsyncHttpClient]:  # noqa
+async def manage_async_client(client: AsyncHttpClient | None = None) -> ta.AsyncGenerator[AsyncHttpClient]:  # noqa
     if client is not None:
         yield client
 

omlish/http/clients/executor.py

@@ -30,10 +30,10 @@ class ExecutorAsyncHttpClient(AsyncHttpClient):
         owner: 'ExecutorAsyncHttpClient'
         resp: StreamHttpResponse
 
-        async def read1(self, /, n: int = -1) -> bytes:
+        async def read1(self, n: int = -1, /) -> bytes:
             return await self.owner._run_in_executor(self.resp.stream.read1, n)  # noqa
 
-        async def read(self, /, n: int = -1) -> bytes:
+        async def read(self, n: int = -1, /) -> bytes:
             return await self.owner._run_in_executor(self.resp.stream.read, n)  # noqa
 
         async def readall(self) -> bytes:

omlish/http/clients/httpx.py

@@ -33,7 +33,7 @@ class HttpxHttpClient(HttpClient):
     class _StreamAdapter:
         it: ta.Iterator[bytes]
 
-        def read1(self, /, n: int = -1) -> bytes:
+        def read1(self, n: int = -1, /) -> bytes:
             try:
                 return next(self.it)
             except StopIteration:
@@ -82,7 +82,7 @@ class HttpxAsyncHttpClient(AsyncHttpClient):
     class _StreamAdapter:
         it: ta.AsyncIterator[bytes]
 
-        async def read1(self, /, n: int = -1) -> bytes:
+        async def read1(self, n: int = -1, /) -> bytes:
             try:
                 return await anext(self.it)
             except StopAsyncIteration:
@@ -105,27 +105,15 @@ class HttpxAsyncHttpClient(AsyncHttpClient):
             it = resp.aiter_bytes()
 
             # FIXME:
-            #  - https://github.com/encode/httpx/discussions/2963
-            #   - Exception ignored in: <async_generator object HTTP11ConnectionByteStream.__aiter__ at 0x1325a7540>
-            #   - RuntimeError: async generator ignored GeneratorExit
-            #  - Traced to:
-            #   - HTTP11ConnectionByteStream.aclose -> await self._connection._response_closed()
-            #   - AsyncHTTP11Connection._response_closed -> async with self._state_lock
-            #   - anyio._backends._asyncio.Lock.acquire -> await AsyncIOBackend.cancel_shielded_checkpoint() -> await sleep(0)  # noqa
-            #  - Might have something to do with pycharm/pydevd's nested asyncio, doesn't seem to happen under trio ever
-            #    or asyncio outside debugger.
-            @es.push_async_callback
-            async def close_it() -> None:
-                try:
-                    # print(f'close_it.begin: {it=}', file=sys.stderr)
-                    await it.aclose()  # type: ignore[attr-defined]
-                    # print(f'close_it.end: {it=}', file=sys.stderr)
-                except BaseException as be:  # noqa
-                    # print(f'close_it.__exit__: {it=} {be=}', file=sys.stderr)
-                    raise
-                finally:
-                    # print(f'close_it.finally: {it=}', file=sys.stderr)
-                    pass
+            #  this has a tendency to raise `RuntimeError: async generator ignored GeneratorExit` when all of the
+            #  following conditions are met:
+            #   - stopped iterating midway through
+            #   - shutting down the event loop
+            #   - debugging under pycharm / pydevd
+            #   - running under asyncio
+            #  it does not seem to happen unless all of these conditions are met. see:
+            #   https://gist.github.com/wrmsr/a0578ee5d5371b53804cfb56aeb84cdf .
+            es.push_async_callback(it.aclose)  # type: ignore[attr-defined]
 
             return AsyncStreamHttpResponse(
                 status=resp.status_code,

omlish/http/clients/syncasync.py

@@ -23,10 +23,10 @@ class SyncAsyncHttpClient(AsyncHttpClient):
     class _StreamAdapter:
         ul: StreamHttpResponse
 
-        async def read1(self, /, n: int = -1) -> bytes:
+        async def read1(self, n: int = -1, /) -> bytes:
             return self.ul.stream.read1(n)
 
-        async def read(self, /, n: int = -1) -> bytes:
+        async def read(self, n: int = -1, /) -> bytes:
             return self.ul.stream.read(n)
 
         async def readall(self) -> bytes:

omlish/io/buffers.py

@@ -277,7 +277,7 @@ class ReadableListBuffer:
             self._buf = buf
             self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
 
-        def read1(self, /, n: int = -1) -> bytes:
+        def read1(self, n: int = -1, /) -> bytes:
             if n < 0:
                 n = self._chunk_size
             if not n:
@@ -327,7 +327,7 @@ class ReadableListBuffer:
             self._buf = buf
             self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
 
-        async def read1(self, /, n: int = -1) -> bytes:
+        async def read1(self, n: int = -1, /) -> bytes:
             if n < 0:
                 n = self._chunk_size
             if not n:

omlish/io/readers.py

@@ -7,11 +7,11 @@ import typing as ta
 
 
 class RawBytesReader(ta.Protocol):
-    def read1(self, /, n: int = -1) -> bytes: ...
+    def read1(self, n: int = -1, /) -> bytes: ...
 
 
 class BufferedBytesReader(RawBytesReader, ta.Protocol):
-    def read(self, /, n: int = -1) -> bytes: ...
+    def read(self, n: int = -1, /) -> bytes: ...
 
     def readall(self) -> bytes: ...
 
@@ -20,10 +20,10 @@ class BufferedBytesReader(RawBytesReader, ta.Protocol):
 
 
 class AsyncRawBytesReader(ta.Protocol):
-    def read1(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+    def read1(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
 
 
 class AsyncBufferedBytesReader(AsyncRawBytesReader, ta.Protocol):
-    def read(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+    def read(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
 
     def readall(self) -> ta.Awaitable[bytes]: ...

omlish/os/pidfiles/pinning.py

@@ -25,8 +25,8 @@ import sys
 import time
 import typing as ta
 
-from ...diag.lslocks import LslocksCommand
-from ...diag.lsof import LsofCommand
+from ...diag.cmds.lslocks import LslocksCommand
+from ...diag.cmds.lsof import LsofCommand
 from ...lite.abstract import Abstract
 from ...lite.check import check
 from ...lite.timeouts import Timeout

omlish/text/docwrap/__init__.py

@@ -0,0 +1,3 @@
+from .api import (  # noqa
+    docwrap,
+)

omlish/text/docwrap/api.py

@@ -0,0 +1,77 @@
+import dataclasses as dc
+import typing as ta
+
+from ..textwrap import TextwrapOpts
+from .groups import group_indents
+from .lists import ListBuilder
+from .parts import Part
+from .parts import build_root
+from .reflowing import TextwrapReflower
+from .reflowing import reflow_block_text
+
+
+##
+
+
+DEFAULT_TAB_WIDTH: int = 4
+
+
+def replace_tabs(s: str, tab_width: int | None = None) -> str:
+    if tab_width is None:
+        tab_width = DEFAULT_TAB_WIDTH
+    return s.replace('\t', ' ' * tab_width)
+
+
+##
+
+
+def parse(
+        s: str,
+        *,
+        tab_width: int | None = None,
+        allow_improper_list_children: bool | ta.Literal['lists_only'] | None = None,
+) -> Part:
+    s = replace_tabs(
+        s,
+        tab_width=tab_width,
+    )
+
+    root = build_root(s)
+
+    root = group_indents(root)
+
+    root = ListBuilder(
+        allow_improper_children=allow_improper_list_children,
+    ).build_lists(root)
+
+    return root
+
+
+##
+
+
+def docwrap(
+        s: str,
+        *,
+        width: int | None = None,
+        textwrap: TextwrapOpts | ta.Mapping[str, ta.Any] | None = None,
+        allow_improper_list_children: bool | ta.Literal['lists_only'] = False,
+) -> Part:
+    if isinstance(textwrap, ta.Mapping):
+        textwrap = TextwrapOpts(**textwrap)
+    elif textwrap is None:
+        textwrap = TextwrapOpts()
+    if width is not None:
+        textwrap = dc.replace(textwrap, width=width)
+
+    root = parse(
+        s,
+        allow_improper_list_children=allow_improper_list_children,
+    )
+
+    root = reflow_block_text(
+        root,
+        TextwrapReflower(opts=textwrap),
+    )
+
+    return root

omlish/text/docwrap/groups.py

@@ -0,0 +1,84 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from .parts import Blank
+from .parts import Block
+from .parts import Indent
+from .parts import Part
+from .parts import Text
+from .parts import blockify
+
+
+##
+
+
+@dc.dataclass()
+@dc.extra_class_params(default_repr_fn=dc.truthy_repr)
+class _IndentGroup:
+    n: int
+    cs: list[ta.Union[Blank, Text, '_IndentGroup']] = dc.field(default_factory=list)
+
+
+def group_indents(root: Part) -> Part:
+    rg = _IndentGroup(0)
+    stk: list[_IndentGroup] = [rg]
+
+    for p in (root.ps if isinstance(root, Block) else [root]):
+        if isinstance(p, Blank):
+            stk[-1].cs.append(p)
+            continue
+
+        n: int
+        t: Text
+        if isinstance(p, Text):
+            n, t = 0, p
+        elif isinstance(p, Indent):
+            n = p.n
+            t = check.isinstance(p.p, Text)
+        else:
+            raise TypeError(p)
+
+        while n < stk[-1].n:
+            stk.pop()
+
+        if n > stk[-1].n:
+            nxt = _IndentGroup(n=n, cs=[t])
+            stk[-1].cs.append(nxt)
+            stk.append(nxt)
+
+        else:
+            check.state(stk[-1].n == n)
+            stk[-1].cs.append(t)
+
+    #
+
+    def relativize(g: '_IndentGroup') -> None:
+        for c in g.cs:
+            if isinstance(c, _IndentGroup):
+                check.state(c.n > g.n)
+                relativize(c)
+                c.n -= g.n
+
+    relativize(rg)
+
+    #
+
+    def convert(g: '_IndentGroup') -> Part:
+        if g.n < 1:
+            check.state(g is rg)
+
+        lst: list[Part] = []
+        for c in g.cs:
+            if isinstance(c, (Blank, Text)):
+                lst.append(c)
+
+            elif isinstance(c, _IndentGroup):
+                lst.append(Indent(c.n, convert(c)))  # type: ignore[arg-type]
+
+            else:
+                raise TypeError(c)
+
+        return blockify(*lst)
+
+    return convert(rg)

omlish/text/docwrap/lists.py

@@ -0,0 +1,167 @@
+"""
+TODO:
+ - numeric lettered lists (even unordered) (with separator - `1)` / `1:` / ...)
+"""
+import typing as ta
+
+from ... import check
+from .parts import Blank
+from .parts import Block
+from .parts import Indent
+from .parts import List
+from .parts import Part
+from .parts import Text
+from .parts import blockify
+from .utils import all_same
+
+
+##
+
+
+class ListBuilder:
+    DEFAULT_ALLOW_IMPROPER_CHILDREN: ta.ClassVar[bool | ta.Literal['lists_only']] = False
+    DEFAULT_LIST_PREFIXES: ta.ClassVar[ta.Sequence[str]] = ['*', '-']
+
+    def __init__(
+            self,
+            *,
+            list_prefixes: ta.Iterable[str] | None = None,
+            allow_improper_children: bool | ta.Literal['lists_only'] | None = None,
+    ) -> None:
+        super().__init__()
+
+        if list_prefixes is None:
+            list_prefixes = self.DEFAULT_LIST_PREFIXES
+        self._list_prefixes = set(check.not_isinstance(list_prefixes, str))
+        if allow_improper_children is None:
+            allow_improper_children = self.DEFAULT_ALLOW_IMPROPER_CHILDREN
+        self._allow_improper_children = allow_improper_children
+
+        self._len_sorted_list_prefixes = sorted(self._list_prefixes, key=len, reverse=True)
+
+    #
+
+    def _should_promote_indent_child(self, p: Indent) -> bool:
+        ac = self._allow_improper_children
+        if isinstance(ac, bool):
+            return ac
+        elif ac == 'lists_only':
+            return isinstance(p.p, List)
+        else:
+            raise TypeError(ac)
+
+    #
+
+    class _DetectedList(ta.NamedTuple):
+        pfx: str
+        ofs: int
+        len: int
+
+    def _detect_list(self, ps: ta.Sequence[Part], st: int = 0) -> _DetectedList | None:
+        if not ps:
+            return None
+
+        for lp in self._len_sorted_list_prefixes:
+            sp = lp + ' '
+
+            mo = -1
+            n = st
+            while n < len(ps):
+                p = ps[n]
+
+                if isinstance(p, (Blank, Text)):
+                    if isinstance(p, Text):
+                        if p.s.startswith(sp):
+                            if mo < 0:
+                                mo = n
+                        elif mo >= 0:
+                            break
+
+                elif isinstance(p, Indent):
+                    if mo >= 0 and p.n < len(sp):
+                        if not self._should_promote_indent_child(p):
+                            break
+
+                elif isinstance(p, List):
+                    if mo >= 0:
+                        break
+
+                else:
+                    raise TypeError(p)
+
+                n += 1
+
+            if mo >= 0:
+                return ListBuilder._DetectedList(lp, mo, n - mo)
+
+        return None
+
+    def _build_list(self, lp: str, ps: ta.Sequence[Part]) -> List:
+        sp = lp + ' '
+
+        new: list[list[Part]] = []
+
+        f = check.isinstance(ps[0], Text)
+        check.state(f.s.startswith(sp))
+        new.append([Text(f.s[len(sp):])])
+        del f
+
+        for i in range(1, len(ps)):
+            p = ps[i]
+
+            if isinstance(p, Blank):
+                new[-1].append(p)
+
+            elif isinstance(p, Text):
+                check.state(p.s.startswith(sp))
+                new.append([Text(p.s[len(sp):])])
+
+            elif isinstance(p, Indent):
+                if p.n < len(sp):
+                    check.state(self._should_promote_indent_child(p))
+                    p = Indent(len(sp), p.p)
+
+                if p.n == len(sp):
+                    new[-1].append(p.p)
+
+                else:
+                    raise NotImplementedError
+
+            else:
+                raise TypeError(p)
+
+        #
+
+        return List(lp, [blockify(*x) for x in new])
+
+    def build_lists(self, root: Part) -> Part:
+        def rec(p: Part) -> Part:  # noqa
+            if isinstance(p, Block):
+                new = [rec(c) for c in p.ps]
+                if not all_same(new, p.ps):
+                    return rec(blockify(*new))
+
+                st = 0
+                diff = False
+                while (dl := self._detect_list(new, st)) is not None:
+                    diff = True
+                    ln = self._build_list(dl.pfx, new[dl.ofs:dl.ofs + dl.len])
+                    new[dl.ofs:dl.ofs + dl.len] = [ln]
+                    st = dl.ofs + 1
+
+                if diff:
+                    p = blockify(*new)
+                return p
+
+            elif isinstance(p, Indent):
+                if (n := rec(p.p)) is not p.p:
+                    p = Indent(p.n, n)  # type: ignore[arg-type]
+                return p
+
+            elif isinstance(p, (Blank, Text, List)):
+                return p
+
+            else:
+                raise TypeError(p)
+
+        return rec(root)

omlish/text/docwrap/parts.py

@@ -0,0 +1,139 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class Part(lang.Abstract, lang.Sealed):
+    pass
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class Text(Part, lang.Final):
+    s: str
+
+    @dc.init
+    def _check_s(self) -> None:
+        check.non_empty_str(self.s)
+        check.state(self.s == self.s.strip())
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class Blank(Part, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class Indent(Part, lang.Final):
+    n: int = dc.xfield(validate=lambda n: n > 0)
+    p: ta.Union[Text, 'Block', 'List'] = dc.xfield(coerce=lambda p: check.isinstance(p, (Text, Block, List)))
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class Block(Part, lang.Final):
+    ps: ta.Sequence[Part]
+
+    @dc.init
+    def _check_ps(self) -> None:
+        check.state(len(self.ps) > 1)
+        for i, p in enumerate(self.ps):
+            check.isinstance(p, Part)
+            if i and isinstance(p, Block):
+                check.not_isinstance(self.ps[i - 1], Block)
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(terse_repr=True)
+class List(Part, lang.Final):
+    d: str = dc.xfield(coerce=check.non_empty_str)
+    es: ta.Sequence[Part] = dc.xfield()
+
+    @dc.init
+    def _check_es(self) -> None:
+        check.not_empty(self.es)
+        for e in self.es:
+            check.isinstance(e, Part)
+
+
+##
+
+
+def _squish(ps: ta.Sequence[Part]) -> ta.Sequence[Part]:
+    for p in ps:
+        check.isinstance(p, Part)
+
+    if len(ps) < 2:
+        return ps
+
+    while True:
+        if any(isinstance(p, Block) for p in ps):
+            ps = list(lang.flatmap(lambda p: p.ps if isinstance(p, Block) else [p], ps))
+            continue
+
+        if any(
+                isinstance(ps[i], Indent) and
+                isinstance(ps[i + 1], Indent) and
+                ps[i].n == ps[i + 1].n  # type: ignore[attr-defined]
+                for i in range(len(ps) - 1)
+        ):
+            new: list[Part | tuple[int, list[Part]]] = []
+            for p in ps:
+                if isinstance(p, Indent):
+                    if new and isinstance(y := new[-1], tuple) and p.n == y[0]:
+                        y[1].append(p.p)
+                    else:
+                        new.append((p.n, [p.p]))
+                else:
+                    new.append(p)
+            ps = [
+                Indent(x[0], blockify(*x[1])) if isinstance(x, tuple) else x  # type: ignore[arg-type]
+                for x in new
+            ]
+            continue
+
+        break
+
+    return ps
+
+
+def blockify(*ps: Part) -> Part:
+    check.not_empty(ps)
+    ps = _squish(ps)  # type: ignore[assignment]
+    if len(ps) == 1:
+        return ps[0]
+    return Block(ps)
+
+
+##
+
+
+def build_root(s: str) -> Part:
+    lst: list[Part] = []
+
+    for l in s.splitlines():
+        if not (sl := l.strip()):
+            lst.append(Blank())
+            continue
+
+        p: Part = Text(sl)
+
+        n = next((i for i, c in enumerate(l) if not c.isspace()), 0)
+        if n:
+            p = Indent(n, p)  # type: ignore[arg-type]
+
+        lst.append(p)
+
+    if len(lst) == 1:
+        return lst[0]
+    else:
+        return Block(lst)

omlish/text/docwrap/reflowing.py

@@ -0,0 +1,103 @@
+"""
+FIXME:
+ - use wrapping.py with all its todos
+"""
+import dataclasses as dc
+import textwrap
+import typing as ta
+
+from ... import lang
+from ..textwrap import TextwrapOpts
+from .parts import Blank
+from .parts import Block
+from .parts import Indent
+from .parts import List
+from .parts import Part
+from .parts import Text
+from .parts import blockify
+from .utils import all_same
+
+
+##
+
+
+class TextReflower(ta.Protocol):
+    def __call__(self, strs: ta.Sequence[str], current_indent: int) -> ta.Sequence[str]: ...
+
+
+class NopReflower:
+    def __call__(self, strs: ta.Sequence[str], current_indent: int = 0) -> ta.Sequence[str]:
+        return strs
+
+
+@dc.dataclass(frozen=True)
+class JoiningReflower:
+    sep: str = ' '
+
+    def __call__(self, strs: ta.Sequence[str], current_indent: int = 0) -> ta.Sequence[str]:
+        return [self.sep.join(strs)]
+
+
+@dc.dataclass(frozen=True)
+class TextwrapReflower:
+    sep: str = ' '
+    opts: TextwrapOpts = TextwrapOpts()
+
+    def __call__(self, strs: ta.Sequence[str], current_indent: int = 0) -> ta.Sequence[str]:
+        return textwrap.wrap(
+            self.sep.join(strs),
+            **dc.asdict(dc.replace(
+                self.opts,
+                width=self.opts.width - current_indent,
+            )),
+        )
+
+
+##
+
+
+def reflow_block_text(
+        root: Part,
+        reflower: TextReflower = JoiningReflower(),
+) -> Part:
+    def rec(p: Part, ci: int) -> Part:
+        if isinstance(p, Blank):
+            return p
+
+        elif isinstance(p, Text):
+            if (rf := reflower([p.s], ci)) != [p.s]:
+                p = blockify(*map(Text, rf))  # noqa
+            return p
+
+        elif isinstance(p, Indent):
+            if (np := rec(p.p, ci + p.n)) is not p.p:
+                p = Indent(p.n, np)  # type: ignore[arg-type]
+            return p
+
+        elif isinstance(p, List):
+            ne = [rec(e, ci + len(p.d) + 1) for e in p.es]
+            if not all_same(ne, p.es):
+                p = List(p.d, ne)
+            return p
+
+        elif not isinstance(p, Block):
+            raise TypeError(p)
+
+        ps = [rec(c, ci) for c in p.ps]
+
+        new: list[Part | list[str]] = []
+        for c in ps:
+            if isinstance(c, Text):
+                if new and isinstance(x := new[-1], list):
+                    x.append(c.s)
+                else:
+                    new.append([c.s])
+            else:
+                new.append(c)
+
+        return blockify(*lang.flatmap(
+            lambda x: map(Text, reflower(x, ci)) if isinstance(x, list) else [x],  # noqa
+            new,
+        ))
+
+    return rec(root, 0)

omlish/text/docwrap/rendering.py

@@ -0,0 +1,142 @@
+import functools
+import io
+import typing as ta
+
+from ... import check
+from .parts import Blank
+from .parts import Block
+from .parts import Indent
+from .parts import List
+from .parts import Part
+from .parts import Text
+
+
+##
+
+
+@functools.lru_cache
+def _indent_str(n: int) -> str:
+    return ' ' * n
+
+
+##
+
+
+def render_to(root: Part, out: ta.Callable[[str], ta.Any]) -> None:
+    i_stk: list[int] = [0]
+    ci = 0
+
+    def write(s: str, ti: int | None = None) -> None:
+        if (nl := '\n' in s) and s != '\n':
+            check.state(s[-1] == '\n')
+            check.state(s.count('\n') == 1)
+
+        if ti is None:
+            ti = i_stk[-1]
+        nonlocal ci
+        if ci < ti:
+            out(_indent_str(ti - ci))
+            ci = ti
+
+        out(s)
+
+        if nl:
+            ci = 0
+
+    def rec(p: Part) -> None:
+        nonlocal ci
+
+        if isinstance(p, Blank):
+            check.state(ci == 0)
+            out('\n')
+
+        elif isinstance(p, Text):
+            write(p.s)
+            write('\n')
+
+        elif isinstance(p, Block):
+            for c in p.ps:
+                rec(c)
+
+        elif isinstance(p, Indent):
+            i_stk.append(i_stk[-1] + p.n)
+            rec(p.p)
+            i_stk.pop()
+
+        elif isinstance(p, List):
+            i_stk.append((li := i_stk[-1]) + len(p.d) + 1)
+            sd = p.d + ' '
+            for e in p.es:
+                if isinstance(e, Blank):
+                    rec(e)
+                else:
+                    check.state(ci == 0)
+                    write(sd, li)
+                    ci += len(sd)
+                    rec(e)
+            i_stk.pop()
+
+        else:
+            raise TypeError(p)
+
+    rec(root)
+    check.state(i_stk == [0])
+
+
+def render(root: Part) -> str:
+    buf = io.StringIO()
+    render_to(root, buf.write)
+    return buf.getvalue()
+
+
+##
+
+
+def dump_to(root: Part, out: ta.Callable[[str], ta.Any]) -> None:
+    i = 0
+
+    def write(s: str) -> None:
+        out(_indent_str(i * 2))
+        out(s)
+        out('\n')
+
+    def rec(p: Part) -> None:
+        nonlocal i
+
+        if isinstance(p, Blank):
+            write('blank')
+
+        elif isinstance(p, Text):
+            write(f'text:{p.s!r}')
+
+        elif isinstance(p, Block):
+            write(f'block/{len(p.ps)}')
+            i += 1
+            for c in p.ps:
+                rec(c)
+            i -= 1
+
+        elif isinstance(p, Indent):
+            write(f'indent:{p.n}')
+            i += 1
+            rec(p.p)
+            i -= 1
+
+        elif isinstance(p, List):
+            write(f'list/{len(p.es)}:{p.d!r}')
+            i += 1
+            for e in p.es:
+                rec(e)
+            i -= 1
+
+        else:
+            raise TypeError(p)
+
+    rec(root)
+    check.state(i == 0)
+
+
+def dump(root: Part) -> str:
+    buf = io.StringIO()
+    dump_to(root, buf.write)
+    return buf.getvalue()

omlish/text/docwrap/utils.py

@@ -0,0 +1,11 @@
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def all_same(l: ta.Sequence[T], r: ta.Sequence[T]) -> bool:
+    return len(l) == len(r) and all(x is y for x, y in zip(l, r, strict=True))

omlish/text/docwrap/wrapping.py

@@ -0,0 +1,59 @@
+"""
+TODO:
+ - a reflowing.TextReflower
+ - import textwrap lol
+ - obviously handle hyphens, underscores, etc
+ - optionally preserve/normalize inter-sentence spaces - '.  ' vs '. '
+ - detect if 'intentionally' smaller than current remaining line width, if so do not merge.
+  - maybe if only ending with punctuation?
+ - detect 'matched pairs' of 'quotes'? to preserve whitespace? `foo  bar` ...
+  - how to escape it lol - if we see any \\` do we give up?
+"""
+import re
+import typing as ta
+
+
+SpanKind: ta.TypeAlias = ta.Literal[
+    'word',
+    'space',
+    'symbol',
+]
+
+
+##
+
+
+class Span(ta.NamedTuple):
+    k: SpanKind
+    s: str
+
+    def __repr__(self) -> str:
+        return f'{self.k}:{self.s!r}'
+
+
+_SPAN_PAT = re.compile(r'(\w+)|(\s+)')
+
+
+def split_line_spans(s: str) -> list[Span]:
+    spans: list[Span] = []
+    p = 0
+    for m in _SPAN_PAT.finditer(s):
+        l, r = m.span()
+        if p < l:
+            spans.append(Span('symbol', s[p:l]))
+        if m.group(1):
+            spans.append(Span('word', m.group(1)))
+        else:
+            spans.append(Span('space', m.group(2)))
+        p = r
+    if p < len(s):
+        spans.append(Span('symbol', s[p:]))
+    return spans
+
+
+def _main() -> None:
+    print(split_line_spans('hi i am a string! this has a hy-phen.'))
+
+
+if __name__ == '__main__':
+    _main()

omlish/text/textwrap.py

@@ -0,0 +1,51 @@
+import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TextwrapOpts:
+    # The maximum width of wrapped lines (unless break_long_words is false).
+    width: int = 70  # noqa
+
+    _: dc.KW_ONLY
+
+    # String that will be prepended to the first line of wrapped output. Counts towards the line's width.
+    initial_indent: str = ''
+
+    # String that will be prepended to all lines save the first of wrapped output; also counts towards each line's
+    # width.
+    subsequent_indent: str = ''
+
+    # Expand tabs in input text to spaces before further processing. Each tab will become 0 .. 'tabsize' spaces,
+    # depending on its position in its line. If false, each tab is treated as a single character.
+    expand_tabs: bool = True
+
+    # Expand tabs in input text to 0 .. 'tabsize' spaces, unless 'expand_tabs' is false.
+    tabsize: int = 8
+
+    # Replace all whitespace characters in the input text by spaces after tab expansion. Note that if expand_tabs is
+    # false and replace_whitespace is true, every tab will be converted to a single space!
+    replace_whitespace: bool = True
+
+    # Ensure that sentence-ending punctuation is always followed by two spaces. Off by default because the algorithm is
+    # (unavoidably) imperfect.
+    fix_sentence_endings: bool = False
+
+    # Break words longer than 'width'.  If false, those words will not be broken, and some lines might be longer than
+    # 'width'.
+    break_long_words: bool = True
+
+    # Allow breaking hyphenated words. If true, wrapping will occur preferably on whitespaces and right after hyphens
+    # part of compound words.
+    break_on_hyphens: bool = True
+
+    # Drop leading and trailing whitespace from lines.
+    drop_whitespace: bool = True
+
+    # Truncate wrapped lines.
+    max_lines: int | None = None
+
+    # Append to the last line of truncated text.
+    placeholder: str = ' [...]'

{omlish-0.0.0.dev473.dist-info → omlish-0.0.0.dev474.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev473
+Version: 0.0.0.dev474
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -18,7 +18,7 @@ Provides-Extra: all
 Requires-Dist: anyio~=4.11; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: greenlet~=3.2; extra == "all"
-Requires-Dist: trio~=0.31; extra == "all"
+Requires-Dist: trio~=0.32; extra == "all"
 Requires-Dist: trio-asyncio~=0.15; extra == "all"
 Requires-Dist: lz4~=4.4; extra == "all"
 Requires-Dist: python-snappy~=0.7; extra == "all"
@@ -58,7 +58,7 @@ Provides-Extra: async
 Requires-Dist: anyio~=4.11; extra == "async"
 Requires-Dist: sniffio~=1.3; extra == "async"
 Requires-Dist: greenlet~=3.2; extra == "async"
-Requires-Dist: trio~=0.31; extra == "async"
+Requires-Dist: trio~=0.32; extra == "async"
 Requires-Dist: trio-asyncio~=0.15; extra == "async"
 Provides-Extra: compress
 Requires-Dist: lz4~=4.4; extra == "compress"
@@ -234,7 +234,8 @@ dependencies of any kind**.
   - **[queries](https://github.com/wrmsr/omlish/blob/master/omlish/sql/queries)** - A SQL query builder with a fluent
     interface.
   - **[alchemy](https://github.com/wrmsr/omlish/blob/master/omlish/sql/alchemy)** - SQLAlchemy utilities. The codebase
-    is moving away from SQLAlchemy however in favor of its own internal SQL api.
+    has moved away from SQLAlchemy in favor of its own internal SQL api, but it will likely still remain as an optional
+    dep for the api adapter.
 
 - **[testing](https://github.com/wrmsr/omlish/blob/master/omlish/testing)** - Test - primarily pytest - helpers,
   including:
@@ -294,8 +295,8 @@ examples are:
 - **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
   stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
 - **wrapt** - For (optionally-enabled) injector circular proxies.
-- **sqlalchemy** - Parts of the codebase use SQLAlchemy for db stuff, but it is being migrated away from in favor of the
-  internal api. It will however likely still remain as an optional dep for the api adapter.
+- **sqlalchemy** - The codebase has migrated away from SQLAlchemy in favor of the internal api but it retains it as an
+  optional dep to support adapting the internal api to it.
 
 Additionally, some catchall dep categories include:
 

{omlish-0.0.0.dev473.dist-info → omlish-0.0.0.dev474.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.omlish-manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=BoG13E5l8VG76ZQEVeoy6T90tE-JO2_DCUi_285ZWU0,3611
+omlish/__about__.py,sha256=35_ul-npqd8WV5dBJiHcOowqXVDo-ayDrD_0zvxyImg,3611
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ZNIMl1kwg3qdei4DiUrJPQe5M81S1e76N-GuNSwLBAE,8683
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -202,17 +202,18 @@ omlish/dataclasses/tools/static.py,sha256=byDnPc0W15s3YPQNC9oyCASKVNxCytrHGLvDky
 omlish/diag/__init__.py,sha256=c1q8vuapGH1YiYdU300FIJXMI1MOcnLNBZXr-zc8BXk,1181
 omlish/diag/asts.py,sha256=MWh9XAG3m9L10FIJCyoNT2aU4Eft6tun_x9K0riq6Dk,3332
 omlish/diag/debug.py,sha256=ClED7kKXeVMyKrjGIxcq14kXk9kvUJfytBQwK9y7c4Q,1637
-omlish/diag/lslocks.py,sha256=VuA4MNNqXTcnHWsJvulGM6pNJRKmlXFXUZTfXpY0V6g,1750
-omlish/diag/lsof.py,sha256=5N5aZQ7UqEBgV-hj3_a8QcvALOeLlVb8otqF2hvucxY,9107
 omlish/diag/procfs.py,sha256=eeB3L9UpNBpAfsax3U6OczayYboPlFzOGplqlQ4gBNY,9700
 omlish/diag/procstats.py,sha256=EJEe2Zc58ykBoTfqMXro7H52aQa_pd6uC2hsIPFceso,825
-omlish/diag/ps.py,sha256=MEpMU6fbkh0bSWrOHh_okOa0JDTUSUQUVSYBdh1TGvE,1672
 omlish/diag/pycharm.py,sha256=_WVmPm1E66cBtR4ukgUAaApe_3rX9Cv3sQRP5PL37P8,5013
 omlish/diag/pydevd.py,sha256=JEHC0hiSJxL-vVtuxKUi1BNkgUKnRC1N4alDg6JP5WQ,8363
 omlish/diag/threads.py,sha256=sjtlTl41wxssoVCDkBB6xeLF-9kJEK3eA6hmSFWJSQA,3643
 omlish/diag/timers.py,sha256=cxX3GgjTIjBx9DI4pzCCO5Hfqb1TM3uo22yim7kjfRU,3831
 omlish/diag/_pycharm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/diag/_pycharm/runhack.py,sha256=IxawPyqrPfY1fpV1D_9dZXxny89fVSR3RlmqlbaRctw,37869
+omlish/diag/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/diag/cmds/lslocks.py,sha256=iEYe3OqcbMCKg1NbtO2EsYsnr2GnDYnNdi6Cbb_zEKM,1756
+omlish/diag/cmds/lsof.py,sha256=hmrEZJNY0rQxa42t2Y3e3w5ZVe8rJqO2eI7_8HmzZEQ,9113
+omlish/diag/cmds/ps.py,sha256=Ff0JusuXhJqpZ4w5cpOwovoRftQUtaKjT5YTtHfazl4,1678
 omlish/diag/replserver/__init__.py,sha256=uLo6V2aQ29v9z3IMELlPDSlG3_2iOT4-_X8VniF-EgE,235
 omlish/diag/replserver/__main__.py,sha256=LmU41lQ58bm1h4Mx7S8zhE_uEBSC6kPcp9mn5JRpulA,32
 omlish/diag/replserver/console.py,sha256=MxDLslAaYfC-l0rfGO-SnYAJ__8RWBJQ5FxGi29czYU,7438
@@ -325,15 +326,15 @@ omlish/http/wsgi.py,sha256=1JpfrY2JrQ0wrEVE0oLdQMWZw8Zcx0b4_9f3VmH4JKA,1070
 omlish/http/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/clients/asyncs.py,sha256=QrbavgXv4BuQFW0bRojy-dxa_jpxjPVLA7eyfo1zzns,4230
 omlish/http/clients/base.py,sha256=bm3Oy2wuunSO3Rd2dxCmhHoZcQ8X9B5pkzaudbjZKvI,2810
-omlish/http/clients/default.py,sha256=fnz-pvPKHc7Kgft4XRwOZ6ZUUtt5D6ljuvOGAA8mgQw,5639
-omlish/http/clients/executor.py,sha256=yvjLs8XfJuHx0mDOC1nqKsQbQXqo2cldH8oQIBhfjOY,1854
-omlish/http/clients/httpx.py,sha256=Yp0u_DAPImqJ1_jlAN9RKWbkUP6Y_lfGJWJjaFWBdJQ,4793
+omlish/http/clients/default.py,sha256=yQ7kOxlU-Dds8NdIJszeHkgnxtiJd6W-d0oUhKXTaYI,5653
+omlish/http/clients/executor.py,sha256=r66xoGWdRsaSpfGtx8ovf3pOMG3k4UONlZEQZ58KAS0,1854
+omlish/http/clients/httpx.py,sha256=T1Pa9Of6GylTmt9AGp8D6Uni3HxOtP7OPsImo35Kc1o,4029
 omlish/http/clients/middleware.py,sha256=xnXlNN1MU4sUKtkhPzdpRQsRh9wpLf1r7OGKjqGzLWg,5058
 omlish/http/clients/sync.py,sha256=jVbqbUlruuaNFKUYQr55kVF6bwcIZgeaLyLclXM_T5w,3891
-omlish/http/clients/syncasync.py,sha256=2VfApHxoz3dBilOJhxyaP9LnWWNdqn5G4Tss6CRruXM,1401
+omlish/http/clients/syncasync.py,sha256=nhQlcds4BWib_gphhGElUdA_0uJ0tD1lV1At-fr13Q0,1401
 omlish/http/clients/urllib.py,sha256=c8TQITZYRo5RrdxaNhsE2QoeDw4mZW0wLzoIsWYTYwU,2852
 omlish/http/clients/coro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/http/clients/coro/sync.py,sha256=x5VoA31lPyxGMkuYAXgEziDfL_mhV_VP6iQ4HmpLjjE,5762
+omlish/http/clients/coro/sync.py,sha256=Fk1KdJf9q6ba2-7HWzj7Tb-ibBuj5VIV5f4SCziP-C8,5762
 omlish/http/coro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/coro/io.py,sha256=d97Oa7KlgMP7BQWdhUbOv3sfA96uWyMtjJF7lJFwZC0,1090
 omlish/http/coro/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -390,10 +391,10 @@ omlish/inject/impl/scopes.py,sha256=sqtjHe6g0pAEOHqIARXGiIE9mKmGmlqh1FDpskV4TIw,
 omlish/inject/impl/sync.py,sha256=_aLaC-uVNHOePcfE1as61Ni7fuyHZpjEafIWBc7FvC0,1049
 omlish/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/io/abc.py,sha256=M40QB2udYpCEqmlxCcHv6FlJYJY6ymmJQBlaklYv0U8,1256
-omlish/io/buffers.py,sha256=GueMHwOLGd6Q-UxLrGobYYNTm0fc5GBtltwzYgLxGIQ,10935
+omlish/io/buffers.py,sha256=eeDSG0mhwx1IAYPu3pSe-ce3LG5WpQz924OsRyLu0mI,10935
 omlish/io/fileno.py,sha256=_W3qxkIKpnabn1_7kgmKdx0IsPF3R334xWnF_TtkEj4,185
 omlish/io/pyio.py,sha256=xmHTV-sn7QZThWCVBo6lTM7dhgsQn7m2L0DqRwdF2-8,94509
-omlish/io/readers.py,sha256=O_FcMW6wXSoKhyhM9dKFg9lVJ8mS-Q5I9xnFLfgJMKQ,583
+omlish/io/readers.py,sha256=w67uZQbWzed4Ton2kyA_WRrRz-IRXmFip8EJtpAxLYU,583
 omlish/io/compress/__init__.py,sha256=fJFPT4ONfqxmsA4jR6qbMt2woIyyEgnc_qOWK9o1kII,247
 omlish/io/compress/abc.py,sha256=P9YoQX8XYoq2UfBsinKLUuwwqV1ODUIJzjTraRWGF1M,3090
 omlish/io/compress/adapters.py,sha256=LJHhjwMHXstoLyX_q0QhGoBAcqyYGWfzhzQbGBXHzHY,6148
@@ -635,7 +636,7 @@ omlish/os/pidfiles/__main__.py,sha256=nfjVxFY9I2I7hfb81rCxX6zm2Rc3P87ySpUouy33vG
 omlish/os/pidfiles/cli.py,sha256=dAKukx4mrarH8t7KZM4n_XSfTk3ycShGAFqRrirK5dw,2079
 omlish/os/pidfiles/manager.py,sha256=oOnL90ttOG5ba_k9XPJ18reP7M5S-_30ln4OAfYV5W8,2357
 omlish/os/pidfiles/pidfile.py,sha256=KlqrW7I-lYVDNJspFHE89i_A0HTTteT5B99b7vpTfNs,4400
-omlish/os/pidfiles/pinning.py,sha256=WGK0kmMBhH1isGSdpm9fKJQqjaL7kxCuT-aAaaYCyn4,6666
+omlish/os/pidfiles/pinning.py,sha256=JJBpW-9cM9Jv_2l0LP4vXQhpx8EnjFaLUnt1FnxrKhw,6676
 omlish/reflect/__init__.py,sha256=omD3VLFQtYTwPxrTH6gLATQIax9sTGGKc-7ps96-q0g,1202
 omlish/reflect/inspect.py,sha256=dUrVz8VfAdLVFtFpW416DxzVC17D80cvFb_g2Odzgq8,1823
 omlish/reflect/ops.py,sha256=4mGvFMw5D6XGbhDhdCqZ1dZsiqezUTenDv63FIDohpY,3029
@@ -831,6 +832,16 @@ omlish/text/minja.py,sha256=7UKNalkWpTG_364OIo7p5ym--uiNPR2RFBW_W8rrO4I,9194
 omlish/text/parts.py,sha256=MFi-ANxXlBiOMqW2y2S0BRg6xDwPYxSXSfrYPM3rtcE,6669
 omlish/text/random.py,sha256=8feS5JE_tSjYlMl-lp0j93kCfzBae9AM2cXlRLebXMA,199
 omlish/text/templating.py,sha256=i-HU7W-GtKdnBhEG3mnSey5ig7vV0q02D3pVzMoOzJY,3318
+omlish/text/textwrap.py,sha256=fTe04E4T5MpMGLz5QOTfT8T93FdiIT1tohEpzL28_zI,1874
+omlish/text/docwrap/__init__.py,sha256=NQh0gVyJSxUOAX7nnwsAOwHVPeuZ8abVaN5topQI6gE,42
+omlish/text/docwrap/api.py,sha256=cePtl2fLb1FwWN0z6dL5CquAt1AiH0aEEiGp7ijF-Wo,1602
+omlish/text/docwrap/groups.py,sha256=8__fk1q3KX7tRBcWQ2RprpFS2p4QYnRtCNOxbUBaOVI,1887
+omlish/text/docwrap/lists.py,sha256=8ZTfXV-hJaTZTf0jAkODke0Z87kZDS5w-xGqNlc0U_c,4693
+omlish/text/docwrap/parts.py,sha256=IaW_qRvIiP3e12OhFgTIa_qKamQX4MAps-BG5CT_dDw,3338
+omlish/text/docwrap/reflowing.py,sha256=F1mrGpNvTPfII8LpnZGCU4aoUxEvh91iL1mfswHB98U,2584
+omlish/text/docwrap/rendering.py,sha256=SmnkLdePgK4qH0f3lGRY94NfRKJNdTlUaTgzo6RjEnM,2848
+omlish/text/docwrap/utils.py,sha256=n4oFWgA9PBC_77vYrH8H7uFR2s8bcFqDtrCWTcyhGFw,188
+omlish/text/docwrap/wrapping.py,sha256=VyECcYTpjPz7SidT8PJi7mLTg4bGLzaME1H3G5Ub0Yg,1314
 omlish/text/go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/text/go/quoting.py,sha256=zbcPEDWsdj7GAemtu0x8nwMqpIu2C_5iInSwn6mMWlE,9142
 omlish/typedvalues/__init__.py,sha256=dQpM8VaON8S7dUv1LBwhyBDjUVo7EW475a9DpnDQz1E,936
@@ -843,9 +854,9 @@ omlish/typedvalues/marshal.py,sha256=2xqX6JllhtGpmeYkU7C-qzgU__0x-vd6CzYbAsocQlc
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev473.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev473.dist-info/METADATA,sha256=-EYEBlROnYaFvqD5fxDP0hmJ1GTBnmWbV0EzbBxPACc,18999
-omlish-0.0.0.dev473.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev473.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev473.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev473.dist-info/RECORD,,
+omlish-0.0.0.dev474.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev474.dist-info/METADATA,sha256=sTrBg5y3IV8XQuez3bmFN_mIxOqGGArfERXAKffXCFw,19032
+omlish-0.0.0.dev474.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev474.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev474.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev474.dist-info/RECORD,,