omdev 0.0.0.dev460__py3-none-any.whl → 0.0.0.dev462__py3-none-any.whl

omdev/markdown/incparse.py

@@ -0,0 +1,116 @@
+import dataclasses as dc
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md
+    import markdown_it.token  # noqa
+
+
+##
+
+
+class IncrementalMarkdownParser:
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+    ) -> None:
+        super().__init__()
+
+        if parser is None:
+            parser = md.MarkdownIt()
+        self._parser = parser
+
+        self._stable_tokens: list[md.token.Token] = []
+        self._buffer = ''
+        self._num_stable_lines = 0  # Number of lines in stable tokens
+
+    class FeedOutput(ta.NamedTuple):
+        stable: ta.Sequence['md.token.Token']
+        new_stable: ta.Sequence['md.token.Token']
+        unstable: ta.Sequence['md.token.Token']
+
+    def feed2(self, chunk: str) -> FeedOutput:
+        self._buffer += chunk
+
+        # Parse the current buffer
+        new_tokens = self._parser.parse(self._buffer)
+
+        # Adjust ALL tokens to account for stable lines from previous parses (new_tokens have line numbers relative to
+        # current buffer)
+        adjusted_tokens = self._adjust_token_line_numbers(new_tokens, self._num_stable_lines)
+
+        # Find stable tokens (all but the last parent and its children)
+        stable_count = self._find_stable_token_count(adjusted_tokens)
+
+        newly_stable: ta.Sequence[md.token.Token]
+        if stable_count > 0:
+            # Extract newly stable tokens (already have adjusted line numbers)
+            newly_stable = adjusted_tokens[:stable_count]
+
+            # Calculate how many lines these stable tokens cover
+            max_line = 0
+            for token in newly_stable:
+                if token.map:
+                    max_line = max(max_line, token.map[1])
+
+            # Update buffer to only contain unstable content
+            if max_line > self._num_stable_lines:
+                # max_line is absolute, num_stable_lines is the current buffer offset
+                lines_to_remove = max_line - self._num_stable_lines
+                lines = self._buffer.split('\n')
+                self._buffer = '\n'.join(lines[lines_to_remove:])
+
+                # Store newly stable tokens (with adjusted line numbers)
+                self._stable_tokens.extend(newly_stable)
+                self._num_stable_lines = max_line
+
+        else:
+            newly_stable = ()
+
+        return IncrementalMarkdownParser.FeedOutput(
+            stable=self._stable_tokens,
+            new_stable=newly_stable,
+            unstable=adjusted_tokens[stable_count:],
+        )
+
+    def feed(self, chunk: str) -> list['md.token.Token']:
+        out = self.feed2(chunk)
+        return [*out.stable, *out.unstable]
+
+    def _find_stable_token_count(self, tokens: list['md.token.Token']) -> int:
+        if not tokens:
+            return 0
+
+        # Find indices of all parent-level tokens (nesting = 0)
+        parent_indices = []
+        for i, token in enumerate(tokens):
+            if token.nesting in (1, 0) and token.level == 0:
+                parent_indices.append(i)
+
+        if len(parent_indices) < 2:
+            # Need at least 2 parent tokens to have stable content
+            return 0
+
+        # The last parent and everything after it is unstable. Everything before the second-to-last parent is stable.
+        return parent_indices[-2]
+
+    def _adjust_token_line_numbers(
+            self,
+            tokens: list['md.token.Token'],
+            line_offset: int,
+    ) -> list['md.token.Token']:
+        adjusted = []
+        for token in tokens:
+            if token.map:
+                token = dc.replace(
+                    token,
+                    map=[token.map[0] + line_offset, token.map[1] + line_offset],
+                )
+
+            adjusted.append(token)
+
+        return adjusted

omdev/markdown/tokens.py

