omdev 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev486__py3-none-any.whl

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/apps/markdown/__main__.py

@@ -0,0 +1,11 @@
+from ....cli import CliModule
+
+
+# @omlish-manifest
+_CLI_MODULE = CliModule(['tui/markdown', 'tui/md'], __name__)
+
+
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()

omdev/{ptk → tui/apps}/markdown/cli.py

@@ -1,9 +1,7 @@
 import argparse
 import sys
 
-from ... import ptk
-from .markdown import Markdown
-from .styles import MARKDOWN_STYLE
+from ... import rich
 
 
 ##
@@ -20,10 +18,10 @@ def _main() -> None:
     else:
         src = sys.stdin.read()
 
-    ptk.print_formatted_text(
-        Markdown(src),
-        style=ptk.Style(list(MARKDOWN_STYLE)),
-    )
+    console = rich.Console()
+    markdown = rich.Markdown(src)
+    console.print(markdown)
+    print()
 
 
 if __name__ == '__main__':

omdev/tui/rich/__init__.py

@@ -0,0 +1,34 @@
+# 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 repr  # 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)))