omdev 0.0.0.dev462__tar.gz → 0.0.0.dev464__tar.gz

{omdev-0.0.0.dev462/omdev.egg-info → omdev-0.0.0.dev464}/PKG-INFO

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

{omdev-0.0.0.dev462 → omdev-0.0.0.dev464}/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-0.0.0.dev464/omdev/tui/apps/irc/__main__.py

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

omdev-0.0.0.dev464/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-0.0.0.dev464/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-0.0.0.dev464/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-0.0.0.dev464/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()