omdev 0.0.0.dev461__py3-none-any.whl → 0.0.0.dev463__py3-none-any.whl

omdev/.omlish-manifests.json

@@ -27,7 +27,7 @@
     "module": ".cexts.cmake",
     "attr": "_CLI_MODULE",
     "file": "omdev/cexts/cmake.py",
-    "line": 332,
+    "line": 335,
     "value": {
       "!.cli.types.CliModule": {
         "name": "cmake",

omdev/cexts/cmake.py

@@ -266,7 +266,10 @@ class CmakeProjectGen:
                         '-g',
                         '-c',
                     ],
-                    ['-std=c++20'],
+                    [
+                        '$<$<COMPILE_LANGUAGE:C>:-std=c11>',
+                        '$<$<COMPILE_LANGUAGE:CXX>:-std=c++20>',
+                    ],
                 ),
             ))
 

omdev/scripts/pyproject.py

@@ -2972,6 +2972,12 @@ def format_num_bytes(num_bytes: int) -> str:
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)

omdev/tui/apps/irc/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .main import _main
+
+    _main()

omdev/tui/apps/irc/app.py

@@ -0,0 +1,278 @@
+"""
+TODO:
+ - use omdev.irc obv
+ - readliney input
+ - command suggest / autocomplete
+ - disable command palette
+ - grow input box for multiline
+ - styled text
+"""
+import shlex
+import typing as ta
+
+from omlish import lang
+
+from ... import textual
+from .client import IrcClient
+from .commands import ALL_COMMANDS
+from .commands import IrcCommand
+
+
+##
+
+
+class IrcWindow:
+    """Represents a chat window."""
+
+    def __init__(self, name: str) -> None:
+        super().__init__()
+
+        self.name: str = name
+        self.lines: list[str] = []
+        self.unread: int = 0
+        self.displayed_line_count: int = 0  # Track how many lines are currently displayed
+
+    def add_line(self, line: str) -> None:
+        self.lines.append(line)
+        self.unread += 1
+
+
+class IrcApp(textual.App):
+    """IRC client application."""
+
+    _commands: ta.ClassVar[ta.Mapping[str, IrcCommand]] = ALL_COMMANDS
+
+    CSS = """
+    #messages {
+        height: 1fr;
+        overflow-y: auto;
+        border: none;
+        padding: 0;
+    }
+
+    #status {
+        height: 1;
+        background: $primary;
+        color: $text;
+        border: none;
+        padding: 0;
+    }
+
+    #input {
+        dock: bottom;
+        border: none;
+        padding: 0;
+    }
+    """
+
+    BINDINGS: ta.ClassVar[ta.Sequence[textual.Binding]] = [
+        textual.Binding('ctrl+n', 'next_window', 'Next Window', show=False),
+        textual.Binding('ctrl+p', 'prev_window', 'Previous Window', show=False),
+    ]
+
+    def __init__(
+            self,
+            *,
+            startup_commands: ta.Sequence[str] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._client: IrcClient | None = None
+        self._windows: dict[str, IrcWindow] = {'system': IrcWindow('system')}
+        self._window_order: list[str] = ['system']
+        self._current_window_idx: int = 0
+        self._current_channel: str | None = None
+        self._startup_commands: ta.Sequence[str] = startup_commands or []
+
+    @property
+    def client(self) -> IrcClient | None:
+        return self._client
+
+    @property
+    def current_channel(self) -> str | None:
+        return self._current_channel
+
+    #
+
+    def compose(self) -> textual.ComposeResult:
+        text_area = textual.TextArea(id='messages', read_only=True, show_line_numbers=False)
+        text_area.cursor_blink = False
+        yield text_area
+        yield textual.Static('', id='status')
+        yield textual.Input(placeholder='Enter command or message', id='input', select_on_focus=False)
+
+    async def on_mount(self) -> None:
+        """Initialize on mount."""
+
+        self._client = IrcClient(self.on_irc_message)
+        self.update_display()
+        self.query_one('#input').focus()
+
+        # Show connection prompt
+        await self.add_message('system', 'IRC Client - Use /connect <server> <port> <nickname>')
+        await self.add_message('system', 'Example: /connect irc.libera.chat 6667 mynick')
+
+        # Execute startup commands
+        for cmd in self._startup_commands:
+            # Add leading slash if not present
+            if not cmd.startswith('/'):
+                cmd = '/' + cmd
+            await self.add_message('system', f'Executing: {cmd}')
+            await self.handle_command(cmd)
+
+    async def on_key(self, event: textual.Key) -> None:
+        """Handle key events - redirect typing to input when messages area is focused."""
+
+        focused = self.focused
+        if focused and focused.id == 'messages':
+            # If a printable character or common input key is pressed, focus the input and forward event
+            if event.is_printable or event.key in ('space', 'backspace', 'delete'):
+                input_widget = self.query_one('#input', textual.Input)
+                input_widget.focus()
+                # Post the key event to the input widget so it handles it naturally
+                input_widget.post_message(textual.Key(event.key, event.character))
+                # Stop the event from being processed by the messages widget
+                event.stop()
+
+    async def on_input_submitted(self, event: textual.Input.Submitted) -> None:
+        """Handle user input."""
+
+        text = event.value.strip()
+        event.input.value = ''
+
+        if not text:
+            return
+
+        # Handle commands
+        if text.startswith('/'):
+            await self.handle_command(text)
+        else:
+            # Send message to current channel
+            if self._current_channel and self._client and self._client.connected:
+                await self._client.privmsg(self._current_channel, text)
+                await self.add_message(self._current_channel, f'<{self._client.nickname}> {text}')
+            else:
+                await self.add_message('system', 'Not in a channel or not connected')
+
+    async def handle_command(self, text: str) -> None:
+        """Handle IRC commands."""
+
+        try:
+            parts = shlex.split(text)
+        except ValueError as e:
+            await self.add_message('system', f'Invalid command syntax: {e}')
+            return
+
+        if not parts:
+            return
+
+        cmd = parts[0].lstrip('/').lower()
+        argv = parts[1:]
+
+        command = self._commands.get(cmd)
+        if command:
+            await command.run(self, argv)
+        else:
+            await self.add_message('system', f'Unknown command: /{cmd}')
+
+    def action_next_window(self) -> None:
+        """Switch to next window."""
+
+        if len(self._window_order) > 1:
+            self._current_window_idx = (self._current_window_idx + 1) % len(self._window_order)
+            self.update_display()
+
+    def action_prev_window(self) -> None:
+        """Switch to previous window."""
+
+        if len(self._window_order) > 1:
+            self._current_window_idx = (self._current_window_idx - 1) % len(self._window_order)
+            self.update_display()
+
+    def get_or_create_window(self, name: str) -> IrcWindow:
+        """Get or create a window."""
+
+        if name not in self._windows:
+            self._windows[name] = IrcWindow(name)
+            self._window_order.append(name)
+        return self._windows[name]
+
+    def switch_to_window(self, name: str) -> None:
+        """Switch to a specific window."""
+
+        if name in self._window_order:
+            self._current_window_idx = self._window_order.index(name)
+            self.update_display()
+
+    async def add_message(self, window_name: str, message: str) -> None:
+        """Add a message to a window."""
+
+        window = self.get_or_create_window(window_name)
+        timestamp = lang.utcnow().strftime('%H:%M')
+        window.add_line(f'[{timestamp}] {message}')
+        self.update_display()
+
+    async def on_irc_message(self, window_name: str, message: str) -> None:
+        """Callback for IRC messages."""
+
+        await self.add_message(window_name, message)
+
+    _last_window: str | None = None
+
+    def update_display(self) -> None:
+        """Update the display."""
+
+        current_window_name = self._window_order[self._current_window_idx]
+        current_window = self._windows[current_window_name]
+
+        # Update current channel for sending messages
+        self._current_channel = current_window_name if current_window_name.startswith('#') else None
+
+        # Mark as read
+        current_window.unread = 0
+
+        # Update messages display
+        messages_widget = self.query_one('#messages', textual.TextArea)
+
+        # Check if we switched windows or need full reload
+        window_changed = self._last_window != current_window_name
+        self._last_window = current_window_name
+
+        lines_to_show = current_window.lines[-100:]  # Last 100 lines
+
+        if window_changed:
+            # Full reload when switching windows
+            messages_widget.load_text('\n'.join(lines_to_show))
+            current_window.displayed_line_count = len(lines_to_show)
+
+        else:
+            # Append only new lines
+            new_line_count = len(lines_to_show) - current_window.displayed_line_count
+            if new_line_count > 0:
+                new_lines = lines_to_show[-new_line_count:]
+                # Get the end position
+                doc = messages_widget.document
+                end_line = doc.line_count - 1
+                end_col = len(doc.get_line(end_line))
+                # Append new lines using insert
+                prefix = '\n' if len(doc.text) > 0 else ''
+                messages_widget.insert(prefix + '\n'.join(new_lines), location=(end_line, end_col))
+                current_window.displayed_line_count = len(lines_to_show)
+
+        # Update status line
+        window_list = []
+        for i, name in enumerate(self._window_order):
+            win = self._windows[name]
+            indicator = f'[{i + 1}:{name}]'
+            if i == self._current_window_idx:
+                indicator = f'[{i + 1}:{name}*]'
+            elif win.unread > 0:
+                indicator = f'[{i + 1}:{name}({win.unread})]'
+            window_list.append(indicator)
+
+        status_text = ' '.join(window_list)
+        self.query_one('#status', textual.Static).update(status_text)
+
+    async def on_unmount(self) -> None:
+        if (cl := self._client) is not None:
+            await cl.shutdown()

omdev/tui/apps/irc/client.py

@@ -0,0 +1,187 @@
+import asyncio
+import ssl
+import typing as ta
+
+from omlish import check
+
+
+##
+
+
+class IrcClient:
+    """Simple asyncio-based IRC client."""
+
+    def __init__(
+            self,
+            callback: ta.Callable[[str, str], ta.Awaitable[None]],
+    ) -> None:
+        super().__init__()
+
+        self.reader: asyncio.StreamReader | None = None
+        self.writer: asyncio.StreamWriter | None = None
+        self.callback: ta.Callable[[str, str], ta.Awaitable[None]] = callback
+        self.nickname: str = ''
+        self.connected: bool = False
+        self.read_task: asyncio.Task | None = None
+
+    async def shutdown(self) -> None:
+        if self.read_task is not None:
+            self.read_task.cancel()
+            await self.read_task
+
+    async def connect(
+            self,
+            server: str,
+            port: int,
+            nickname: str,
+            realname: str = 'Textual IRC',
+            use_ssl: bool | None = None,
+    ) -> bool:
+        """Connect to IRC server."""
+
+        check.none(self.read_task)
+
+        try:
+            # Auto-detect SSL for common SSL ports if not explicitly specified
+            if use_ssl is None:
+                use_ssl = port in (6697, 6698, 7000, 7070, 9999)
+
+            ssl_context = None
+            if use_ssl:
+                ssl_context = ssl.create_default_context()
+
+            self.reader, self.writer = await asyncio.open_connection(
+                server, port, ssl=ssl_context,
+            )
+            self.nickname = nickname
+            self.connected = True
+
+            # Send initial IRC handshake
+            await self.send_raw(f'NICK {nickname}')
+            await self.send_raw(f'USER {nickname} 0 * :{realname}')
+
+            # Start reading messages
+            self.read_task = asyncio.create_task(self._read_loop())
+
+            return True
+
+        except Exception as e:  # noqa  # FIXME
+            await self.callback('system', f'Connection error: {e}')
+            return False
+
+    async def send_raw(self, message: str) -> None:
+        """Send raw IRC message."""
+
+        if self.writer:
+            self.writer.write(f'{message}\r\n'.encode())
+            await self.writer.drain()
+
+    async def join(self, channel: str) -> None:
+        """Join a channel."""
+
+        await self.send_raw(f'JOIN {channel}')
+
+    async def part(self, channel: str, message: str = 'Leaving') -> None:
+        """Leave a channel."""
+
+        await self.send_raw(f'PART {channel} :{message}')
+
+    async def privmsg(self, target: str, message: str) -> None:
+        """Send a message to a channel or user."""
+
+        await self.send_raw(f'PRIVMSG {target} :{message}')
+
+    async def names(self, channel: str) -> None:
+        """Request names list for a channel."""
+
+        await self.send_raw(f'NAMES {channel}')
+
+    async def quit(self, message: str = 'Quit') -> None:
+        """Quit IRC."""
+
+        await self.send_raw(f'QUIT :{message}')
+        if self.writer:
+            self.writer.close()
+            await self.writer.wait_closed()
+        self.connected = False
+
+    async def _read_loop(self) -> None:
+        """Read messages from server."""
+
+        try:
+            while self.connected and self.reader:
+                line = await self.reader.readline()
+                if not line:
+                    break
+
+                message = line.decode('utf-8', errors='ignore').strip()
+                if message:
+                    await self._handle_message(message)
+
+        except Exception as e:  # noqa  # FIXME
+            await self.callback('system', f'Read error: {e}')
+
+        finally:
+            self.connected = False
+            await self.callback('system', 'Disconnected from server')
+
+    async def _handle_message(self, message: str) -> None:
+        """Parse and handle IRC messages."""
+
+        # Handle PING
+        if message.startswith('PING'):
+            pong = message.replace('PING', 'PONG', 1)
+            await self.send_raw(pong)
+            return
+
+        # Parse IRC message
+        prefix = ''
+        if message.startswith(':'):
+            prefix, _, message = message[1:].partition(' ')
+
+        parts = message.split(' ', 2)
+        command = parts[0] if parts else ''
+        params = parts[1:] if len(parts) > 1 else []
+
+        # Extract nickname from prefix
+        nick = prefix.split('!')[0] if '!' in prefix else prefix
+
+        # Handle different message types
+        if command == 'PRIVMSG' and len(params) >= 2:
+            target = params[0]
+            text = params[1]
+            text = text.removeprefix(':')
+
+            window = target if target.startswith('#') else nick
+            await self.callback(window, f'<{nick}> {text}')
+
+        elif command == 'JOIN' and params:
+            channel = params[0].lstrip(':')
+            await self.callback(channel, f'* {nick} has joined {channel}')
+
+        elif command == 'PART' and params:
+            channel = params[0]
+            reason = params[1].lstrip(':') if len(params) > 1 else ''
+            msg = f'* {nick} has left {channel}'
+            if reason:
+                msg += f' ({reason})'
+            await self.callback(channel, msg)
+
+        elif command == 'QUIT':
+            reason = params[0].lstrip(':') if params else ''
+            msg = f'* {nick} has quit'
+            if reason:
+                msg += f' ({reason})'
+            await self.callback('system', msg)
+
+        elif command == 'NICK' and params:
+            new_nick = params[0].lstrip(':')
+            await self.callback('system', f'* {nick} is now known as {new_nick}')
+
+        elif command.isdigit():
+            # Numeric replies
+            reply_text = ' '.join(params).lstrip(':')
+            await self.callback('system', f'[{command}] {reply_text}')
+        else:
+            # Unhandled messages go to system
+            await self.callback('system', message)

omdev/tui/apps/irc/commands.py

@@ -0,0 +1,175 @@
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import lang
+from omlish.argparse import all as argparse
+
+
+if ta.TYPE_CHECKING:
+    from .app import IrcApp
+
+
+##
+
+
+class IrcCommand(abc.ABC):
+    """Abstract base class for IRC commands."""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.__parser: argparse.ArgumentParser = argparse.NoExitArgumentParser(
+            prog=self.name,
+            description=self.description,
+            formatter_class=self._HelpFormatter,
+        )
+        self._configure_parser(self.__parser)
+
+    #
+
+    @property
+    def name(self) -> str:
+        return lang.camel_to_snake(type(self).__name__.removesuffix('IrcCommand'))
+
+    @property
+    def description(self) -> str | None:
+        return None
+
+    class _HelpFormatter(argparse.HelpFormatter):
+        def start_section(self, heading):
+            return super().start_section(heading.title())
+
+        def add_usage(self, usage, actions, groups, prefix=None):
+            if prefix is None:
+                prefix = 'Usage: '
+            return super().add_usage(usage, actions, groups, prefix)
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        pass
+
+    #
+
+    @ta.final
+    async def run(self, app: 'IrcApp', argv: list[str]) -> None:
+        try:
+            args = self.__parser.parse_args(argv)
+        except argparse.ArgumentError:
+            await app.add_message('system', self.__parser.format_help())
+            return
+
+        await self._run_args(app, args)
+
+    @abc.abstractmethod
+    async def _run_args(self, app: 'IrcApp', args: argparse.Namespace) -> None:
+        raise NotImplementedError
+
+
+class ConnectIrcCommand(IrcCommand):
+    """Connect to an IRC server."""
+
+    description: ta.ClassVar[str] = 'Connect to an IRC server'
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('server', help='IRC server hostname')
+        parser.add_argument('port', type=int, help='Port number')
+        parser.add_argument('nickname', help='Your nickname')
+        parser.add_argument(
+            '--ssl',
+            action='store_true',
+            help='Use SSL/TLS (auto-detected for common ports)',
+        )
+
+    async def _run_args(self, app: 'IrcApp', args: argparse.Namespace) -> None:
+        use_ssl = args.ssl or None  # None triggers auto-detection
+        ssl_msg = ' (SSL)' if args.ssl or args.port in (6697, 6698, 7000, 7070, 9999) else ''
+        await app.add_message('system', f'Connecting to {args.server}:{args.port}{ssl_msg} as {args.nickname}...')
+        success = await check.not_none(app.client).connect(
+            args.server,
+            args.port,
+            args.nickname,
+            use_ssl=use_ssl if args.ssl else None,
+        )
+        if success:
+            await app.add_message('system', 'Connected!')
+
+
+class JoinIrcCommand(IrcCommand):
+    """Join a channel."""
+
+    description: ta.ClassVar[str] = 'Join an IRC channel'
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('channel', help='Channel name (# prefix optional)')
+
+    async def _run_args(self, app: 'IrcApp', args: argparse.Namespace) -> None:
+        channel = args.channel
+        if not channel.startswith('#'):
+            channel = '#' + channel
+
+        if app.client and app.client.connected:
+            await app.client.join(channel)
+            app.get_or_create_window(channel)
+            app.switch_to_window(channel)
+        else:
+            await app.add_message('system', 'Not connected to server')
+
+
+class PartIrcCommand(IrcCommand):
+    """Leave a channel."""
+
+    description: ta.ClassVar[str] = 'Leave an IRC channel'
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('reason', nargs='*', help='Part message (optional)')
+
+    async def _run_args(self, app: 'IrcApp', args: argparse.Namespace) -> None:
+        if app.current_channel:
+            reason = ' '.join(args.reason) if args.reason else 'Leaving'
+            if app.client and app.client.connected:
+                await app.client.part(app.current_channel, reason)
+        else:
+            await app.add_message('system', 'Not in a channel')
+
+
+class NamesIrcCommand(IrcCommand):
+    """Request names list for current channel."""
+
+    description: ta.ClassVar[str] = 'Request names list for current channel'
+
+    async def _run_args(self, app: 'IrcApp', args: argparse.Namespace) -> None:
+        if app.current_channel:
+            if app.client and app.client.connected:
+                await app.client.names(app.current_channel)
+            else:
+                await app.add_message('system', 'Not connected to server')
+        else:
+            await app.add_message('system', 'Not in a channel')
+
+
+class QuitIrcCommand(IrcCommand):
+    """Quit IRC."""
+
+    description: ta.ClassVar[str] = 'Quit IRC and exit the application'
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('message', nargs='*', help='Quit message (optional)')
+
+    async def _run_args(self, app: 'IrcApp', args: argparse.Namespace) -> None:
+        reason = ' '.join(args.message) if args.message else 'Quit'
+        if app.client and app.client.connected:
+            await app.client.quit(reason)
+        await app.add_message('system', 'Goodbye!')
+        app.exit()
+
+
+##
+
+
+ALL_COMMANDS: ta.Mapping[str, IrcCommand] = {
+    'connect': ConnectIrcCommand(),
+    'join': JoinIrcCommand(),
+    'part': PartIrcCommand(),
+    'names': NamesIrcCommand(),
+    'quit': QuitIrcCommand(),
+}

omdev/tui/apps/irc/main.py

@@ -0,0 +1,26 @@
+from omlish.argparse import all as argparse
+
+from .app import IrcApp
+
+
+##
+
+
+def _main() -> None:
+    parser = argparse.ArgumentParser(description='Simple IRC client using Textual')
+    parser.add_argument(
+        '-x',
+        action='append',
+        dest='commands',
+        help='Execute slash command on startup (can be specified multiple times)',
+    )
+    args = parser.parse_args()
+
+    app = IrcApp(
+        startup_commands=args.commands,
+    )
+    app.run()
+
+
+if __name__ == '__main__':
+    _main()

omdev/tui/textual/__init__.py

@@ -6,4 +6,205 @@ from omlish import lang as _lang
 with _lang.auto_proxy_init(globals()):
     ##
 
-    pass
+    from textual import app  # noqa
+    from textual import binding  # noqa
+    from textual import containers  # noqa
+    from textual import content  # noqa
+    from textual import driver  # noqa
+    from textual import events  # noqa
+    from textual import markup  # noqa
+    from textual import message  # noqa
+    from textual import messages  # noqa
+    from textual import pad  # noqa
+    from textual import reactive  # noqa
+    from textual import screen  # noqa
+    from textual import style  # noqa
+    from textual import suggester  # noqa
+    from textual import suggestions  # noqa
+    from textual import timer  # noqa
+    from textual import widget  # noqa
+    from textual import widgets  # noqa
+    from textual.app import ActionError  # noqa
+    from textual.app import ActiveModeError  # noqa
+    from textual.app import App as 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.content import Content  # noqa
+    from textual.content import ContentText  # noqa
+    from textual.content import ContentType  # noqa
+    from textual.content import EMPTY_CONTENT  # noqa
+    from textual.content import Span  # 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 as TimerEvent  # noqa
+    from textual.events import Unmount  # noqa
+    from textual.markup import MarkupError  # noqa
+    from textual.markup import MarkupTokenizer  # noqa
+    from textual.markup import StyleTokenizer  # noqa
+    from textual.markup import escape  # noqa
+    from textual.markup import parse_style  # noqa
+    from textual.markup import to_content  # noqa
+    from textual.message import Message  # noqa
+    from textual.messages import CloseMessages  # noqa
+    from textual.messages import ExitApp  # noqa
+    from textual.messages import InBandWindowResize  # noqa
+    from textual.messages import InvokeLater  # noqa
+    from textual.messages import Layout  # noqa
+    from textual.messages import Prompt  # noqa
+    from textual.messages import Prune  # noqa
+    from textual.messages import ScrollToRegion  # noqa
+    from textual.messages import TerminalSupportsSynchronizedOutput  # noqa
+    from textual.messages import Update  # noqa
+    from textual.messages import UpdateScroll  # noqa
+    from textual.pad import HorizontalPad  # noqa
+    from textual.reactive import Initialize  # noqa
+    from textual.reactive import Reactive  # noqa
+    from textual.reactive import ReactiveError  # noqa
+    from textual.reactive import await_watcher  # noqa
+    from textual.reactive import invoke_watcher  # noqa
+    from textual.reactive import reactive as reactive_  # noqa
+    from textual.reactive import var  # noqa
+    from textual.screen import ModalScreen  # noqa
+    from textual.screen import Screen  # noqa
+    from textual.screen import SystemModalScreen  # noqa
+    from textual.style import Style  # noqa
+    from textual.suggester import SuggestFromList  # noqa
+    from textual.suggester import Suggester  # noqa
+    from textual.suggester import SuggestionReady  # noqa
+    from textual.suggestions import get_suggestion  # noqa
+    from textual.suggestions import get_suggestions  # noqa
+    from textual.timer import Timer  # noqa
+    from textual.timer import TimerCallback  # 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 .app2 import (  # noqa
+        App,
+    )
+
+    from .drivers2 import (  # noqa
+        PendingWritesDriverMixin,
+        get_pending_writes_driver_class,
+    )

