omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/term/termstate.py

@@ -0,0 +1,67 @@
+import dataclasses as dc
+import termios
+
+
+##
+
+
+@dc.dataclass()
+class TermState:
+    iflag: int
+    oflag: int
+    cflag: int
+    lflag: int
+    ispeed: int
+    ospeed: int
+    cc: list[bytes]
+
+    #
+
+    def copy(self) -> 'TermState':
+        return TermState(*self.as_list())  # type: ignore[arg-type]
+
+    def as_list(self) -> list[int | list[bytes]]:
+        return [
+            self.iflag,
+            self.oflag,
+            self.cflag,
+            self.lflag,
+            self.ispeed,
+            self.ospeed,
+            self.cc[:],
+        ]
+
+
+def get_term_state(fd: int) -> TermState:
+    return TermState(*termios.tcgetattr(fd))
+
+
+def set_term_state(fd: int, attrs: TermState, when: int = termios.TCSANOW) -> None:
+    termios.tcsetattr(fd, when, attrs.as_list())
+
+
+##
+
+
+class TermStateStack:
+    def __init__(self, fd: int = 0) -> None:  # noqa
+        super().__init__()
+
+        self._fd = fd
+        self._stack: list[TermState] = []
+
+    #
+
+    def get(self) -> TermState:
+        return get_term_state(self._fd)
+
+    def set(self, attrs: TermState, when: int = termios.TCSANOW) -> None:
+        set_term_state(self._fd, attrs, when)
+
+    #
+
+    def save(self) -> None:
+        self._stack.append(self.get())
+
+    def restore(self) -> None:
+        self.set(self._stack.pop())

omlish/term/vt100/terminal.py

@@ -5,9 +5,6 @@ import typing as ta
 from ...lite.check import check
 
 
-T = ta.TypeVar('T')
-
-
 ##
 
 

omlish/testing/pytest/plugins/asyncs/fixtures.py

@@ -141,7 +141,10 @@ class AsyncsFixture:
                 finally:
                     nursery_fixture.cancel_scope.cancel()
 
-        except BaseException as exc:  # noqa
+        except* (Skipped, XFailed):
+            pass
+
+        except* BaseException as exc:  # noqa
             test_ctx.crash(self, exc)
 
         finally:

omlish/testing/pytest/plugins/skips.py

@@ -1,7 +1,3 @@
-"""
-TODO:
- - go-style tags: +slow,-ci, ...
-"""
 from _pytest.main import resolve_collection_argument  # noqa
 import pytest
 
@@ -15,10 +11,11 @@ from ._registry import register
 class SkipsPlugin:
     def pytest_collection_modifyitems(self, session, items):
         dct: dict[str, set[str]] = {}
-        for arg in session.config.args:
+        for i, arg in enumerate(session.config.args):
             ca = resolve_collection_argument(
                 session.config.invocation_params.dir,
                 arg,
+                i,
                 as_pypath=session.config.option.pyargs,
             )
             if ca.path.is_file():

omlish/testing/unittest/main.py

@@ -257,11 +257,11 @@ class UnittestRunCli:
 
         if exit:
             if not result.num_tests_run and not result.skipped:
-                sys.exit(self.NO_TESTS_EXITCODE)
+                raise SystemExit(self.NO_TESTS_EXITCODE)
             elif result.was_successful:
-                sys.exit(0)
+                raise SystemExit(0)
             else:
-                sys.exit(1)
+                raise SystemExit(1)
 
 
 ##

omlish/text/docwrap/__init__.py

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

omlish/text/docwrap/__main__.py

@@ -0,0 +1,11 @@
+# @omlish-manifest
+_CLI_MODULE = {'!omdev.cli.types.CliModule': {
+    'name': 'docwrap',
+    'module': __name__,
+}}
+
+
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()

omlish/text/docwrap/api.py

@@ -0,0 +1,83 @@
+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
+
+
+##
+
+
+DEFAULT_TEXTWRAP_OPTS = TextwrapOpts(
+    width=120,
+    break_on_hyphens=False,
+)
+
+
+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 = DEFAULT_TEXTWRAP_OPTS
+    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/cli.py

@@ -0,0 +1,86 @@
+"""
+Usable as a jetbrains external tool:
+  `om docwrap -i "$FilePath$" -s "$SelectionStartLine$" -e "$SelectionEndLine$"`
+"""
+import argparse
+import sys
+import typing as ta
+
+from .api import docwrap
+from .rendering import render
+
+
+##
+
+
+def _main(argv: ta.Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('file', nargs='?')
+
+    parser.add_argument('-w', '--width', type=int, default=120)
+
+    parser.add_argument('-s', '--start-line', type=int)
+    parser.add_argument('-e', '--end-line', type=int)
+    parser.add_argument('-i', '--in-place', action='store_true')
+
+    args = parser.parse_args(argv)
+
+    #
+
+    if args.file:
+        with open(args.file) as f:
+            in_txt = f.read()
+    else:
+        if args.in_place:
+            raise ValueError('Cannot use --in-place without specifying a file')
+        in_txt = sys.stdin.read()
+
+    in_lines = in_txt.splitlines()
+
+    #
+
+    if args.start_line is not None and args.end_line is not None:
+        if args.start_line > args.end_line:
+            raise ValueError('Start line cannot be greater than end line')
+    if args.start_line is not None:
+        if args.start_line < 1:
+            raise ValueError('Start line cannot be less than 1')
+        start_line = args.start_line - 1
+    else:
+        start_line = 0
+    if args.end_line is not None:
+        if args.end_line < 1:
+            raise ValueError('End line cannot be less than 1')
+        end_line = args.end_line - 1
+    else:
+        end_line = len(in_lines) - 1
+
+    #
+
+    in_part = '\n'.join(in_lines[start_line:end_line + 1])
+
+    root = docwrap(
+        in_part,
+        width=args.width,
+    )
+
+    out_part = render(root)
+
+    out_txt = '\n'.join([
+        *in_lines[:start_line],
+        out_part,
+        *in_lines[end_line + 1:],
+        '',
+    ])
+
+    #
+
+    if args.in_place:
+        with open(args.file, 'w') as f:
+            f.write(out_txt)
+    else:
+        print(out_txt)
+
+
+if __name__ == '__main__':
+    _main()

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,146 @@
+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 unblockify(p: Part) -> ta.Sequence[Part]:
+    if isinstance(p, Block):
+        return p.ps
+    else:
+        return [p]
+
+
+##
+
+
+def build_root(s: str) -> Part:
+    lst: list[Part] = []
+
+    for l in s.split('\n'):
+        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)