@@ -0,0 +1,51 @@
+# ruff: noqa: TC002
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md
+    import markdown_it.token  # noqa
+
+
+##
+
+
+def token_repr(t: 'md.token.Token') -> str:
+    return ''.join([
+        'Token(',
+        f'type={t.type!r}',
+        *([f', tag={t.tag!r}'] if t.tag else []),
+        *([f', nesting={t.nesting!r}'] if t.nesting else []),
+        *([f', attrs={t.attrs!r}'] if t.attrs else []),
+        *([f', map={t.map!r}'] if t.map else []),
+        *([f', level={t.level!r}'] if t.level else []),
+        *([f', children={t.children!r}'] if t.children else []),
+        *([f', content={t.content!r}'] if t.content else []),
+        *([f', markup={t.markup!r}'] if t.markup else []),
+        *([f', info={t.info!r}'] if t.info else []),
+        *([f', meta={t.meta!r}'] if t.meta else []),
+        *([f', block={t.block!r}'] if t.block else []),
+        *([f', hidden={t.hidden!r}'] if t.hidden else []),
+        ')',
+    ])
+
+
+##
+
+
+def flatten_tokens(
+        tokens: ta.Iterable['md.token.Token'],
+        *,
+        filter: ta.Callable[['md.token.Token'], bool] | None = None,  # noqa
+) -> ta.Iterable['md.token.Token']:
+    def rec(tks: ta.Iterable['md.token.Token']) -> ta.Iterator['md.token.Token']:
+        for tk in tks:
+            if tk.children and not (filter is not None and not filter(tk)):
+                yield from rec(tk.children)
+
+            else:
+                yield tk
+
+    return rec(tokens)

omdev/tui/apps/markdown/cli.py

@@ -1,8 +1,7 @@
 import argparse
 import sys
 
-import rich.console
-import rich.markdown
+from ... import rich
 
 
 ##
@@ -19,8 +18,8 @@ def _main() -> None:
     else:
         src = sys.stdin.read()
 
-    console = rich.console.Console()
-    markdown = rich.markdown.Markdown(src)
+    console = rich.Console()
+    markdown = rich.Markdown(src)
     console.print(markdown)
     print()
 

omdev/tui/rich/__init__.py

@@ -0,0 +1,33 @@
+# ruff: noqa: F401
+# flake8: noqa: F401
+from omlish import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from rich import console  # noqa
+    from rich import live  # noqa
+    from rich import markdown  # noqa
+    from rich import text  # noqa
+    from rich.console import Console  # noqa
+    from rich.live import Live  # noqa
+    from rich.markdown import Markdown  # noqa
+    from rich.text import Text  # noqa
+
+    ##
+
+    from .console2 import (  # noqa
+        console_render,
+    )
+
+    from .markdown2 import (  # noqa
+        configure_markdown_parser,
+        markdown_from_tokens,
+        flatten_tokens_filter,
+        flatten_tokens,
+
+        MarkdownLiveStream,
+        NaiveMarkdownLiveStream,
+        IncrementalMarkdownLiveStream,
+    )

omdev/tui/rich/console2.py

@@ -0,0 +1,20 @@
+import io
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import rich.console
+
+
+##
+
+
+def console_render(obj: ta.Any, **kwargs: ta.Any) -> str:
+    temp_console = rich.console.Console(
+        file=(out := io.StringIO()),
+        **kwargs,
+    )
+    temp_console.print(obj)
+    return out.getvalue()

omdev/tui/rich/markdown2.py