omdev/tui/textual/app2.py

@@ -0,0 +1,11 @@
+import typing as ta
+
+from textual.app import App as App_
+from textual.binding import BindingType  # noqa
+
+
+##
+
+
+class App(App_):
+    BINDINGS: ta.ClassVar[ta.Sequence[BindingType]] = App_.BINDINGS  # type: ignore[assignment]

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.dev461.dist-info → omdev-0.0.0.dev463.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev461
+Version: 0.0.0.dev463
 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.dev461
+Requires-Dist: omlish==0.0.0.dev463
 Provides-Extra: all
 Requires-Dist: black~=25.9; extra == "all"
 Requires-Dist: pycparser~=2.23; extra == "all"

{omdev-0.0.0.dev461.dist-info → omdev-0.0.0.dev463.dist-info}/RECORD

@@ -1,4 +1,4 @@
-omdev/.omlish-manifests.json,sha256=YqhbZs4Wr3L9DAwcFfhTs8Zw8W8MxPLaxYXp2aqbyzQ,11671
+omdev/.omlish-manifests.json,sha256=cMWrMB14_AFp9mQiTEeoTYL1uaC3zq7ER7-XHGCXY8I,11671
 omdev/__about__.py,sha256=TwPTq6a1_K0K-oDBQf6x2VmkiD5hi6W8Q7CvmTW9Aic,1223
 omdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/cmake.py,sha256=gu49t10_syXh_TUJs4POsxeFs8we8Y3XTOOPgIXmGvg,4608
