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

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

omlish/typedvalues/marshal.py

@@ -1,9 +1,10 @@
+import typing as ta
+
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .. import marshal as msh
 from .. import reflect as rfl
-from ..funcs import match as mfs
 from .collection import TypedValues
 from .reflect import reflect_typed_values_impls
 from .values import ScalarTypedValue
@@ -14,60 +15,77 @@ from .values import TypedValue
 
 
 def _build_typed_value_poly(rty: rfl.Type) -> msh.Polymorphism:
-    ty: type[TypedValue] = check.issubclass(check.isinstance(rty, type), TypedValue)
+    ty: type[TypedValue] = check.issubclass(check.isinstance(rty, type), TypedValue)  # noqa
     check.state(lang.is_abstract_class(ty))
     return msh.polymorphism_from_subclasses(
         ty,
         naming=msh.Naming.SNAKE,
-        strip_suffix='auto',
+        strip_suffix=msh.AutoStripSuffix,
     )
 
 
-class TypedValueMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, ScalarTypedValue) and
-        not lang.is_abstract_class(rty)
-    ))
-    def _build_scalar(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        dc_rfl = dc.reflect(check.isinstance(rty, type))
-        v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
-        v_m = ctx.make(v_rty)
-        return msh.WrappedMarshaler(lambda _, o: o.v, v_m)
-
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, TypedValue) and
-        lang.is_abstract_class(rty)
-    ))
-    def _build_abstract(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return msh.make_polymorphism_marshaler(
+class TypedValueMarshalerFactory(msh.MarshalerFactoryMethodClass):
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_scalar(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, ScalarTypedValue) and
+            not lang.is_abstract_class(rty)
+        ):
+            return None
+
+        def inner() -> msh.Marshaler:
+            dc_rfl = dc.reflect(check.isinstance(rty, type))
+            v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
+            v_m = ctx.make_marshaler(v_rty)
+            return msh.WrappedMarshaler(lambda _, o: o.v, v_m)
+
+        return inner
+
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_abstract(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, TypedValue) and
+            lang.is_abstract_class(rty)
+        ):
+            return None
+
+        return lambda: msh.make_polymorphism_marshaler(
             _build_typed_value_poly(rty).impls,
             msh.WrapperTypeTagging(),
             ctx,
         )
 
 
-class TypedValueUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, ScalarTypedValue) and
-        not lang.is_abstract_class(rty)
-    ))
-    def _build_scalar(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        rty = check.isinstance(rty, type)
-        dc_rfl = dc.reflect(rty)
-        v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
-        v_u = ctx.make(v_rty)
-        return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
-
-    @mfs.simple(lambda _, ctx, rty: (
-        isinstance(rty, type) and
-        issubclass(rty, TypedValue) and
-        lang.is_abstract_class(rty)
-    ))
-    def _build_abstract(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return msh.make_polymorphism_unmarshaler(
+class TypedValueUnmarshalerFactory(msh.UnmarshalerFactoryMethodClass):
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_scalar(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, ScalarTypedValue) and
+            not lang.is_abstract_class(rty)
+        ):
+            return None
+
+        def inner() -> msh.Unmarshaler:
+            dc_rfl = dc.reflect(rty)
+            v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
+            v_u = ctx.make_unmarshaler(v_rty)
+            return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
+
+        return inner
+
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _make_abstract(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if not (
+            isinstance(rty, type) and
+            issubclass(rty, TypedValue) and
+            lang.is_abstract_class(rty)
+        ):
+            return None
+
+        return lambda: msh.make_polymorphism_unmarshaler(
             _build_typed_value_poly(rty).impls,
             msh.WrapperTypeTagging(),
             ctx,
@@ -99,7 +117,7 @@ def _build_typed_values_impls(rty: rfl.Type) -> msh.Impls:
 #
 
 
-def build_typed_values_marshaler(ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+def build_typed_values_marshaler(ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> msh.Marshaler:
     tv_m = msh.make_polymorphism_marshaler(
         msh.Impls(_build_typed_values_impls(rty)),
         msh.WrapperTypeTagging(),
@@ -108,20 +126,24 @@ def build_typed_values_marshaler(ctx: msh.MarshalContext, rty: rfl.Type) -> msh.
     return msh.IterableMarshaler(tv_m)
 
 
-class TypedValuesMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is TypedValues)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return build_typed_values_marshaler(ctx, rty)
+class TypedValuesMarshalerFactory(msh.MarshalerFactoryMethodClass):
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_generic(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and rty.cls is TypedValues):
+            return None
+        return lambda: build_typed_values_marshaler(ctx, rty)
 
-    @mfs.simple(lambda _, ctx, rty: rty is TypedValues)
-    def _build_concrete(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        raise NotImplementedError
+    @msh.MarshalerFactoryMethodClass.make_marshaler.register
+    def _make_concrete(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not TypedValues:
+            return None
+        return lambda: lang.raise_(NotImplementedError)
 
 
 #
 
 
-def build_typed_values_unmarshaler(ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+def build_typed_values_unmarshaler(ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> msh.Unmarshaler:
     tv_u = msh.make_polymorphism_unmarshaler(
         msh.Impls(_build_typed_values_impls(rty)),
         msh.WrapperTypeTagging(),
@@ -130,21 +152,25 @@ def build_typed_values_unmarshaler(ctx: msh.UnmarshalContext, rty: rfl.Type) ->
     return msh.IterableUnmarshaler(lambda it: TypedValues(*it), tv_u)  # noqa
 
 
-class TypedValuesUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is TypedValues)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return build_typed_values_unmarshaler(ctx, rty)
+class TypedValuesUnmarshalerFactory(msh.UnmarshalerFactoryMethodClass):
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _build(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (isinstance(rty, rfl.Generic) and rty.cls is TypedValues):
+            return None
+        return lambda: build_typed_values_unmarshaler(ctx, rty)
 
-    @mfs.simple(lambda _, ctx, rty: rty is TypedValues)
-    def _build_concrete(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        raise NotImplementedError
+    @msh.UnmarshalerFactoryMethodClass.make_unmarshaler.register
+    def _build_concrete(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if rty is not TypedValues:
+            return None
+        return lambda: lang.raise_(NotImplementedError)
 
 
 ##
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     msh.install_standard_factories(
         TypedValueMarshalerFactory(),
         TypedValueUnmarshalerFactory(),

omlish/typedvalues/values.py

@@ -11,7 +11,8 @@ T = ta.TypeVar('T')
 
 
 class TypedValue(lang.Abstract):
-    pass
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError(f"Cannot convert {self!r} to bool - use '.v' or 'is not None'.")
 
 
 ##