omlish 0.0.0.dev473__tar.gz → 0.0.0.dev474__tar.gz

{omlish-0.0.0.dev473/omlish.egg-info → omlish-0.0.0.dev474}/PKG-INFO

@@ -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 → omlish-0.0.0.dev474}/README.md

@@ -125,7 +125,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:
@@ -185,8 +186,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 → omlish-0.0.0.dev474}/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-0.0.0.dev473/omlish/diag → omlish-0.0.0.dev474/omlish/diag/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-0.0.0.dev473/omlish/diag → omlish-0.0.0.dev474/omlish/diag/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-0.0.0.dev473/omlish/diag → omlish-0.0.0.dev474/omlish/diag/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev473 → omlish-0.0.0.dev474}/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-0.0.0.dev474/omlish/text/docwrap/__init__.py

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

omlish-0.0.0.dev474/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-0.0.0.dev474/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-0.0.0.dev474/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)