@@ -52,7 +52,7 @@ omdev/cc/srclangs.py,sha256=3u_APHgknuc-BPRQSDISwSzouluKsnLlBxodp-XCl_E,728
 omdev/cexts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/cexts/_boilerplate.cc,sha256=tUTFKyMpammFj-7bF8DbN6jv67Vn7qrwCFDoAgarof8,1753
 omdev/cexts/build.py,sha256=JxEuqSpspnY6kWn8eB89FjcSjF4bpNgVYNeIvwmWehY,2659
-omdev/cexts/cmake.py,sha256=7CSL9AsWaJnad94dw9QxbZLirtxdlg7Au7EQ1g7H74g,10050
+omdev/cexts/cmake.py,sha256=rwsUVjOMjNR9nBCMgK-oWLl0aD5WWUYzVQEYcZ5BZGs,10185
 omdev/cexts/importhook.py,sha256=GZ04bE6tMQ8uQUUzGr22Rt9cwyI6kkoK4t7xpLP2Lrs,3562
 omdev/cexts/magic.py,sha256=DglhjCXEiL28pFTN4lrmUW6ZLn6HaumR13ptyaFOez4,131
 omdev/cexts/scan.py,sha256=94UqVgxBrAHn_VyW_ZA3-hB_R6pWIJRWqvtSBEg_O4U,1673
