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

omlish/io/buffers.py

@@ -1,10 +1,18 @@
 # ruff: noqa: UP006 UP007 UP043 UP045
 # @omlish-lite
+"""
+TODO:
+ - overhaul and just coro-ify pyio?
+"""
 import io
 import typing as ta
 
 from ..lite.attrops import attr_repr
 from ..lite.check import check
+from .readers import AsyncBufferedBytesReader
+from .readers import AsyncRawBytesReader
+from .readers import BufferedBytesReader
+from .readers import RawBytesReader
 
 
 ##
@@ -183,6 +191,9 @@ class ReadableListBuffer:
 
         self._lst: list[bytes] = []
 
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError("Use 'buf is not None' or 'len(buf)'.")
+
     def __len__(self) -> int:
         return sum(map(len, self._lst))
 
@@ -249,6 +260,110 @@ class ReadableListBuffer:
         r = self.read_until_(delim)
         return r if isinstance(r, bytes) else None
 
+    #
+
+    DEFAULT_BUFFERED_READER_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    @ta.final
+    class _BufferedBytesReader(BufferedBytesReader):
+        def __init__(
+                self,
+                raw: RawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return self._raw.read1(n)
+
+        def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return self.readall()
+            while len(self._buf) < n:
+                if not (b := self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while (b := self._raw.read1(self._chunk_size)):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_buffered_reader(
+            self,
+            raw: RawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> BufferedBytesReader:
+        return self._BufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
+    @ta.final
+    class _AsyncBufferedBytesReader(AsyncBufferedBytesReader):
+        def __init__(
+                self,
+                raw: AsyncRawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        async def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return await self._raw.read1(n)
+
+        async def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return await self.readall()
+            while len(self._buf) < n:
+                if not (b := await self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        async def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while b := await self._raw.read1(self._chunk_size):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_async_buffered_reader(
+            self,
+            raw: AsyncRawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> AsyncBufferedBytesReader:
+        return self._AsyncBufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
 
 ##
 

omlish/io/readers.py

@@ -0,0 +1,29 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import typing as ta
+
+
+##
+
+
+class RawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> bytes: ...
+
+
+class BufferedBytesReader(RawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> bytes: ...
+
+    def readall(self) -> bytes: ...
+
+
+#
+
+
+class AsyncRawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+
+class AsyncBufferedBytesReader(AsyncRawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+    def readall(self) -> ta.Awaitable[bytes]: ...

omlish/lite/contextmanagers.py

@@ -54,7 +54,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -65,7 +65,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -113,7 +113,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -124,7 +124,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)

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)