omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

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)

omlish/text/docwrap/reflowing.py

@@ -0,0 +1,106 @@
+"""
+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 .parts import unblockify
+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]
+
+        ps = list(unblockify(blockify(*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,151 @@
+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
+    need_nl = False
+
+    def write(
+            s: str,
+            ti: int | None = None,
+            endl: bool = False,
+    ) -> None:
+        check.not_in('\n', s)
+
+        nonlocal need_nl
+        nonlocal ci
+        if need_nl:
+            check.state(ci == 0)
+            out('\n')
+            need_nl = False
+
+        if ti is None:
+            ti = i_stk[-1]
+        if ci < ti:
+            out(_indent_str(ti - ci))
+            ci = ti
+
+        out(s)
+
+        if endl:
+            need_nl = True
+            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, endl=True)
+
+        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/filecache.py

@@ -2,10 +2,10 @@
 Features:
  - get (line, offset)
  - invalidate
-  - filewatcher
+  - TODO: filewatcher
  - linecache interop
   - tokenize.open - detect encoding - only for .py
- - directory / path_parts tree?
+ - TODO: directory / path_parts tree?
 
 TODO:
  - read raw, decode (detect)

omlish/text/lorem.py

@@ -0,0 +1,6 @@
+LOREM = (
+    'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore '
+    'magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo '
+    'consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. '
+    'Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
+)

omlish/text/parts.py

@@ -75,7 +75,7 @@ class PartTransform:
     def __call__(self, part: Part | None) -> Part:
         return self._transform(part)
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def _transform(self, part: Part | None) -> Part:
         raise TypeError(part)
 
@@ -214,7 +214,7 @@ class PartRenderer:
     def __call__(self, part: Part | None) -> None:
         return self._render(part)
 
-    @dispatch.method
+    @dispatch.method()
     def _render(self, part: Part | None) -> None:
         raise TypeError(part)
 

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 = ' [...]'