@@ -285,7 +285,7 @@ omdev/pyproject/resources/python.sh,sha256=rFaN4SiJ9hdLDXXsDTwugI6zsw6EPkgYMmtac
 omdev/scripts/__init__.py,sha256=MKCvUAEQwsIvwLixwtPlpBqmkMXLCnjjXyAXvVpDwVk,91
 omdev/scripts/ci.py,sha256=dmpJXF0mS37K6psivRDukXEBF8Z6CAuK_PQERDBzFgE,427466
 omdev/scripts/interp.py,sha256=GELa1TPg0tStMbofHpEYetMrAl3YnInehwler2gdE2I,168564
-omdev/scripts/pyproject.py,sha256=wf3hKkkAjQn7qwnY6cHTRJg3_duUi2R8a3foFaNuehQ,349235
+omdev/scripts/pyproject.py,sha256=DNIVc0GALqIW2lM7YUQCmil-60FblcHgAV8Sil06fWM,349535
 omdev/scripts/slowcat.py,sha256=PwdT-pg62imEEb6kcOozl9_YUi-4KopvjvzWT1OmGb0,2717
 omdev/scripts/tmpexec.py,sha256=t0nErDRALjTk7H0X8ADjZUIDFjlPNzOOokmjCjBHdzs,1431
 omdev/scripts/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -335,16 +335,24 @@ omdev/tools/pawk/__main__.py,sha256=VCqeRVnqT1RPEoIrqHFSu4PXVMg4YEgF4qCQm90-eRI,
 omdev/tools/pawk/pawk.py,sha256=ao5mdrpiSU4AZ8mBozoEaV3UVlmVTnRG9wD9XP70MZE,11429
 omdev/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tui/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omdev/tui/apps/irc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omdev/tui/apps/irc/__main__.py,sha256=d23loR_cKfTYZwYiqpt_CmKI7dd5WcYFgIYzqMep75E,68