@@ -0,0 +1,186 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ...markdown.incparse import IncrementalMarkdownParser
+from ...markdown.tokens import flatten_tokens as _flatten_tokens
+from .console2 import console_render
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md  # noqa
+    import markdown_it.token  # noqa
+    import rich.console
+    import rich.live
+    import rich.markdown
+    import rich.text
+
+
+##
+
+
+def configure_markdown_parser(parser: ta.Optional['md.MarkdownIt'] = None) -> 'md.MarkdownIt':
+    if parser is None:
+        parser = md.MarkdownIt()
+
+    return (
+        parser
+        .enable('strikethrough')
+        .enable('table')
+    )
+
+
+def markdown_from_tokens(tokens: ta.Sequence['md.token.Token']) -> 'rich.markdown.Markdown':
+    rmd = rich.markdown.Markdown('')
+    rmd.parsed = tokens  # type: ignore[assignment]
+    return rmd
+
+
+def flatten_tokens_filter(token: 'md.token.Token') -> bool:
+    return (
+        token.type != 'fence' and
+        token.tag != 'img'
+    )
+
+
+def flatten_tokens(tokens: ta.Iterable['md.token.Token']) -> ta.Iterable['md.token.Token']:
+    return _flatten_tokens(tokens, filter=flatten_tokens_filter)
+
+
+##
+
+
+class MarkdownLiveStream(lang.ExitStacked, lang.Abstract):
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+            console: ta.Optional['rich.console.Console'] = None,
+    ) -> None:
+        super().__init__()
+
+        if console is None:
+            console = rich.console.Console()
+        self._console = console
+
+        if parser is None:
+            parser = configure_markdown_parser()
+        self._parser = parser
+
+        self._lines_printed_to_scrollback = 0
+
+    _live: 'rich.live.Live'  # noqa
+
+    def _enter_contexts(self) -> None:
+        super()._enter_contexts()
+
+        self._live = self._enter_context(rich.live.Live(
+            rich.text.Text(''),
+            console=self._console,
+            refresh_per_second=10,
+        ))
+
+    def _console_render(self, obj: ta.Any) -> list[str]:
+        return console_render(
+            obj,
+            force_terminal=True,
+            width=self._console.width,
+        ).splitlines()
+
+    def _console_render_markdown(self, src: str) -> list[str]:
+        return self._console_render(markdown_from_tokens(self._parser.parse(src)))
+
+    @abc.abstractmethod
+    def feed(self, s: str) -> None:
+        raise NotImplementedError
+
+
+class NaiveMarkdownLiveStream(MarkdownLiveStream):
+    _accumulated = ''
+
+    def feed(self, s: str) -> None:
+        self._accumulated += s
+        all_lines = self._console_render_markdown(self._accumulated)
+
+        # Calculate how many lines fit in the live window
+        available_height = self._console.height - 2
+
+        # Determine which lines overflow and need to be printed to scrollback
+        total_lines = len(all_lines)
+        if total_lines > available_height:
+            # Lines that should be in scrollback
+            lines_for_scrollback = total_lines - available_height
+
+            # Print any new lines that weren't already printed
+            if lines_for_scrollback > self._lines_printed_to_scrollback:
+                new_lines_to_print = all_lines[self._lines_printed_to_scrollback:lines_for_scrollback]
+                for line in new_lines_to_print:
+                    self._live.console.print(rich.text.Text.from_ansi(line))
+                self._lines_printed_to_scrollback = lines_for_scrollback
+
+            # Show only the bottom portion in the live window
+            visible_lines = all_lines[-available_height:]
+
+        else:
+            visible_lines = all_lines
+
+        # Update the live display
+        self._live.update(rich.text.Text.from_ansi('\n'.join(visible_lines)))
+
+
+class IncrementalMarkdownLiveStream(MarkdownLiveStream):
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+            console: ta.Optional['rich.console.Console'] = None,
+    ) -> None:
+        super().__init__(
+            parser=parser,
+            console=console,
+        )
+
+        self._inc_parser = IncrementalMarkdownParser(parser=self._parser)
+
+    def feed(self, s: str) -> None:
+        ip_out = self._inc_parser.feed2(s)
+
+        if ip_out.new_stable:
+            # try:
+            #     srs = getattr(self, '_srs')
+            # except AttributeError:
+            #     setattr(self, '_srs', srs := [])
+            # from ...markdown.tokens import token_repr, flatten_tokens
+            # srs.extend(map(token_repr, flatten_tokens(ip_out.new_stable)))
+
+            stable_lines = self._console_render(markdown_from_tokens(ip_out.new_stable))
+            stable_lines.append(' ')  # FIXME: lame hack
+            self._live.console.print(rich.text.Text.from_ansi('\n'.join(stable_lines), no_wrap=True))
+            self._lines_printed_to_scrollback = max(0, self._lines_printed_to_scrollback - len(stable_lines))
+
+        unstable_lines = self._console_render(markdown_from_tokens(ip_out.unstable))
+
+        # Calculate how many lines fit in the live window
+        available_height = self._console.height - 2
+
+        # Determine which lines overflow and need to be printed to scrollback
+        total_lines = len(unstable_lines)
+        if total_lines > available_height:
+            # Lines that should be in scrollback
+            lines_for_scrollback = total_lines - available_height
+
+            # Print any new lines that weren't already printed
+            if lines_for_scrollback > self._lines_printed_to_scrollback:
+                new_lines_to_print = unstable_lines[self._lines_printed_to_scrollback:lines_for_scrollback]
+                self._live.console.print(rich.text.Text.from_ansi('\n'.join(new_lines_to_print)))
+                self._lines_printed_to_scrollback = lines_for_scrollback
+
+            # Show only the bottom portion in the live window
+            visible_lines = unstable_lines[-available_height:]
+
+        else:
+            visible_lines = unstable_lines
+
+        # Update the live display
+        self._live.update(rich.text.Text.from_ansi('\n'.join(visible_lines)))

omdev/tui/textual/__init__.py