+omdev/tui/apps/irc/app.py,sha256=v7jw8eKfq84FUrxNeMqbE6DXvhsrbrUgLiqms8JXYNY,9222
+omdev/tui/apps/irc/client.py,sha256=H4oO-TO_2XTMWMMezqCurj46n6ARO25gCEaCCCkQgc8,5869
+omdev/tui/apps/irc/commands.py,sha256=nBzE2A8Q727RYwvv9ULeoCwi0vogK9KPzT36hvsfg48,5642
+omdev/tui/apps/irc/main.py,sha256=ptsSjKE3LDmPERCExivcjTN7SOfYY7WVnIlDXSL_XQA,510
 omdev/tui/apps/markdown/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tui/apps/markdown/__main__.py,sha256=Xy-G2-8Ymx8QMBbRzA4LoiAMZqvtC944mMjFEWd69CA,182
 omdev/tui/apps/markdown/cli.py,sha256=K1vH7f3ZqLv4xTPluhJBEZH8nx8n42_vXIALEV07Q50,469
 omdev/tui/rich/__init__.py,sha256=_PcNDlzl7FIa071qni4AlBAf0oXXFHUjEaPxumnuXWs,775
 omdev/tui/rich/console2.py,sha256=BYYLbbD65If9TvfPI6qUcMQKUWJbuWwykEzPplvkf6A,342
 omdev/tui/rich/markdown2.py,sha256=fBcjG_34XzUf4WclBL_MxvBj5NUwvLCANhHCx3R0akw,6139
-omdev/tui/textual/__init__.py,sha256=SljlE7NeWxHrWG7HyGlrtA0dTuIabXi2KidA8X9Nk5s,131
-omdev-0.0.0.dev461.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omdev-0.0.0.dev461.dist-info/METADATA,sha256=0xextQLtZS5bwFwkQzBFbe1FN2PXm8URpKlDFKlnCMk,5170
-omdev-0.0.0.dev461.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omdev-0.0.0.dev461.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
-omdev-0.0.0.dev461.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
-omdev-0.0.0.dev461.dist-info/RECORD,,
+omdev/tui/textual/__init__.py,sha256=l4lDY7g_spyUpCMYlzmM2jFz92xv4-VzOM88vFlV6zA,9801
+omdev/tui/textual/app2.py,sha256=QNh8dX9lXtvWkUOLX5x6ucJCYqDoKD78VDpaX4ZcGS8,225
+omdev/tui/textual/drivers2.py,sha256=ZVxI9n6cyczjrdjqKOAjE51pF0yppACJOVmqLaWuJuM,1402
+omdev-0.0.0.dev463.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omdev-0.0.0.dev463.dist-info/METADATA,sha256=BZD4CAxJpONI1QQgQF1aYu6dr7WvhH_OXomlZy-_guA,5170
+omdev-0.0.0.dev463.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omdev-0.0.0.dev463.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
+omdev-0.0.0.dev463.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
+omdev-0.0.0.dev463.dist-info/RECORD,,