@@ -0,0 +1,156 @@
+# ruff: noqa: F401
+# flake8: noqa: F401
+from omlish import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from textual import app  # noqa
+    from textual import binding  # noqa
+    from textual import containers  # noqa
+    from textual import events  # noqa
+    from textual import events  # noqa
+    from textual import message  # noqa
+    from textual import reactive  # noqa
+    from textual import widgets  # noqa
+    from textual.app import ActionError  # noqa
+    from textual.app import ActiveModeError  # noqa
+    from textual.app import App  # noqa
+    from textual.app import AppError  # noqa
+    from textual.app import AutopilotCallbackType  # noqa
+    from textual.app import CallThreadReturnType  # noqa
+    from textual.app import CommandCallback  # noqa
+    from textual.app import ComposeResult  # noqa
+    from textual.app import InvalidModeError  # noqa
+    from textual.app import InvalidThemeError  # noqa
+    from textual.app import ModeError  # noqa
+    from textual.app import RenderResult  # noqa
+    from textual.app import ReturnType  # noqa
+    from textual.app import ScreenError  # noqa
+    from textual.app import ScreenStackError  # noqa
+    from textual.app import ScreenType  # noqa
+    from textual.app import SuspendNotSupported  # noqa
+    from textual.app import SystemCommand  # noqa
+    from textual.app import UnknownModeError  # noqa
+    from textual.app import get_system_commands_provider  # noqa
+    from textual.binding import ActiveBinding  # noqa
+    from textual.binding import Binding  # noqa
+    from textual.binding import BindingError  # noqa
+    from textual.binding import BindingIDString  # noqa
+    from textual.binding import BindingType  # noqa
+    from textual.binding import BindingsMap  # noqa
+    from textual.binding import InvalidBinding  # noqa
+    from textual.binding import KeyString  # noqa
+    from textual.binding import Keymap  # noqa
+    from textual.binding import KeymapApplyResult  # noqa
+    from textual.binding import NoBinding  # noqa
+    from textual.containers import Center  # noqa
+    from textual.containers import CenterMiddle  # noqa
+    from textual.containers import Container  # noqa
+    from textual.containers import Grid  # noqa
+    from textual.containers import Horizontal  # noqa
+    from textual.containers import HorizontalGroup  # noqa
+    from textual.containers import HorizontalScroll  # noqa
+    from textual.containers import ItemGrid  # noqa
+    from textual.containers import Middle  # noqa
+    from textual.containers import Right  # noqa
+    from textual.containers import ScrollableContainer  # noqa
+    from textual.containers import Vertical  # noqa
+    from textual.containers import VerticalGroup  # noqa
+    from textual.containers import VerticalScroll  # noqa
+    from textual.driver import Driver  # noqa
+    from textual.events import Action  # noqa
+    from textual.events import AppBlur  # noqa
+    from textual.events import AppFocus  # noqa
+    from textual.events import Blur  # noqa
+    from textual.events import Callback  # noqa
+    from textual.events import Click  # noqa
+    from textual.events import Compose  # noqa
+    from textual.events import CursorPosition  # noqa
+    from textual.events import DeliveryComplete  # noqa
+    from textual.events import DeliveryFailed  # noqa
+    from textual.events import DescendantBlur  # noqa
+    from textual.events import DescendantFocus  # noqa
+    from textual.events import Enter  # noqa
+    from textual.events import Event  # noqa
+    from textual.events import Focus  # noqa
+    from textual.events import Hide  # noqa
+    from textual.events import Idle  # noqa
+    from textual.events import InputEvent  # noqa
+    from textual.events import Key  # noqa
+    from textual.events import Leave  # noqa
+    from textual.events import Load  # noqa
+    from textual.events import Mount  # noqa
+    from textual.events import MouseCapture  # noqa
+    from textual.events import MouseDown  # noqa
+    from textual.events import MouseEvent  # noqa
+    from textual.events import MouseMove  # noqa
+    from textual.events import MouseRelease  # noqa
+    from textual.events import MouseScrollDown  # noqa
+    from textual.events import MouseScrollLeft  # noqa
+    from textual.events import MouseScrollRight  # noqa
+    from textual.events import MouseScrollUp  # noqa
+    from textual.events import MouseUp  # noqa
+    from textual.events import Paste  # noqa
+    from textual.events import Print  # noqa
+    from textual.events import Ready  # noqa
+    from textual.events import Resize  # noqa
+    from textual.events import ScreenResume  # noqa
+    from textual.events import ScreenSuspend  # noqa
+    from textual.events import Show  # noqa
+    from textual.events import Timer  # noqa
+    from textual.events import Unmount  # noqa
+    from textual.message import Message  # noqa
+    from textual.reactive import Reactive  # noqa
+    from textual.widget import Widget  # noqa
+    from textual.widgets import Button  # noqa
+    from textual.widgets import Checkbox  # noqa
+    from textual.widgets import Collapsible  # noqa
+    from textual.widgets import CollapsibleTitle  # noqa
+    from textual.widgets import ContentSwitcher  # noqa
+    from textual.widgets import DataTable  # noqa
+    from textual.widgets import Digits  # noqa
+    from textual.widgets import DirectoryTree  # noqa
+    from textual.widgets import Footer  # noqa
+    from textual.widgets import Header  # noqa
+    from textual.widgets import HelpPanel  # noqa
+    from textual.widgets import Input  # noqa
+    from textual.widgets import KeyPanel  # noqa
+    from textual.widgets import Label  # noqa
+    from textual.widgets import Link  # noqa
+    from textual.widgets import ListItem  # noqa
+    from textual.widgets import ListView  # noqa
+    from textual.widgets import LoadingIndicator  # noqa
+    from textual.widgets import Log  # noqa
+    from textual.widgets import Markdown  # noqa
+    from textual.widgets import MarkdownViewer  # noqa
+    from textual.widgets import MaskedInput  # noqa
+    from textual.widgets import OptionList  # noqa
+    from textual.widgets import Placeholder  # noqa
+    from textual.widgets import Pretty  # noqa
+    from textual.widgets import ProgressBar  # noqa
+    from textual.widgets import RadioButton  # noqa
+    from textual.widgets import RadioSet  # noqa
+    from textual.widgets import RichLog  # noqa
+    from textual.widgets import Rule  # noqa
+    from textual.widgets import Select  # noqa
+    from textual.widgets import SelectionList  # noqa
+    from textual.widgets import Sparkline  # noqa
+    from textual.widgets import Static  # noqa
+    from textual.widgets import Switch  # noqa
+    from textual.widgets import Tab  # noqa
+    from textual.widgets import TabPane  # noqa
+    from textual.widgets import TabbedContent  # noqa
+    from textual.widgets import Tabs  # noqa
+    from textual.widgets import TextArea  # noqa
+    from textual.widgets import Tooltip  # noqa
+    from textual.widgets import Tree  # noqa
+    from textual.widgets import Welcome  # noqa
+
+    ##
+
+    from .drivers2 import (  # noqa
+        PendingWritesDriverMixin,
+        get_pending_writes_driver_class,
+    )

omdev/tui/textual/drivers2.py

@@ -0,0 +1,55 @@
+import threading
+import typing as ta
+
+from omlish import lang
+
+
+if ta.TYPE_CHECKING:
+    from textual.driver import Driver
+
+
+##
+
+
+class PendingWritesDriverMixin:
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._pending_primary_buffer_writes: list[str] = []
+
+    def queue_primary_buffer_write(self, *s: str) -> None:
+        self._pending_primary_buffer_writes.extend(s)
+
+    def write(self, data: str) -> None:
+        if (pw := self._pending_primary_buffer_writes):
+            data = ''.join([*pw, data])
+            pw.clear()
+        super().write(data)  # type: ignore
+
+
+_PENDING_WRITES_DRIVER_CLASSES_LOCK = threading.RLock()
+_PENDING_WRITES_DRIVER_CLASSES: dict[type['Driver'], type['Driver']] = {}
+
+
+def get_pending_writes_driver_class(cls: type['Driver']) -> type['Driver']:
+    if issubclass(cls, PendingWritesDriverMixin):
+        return cls  # noqa
+
+    try:
+        return _PENDING_WRITES_DRIVER_CLASSES[cls]
+    except KeyError:
+        pass
+
+    with _PENDING_WRITES_DRIVER_CLASSES_LOCK:
+        try:
+            return _PENDING_WRITES_DRIVER_CLASSES[cls]
+        except KeyError:
+            pass
+
+        cls = _PENDING_WRITES_DRIVER_CLASSES[cls] = lang.new_type(  # noqa
+            f'PendingWrites{cls.__name__}',
+            (PendingWritesDriverMixin, cls),
+            {},
+        )
+
+    return cls  # noqa

{omdev-0.0.0.dev460.dist-info → omdev-0.0.0.dev462.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev460
+Version: 0.0.0.dev462
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev460
+Requires-Dist: omlish==0.0.0.dev462
 Provides-Extra: all
 Requires-Dist: black~=25.9; extra == "all"
 Requires-Dist: pycparser~=2.23; extra == "all"