omdev 0.0.0.dev416__py3-none-any.whl → 0.0.0.dev500__py3-none-any.whl

omdev/tools/pawk/README.md

@@ -0,0 +1,195 @@
+[From alecthomas/pawk](https://github.com/alecthomas/pawk/blob/d60f78399e8a01857ebd73415a00e7eb424043ab/pawk.py)
+
+---
+
+PAWK - A Python line processor (like AWK)
+
+PAWK aims to bring the full power of Python to AWK-like line-processing.
+
+Here are some quick examples to show some of the advantages of pawk over AWK.
+
+The first example transforms `/etc/hosts` into a JSON map of host to IP:
+
+    cat /etc/hosts | pawk -B 'd={}' -E 'json.dumps(d)' '!/^#/ d[f[1]] = f[0]'
+
+Breaking this down:
+
+1. `-B 'd={}'` is a begin statement initializing a dictionary, executed once before processing begins.
+2. `-E 'json.dumps(d)'` is an end statement expression, producing the JSON representation of the dictionary `d`.
+3. `!/^#/` tells pawk to match any line *not* beginning with `#`.
+4. `d[f[1]] = f[0]` adds a dictionary entry where the key is the second field in the line (the first hostname) and the
+    value is the first field (the IP address).
+
+And another example showing how to bzip2-compress + base64-encode a file:
+
+    cat pawk.py | pawk -E 'base64.encodestring(bz2.compress(t))'
+
+### AWK example translations
+
+Most basic AWK constructs are available. You can find more idiomatic examples below in the example section, but here are
+a bunch of awk commands and their equivalent pawk commands to get started with:
+
+Print lines matching a pattern:
+
+    ls -l / | awk '/etc/'
+    ls -l / | pawk '/etc/'
+
+Print lines *not* matching a pattern:
+
+    ls -l / | awk '!/etc/'
+    ls -l / | pawk '!/etc/'
+
+Field slicing and dicing (here pawk wins because of Python's array slicing):
+
+    ls -l / | awk '/etc/ {print $5, $6, $7, $8, $9}'
+    ls -l / | pawk '/etc/ f[4:]'
+
+Begin and end actions (in this case, summing the sizes of all files):
+
+    ls -l | awk 'BEGIN {c = 0} {c += $5} END {print c}'
+    ls -l | pawk -B 'c = 0' -E 'c' 'c += int(f[4])'
+
+Print files where a field matches a numeric expression (in this case where files are > 1024 bytes):
+
+    ls -l | awk '$5 > 1024'
+    ls -l | pawk 'int(f[4]) > 1024'
+
+Matching a single field (any filename with "t" in it):
+
+    ls -l | awk '$NF ~/t/'
+    ls -l | pawk '"t" in f[-1]'
+
+## Expression evaluation
+
+PAWK evaluates a Python expression or statement against each line in stdin. The following variables are available in
+local context:
+
+- `line` - Current line text, including newline.
+- `l` - Current line text, excluding newline.
+- `n` - The current 1-based line number.
+- `f` - Fields of the line (split by the field separator `-F`).
+- `nf` - Number of fields in this line.
+- `m` - Tuple of match regular expression capture groups, if any.
+
+
+In the context of the `-E` block:
+
+- `t` - The entire input text up to the current cursor position.
+
+If the flag `-H, --header` is provided, each field in the first row of the input will be treated as field variable names
+in subsequent rows. The header is not output. For example, given the input:
+
+```
+count name
+12 bob
+34 fred
+```
+
+We could do:
+
+```
+$ pawk -H '"%s is %s" % (name, count)' < input.txt
+bob is 12
+fred is 34
+```
+
+To output a header as well, use `-B`:
+
+```
+$ pawk -H -B '"name is count"' '"%s is %s" % (name, count)' < input.txt
+name is count
+bob is 12
+fred is 34
+```
+
+Module references will be automatically imported if possible. Additionally, the `--import <module>[,<module>,...]` flag
+can be used to import symbols from a set of modules into the evaluation context.
+
+eg. `--import os.path` will import all symbols from `os.path`, such as `os.path.isfile()`, into the context.
+
+## Output
+
+### Line actions
+
+The type of the evaluated expression determines how output is displayed:
+
+- `tuple` or `list`: the elements are converted to strings and joined with the output delimiter (`-O`).
+- `None` or `False`: nothing is output for that line.
+- `True`: the original line is output.
+- Any other value is converted to a string.
+
+### Start/end blocks
+
+The rules are the same as for line actions with one difference.  Because there is no "line" that corresponds to them, an
+expression returning True is ignored.
+
+    $ echo -ne 'foo\nbar' | pawk -E t
+    foo
+    bar
+
+
+## Command-line usage
+
+```
+Usage: cat input | pawk [<options>] <expr>
+
+A Python line-processor (like awk).
+
+See https://github.com/alecthomas/pawk for details. Based on
+http://code.activestate.com/recipes/437932/.
+
+Options:
+  -h, --help            show this help message and exit
+  -I <filename>, --in_place=<filename>
+                        modify given input file in-place
+  -i <modules>, --import=<modules>
+                        comma-separated list of modules to "from x import *"
+                        from
+  -F <delim>            input delimiter
+  -O <delim>            output delimiter
+  -L <delim>            output line separator
+  -B <statement>, --begin=<statement>
+                        begin statement
+  -E <statement>, --end=<statement>
+                        end statement
+  -s, --statement       DEPRECATED. retained for backward compatibility
+  -H, --header          use first row as field variable names in subsequent
+                        rows
+  --strict              abort on exceptions
+```
+
+## Examples
+
+### Line processing
+
+Print the name and size of every file from stdin:
+
+    find . -type f | pawk 'f[0], os.stat(f[0]).st_size'
+
+> **Note:** this example also shows how pawk automatically imports referenced modules, in this case `os`.
+
+Print the sum size of all files from stdin:
+
+    find . -type f | \
+        pawk \
+            --begin 'c=0' \
+            --end c \
+            'c += os.stat(f[0]).st_size'
+
+Short-flag version:
+
+    find . -type f | pawk -B c=0 -E c 'c += os.stat(f[0]).st_size'
+
+
+### Whole-file processing
+
+If you do not provide a line expression, but do provide an end statement, pawk will accumulate each line, and the entire
+file's text will be available in the end statement as `t`. This is useful for operations on entire files, like the
+following example of converting a file from markdown to HTML:
+
+    cat README.md | \
+        pawk --end 'markdown.markdown(t)'
+
+Short-flag version:
+
+    cat README.md | pawk -E 'markdown.markdown(t)'

omdev/tools/pawk/pawk.py

@@ -384,9 +384,9 @@ def main() -> None:
         # Workaround for close failed in file object destructor: sys.excepthook is missing lost sys.stderr
         # http://stackoverflow.com/questions/7955138/addressing-sys-excepthook-error-in-bash-script
         sys.stderr.write(str(e) + '\n')
-        sys.exit(1)
+        raise SystemExit(1) from None
     except KeyboardInterrupt:
-        sys.exit(1)
+        raise SystemExit(1) from None
 
 
 # @omlish-manifest

omdev/tools/pip.py

@@ -22,6 +22,11 @@ from ..pip import lookup_latest_package_version
 ##
 
 
+DEV_DEP_NAMES: ta.AbstractSet[str] = frozenset([
+    'pydevd-pycharm',
+])
+
+
 class Cli(ap.Cli):
     @ap.cmd(
         ap.arg('package'),
@@ -49,6 +54,9 @@ class Cli(ap.Cli):
         for l in src.splitlines(keepends=True):
             if l.startswith('-e'):
                 continue
+            pr = parse_requirement(l)
+            if pr.name in DEV_DEP_NAMES:
+                continue
             out.append(l)
 
         new_src = ''.join(out)

omdev/tui/apps/edit/main.py

@@ -0,0 +1,167 @@
+import argparse
+import pathlib
+import typing as ta
+
+from ... import textual as tx
+
+
+##
+
+
+class QuitConfirmScreen(tx.ModalScreen[bool]):
+    """Screen with a dialog to confirm quit without saving."""
+
+    CSS = """
+        QuitConfirmScreen {
+            align: center middle;
+        }
+
+        #dialog {
+            width: 60;
+            height: 11;
+
+            border: thick $background 80%;
+
+            padding: 1 2;
+
+            background: $surface;
+        }
+
+        #question {
+            height: 3;
+
+            content-align: center middle;
+        }
+
+        Button {
+            width: 1fr;
+        }
+    """
+
+    def compose(self) -> tx.ComposeResult:
+        yield tx.Vertical(
+            tx.Label('You have unsaved changes. Do you want to save before quitting?', id='question'),
+            tx.Button('Save and Quit', variant='success', id='save'),
+            tx.Button('Quit Without Saving', variant='warning', id='quit'),
+            tx.Button('Cancel', variant='primary', id='cancel'),
+            id='dialog',
+        )
+
+    def on_button_pressed(self, event: tx.Button.Pressed) -> None:
+        if event.button.id == 'save':
+            self.dismiss(True)
+        elif event.button.id == 'quit':
+            self.dismiss(False)
+        else:
+            self.dismiss(None)
+
+
+class TextEditor(tx.App):
+    """A simple text editor using Textual."""
+
+    CSS = """
+        TextArea {
+            height: 1fr;
+        }
+
+        Container {
+            height: 100%;
+        }
+    """
+
+    BINDINGS: ta.ClassVar[ta.Sequence[tx.Binding]] = [
+        tx.Binding('ctrl+s', 'save', 'Save', show=True),
+        tx.Binding('ctrl+q', 'quit', 'Quit', show=True),
+    ]
+
+    def __init__(self, filepath: pathlib.Path):
+        super().__init__()
+
+        self.filepath = filepath
+        self.text_area: tx.TextArea | None = None
+        self.modified = False
+        self.original_content = ''
+
+    def compose(self) -> tx.ComposeResult:
+        """Create child widgets for the app."""
+
+        yield tx.Header()
+        yield tx.Container(tx.TextArea(id='editor'))
+        yield tx.Footer()
+
+    def on_mount(self) -> None:
+        """Load the file content when the app starts."""
+
+        self.text_area = self.query_one('#editor', tx.TextArea)
+
+        # Load existing file or create new
+        if self.filepath.exists():
+            content = self.filepath.read_text()
+            self.text_area.load_text(content)
+            self.original_content = content
+        else:
+            self.original_content = ''
+
+        self.title = f'Text Editor - {self.filepath.name}'
+        self.sub_title = str(self.filepath)
+
+    def on_text_area_changed(self, event: tx.TextArea.Changed) -> None:
+        """Track if the document has been modified."""
+
+        if self.text_area:
+            current_content = self.text_area.text
+            self.modified = current_content != self.original_content
+
+            # Update title to show modified status
+            status = ' *' if self.modified else ''
+            self.title = f'Text Editor - {self.filepath.name}{status}'
+
+    def action_save(self) -> None:
+        """Save the current content to file."""
+
+        if self.text_area:
+            content = self.text_area.text
+            self.filepath.write_text(content)
+            self.original_content = content
+            self.modified = False
+            self.title = f'Text Editor - {self.filepath.name}'
+            self.notify(f'Saved to {self.filepath.name}')
+
+    async def action_quit(self) -> None:
+        """Quit the editor, prompting to save if modified."""
+
+        if self.modified:
+            def check_quit(should_save: bool | None) -> None:
+                if should_save is None:
+                    # User cancelled
+                    return
+
+                if should_save:
+                    self.action_save()
+
+                self.exit()
+
+            await self.push_screen(QuitConfirmScreen(), callback=check_quit)
+
+        else:
+            self.exit()
+
+
+def main() -> None:
+    """Parse arguments and run the editor."""
+
+    parser = argparse.ArgumentParser(description='Simple text editor')
+    parser.add_argument('filename', help='File to edit')
+    args = parser.parse_args()
+
+    filepath = pathlib.Path(args.filename).resolve()
+
+    # Create parent directories if needed
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    app = TextEditor(filepath)
+    app.run()
+
+
+if __name__ == '__main__':
+    main()

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,286 @@
+"""
+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 as tx
+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(tx.App):
+    """IRC client application."""
+
+    _commands: ta.ClassVar[ta.Mapping[str, IrcCommand]] = ALL_COMMANDS
+
+    CSS = """
+        #messages {
+            height: 1fr;
+
+            border: none;
+
+            padding: 0;
+
+            overflow-y: auto;
+        }
+
+        #status {
+            height: 1;
+
+            border: none;
+
+            padding: 0;
+
+            color: $text;
+            background: $primary;
+        }
+
+        #input {
+            border: none;
+
+            padding: 0;
+
+            dock: bottom;
+        }
+    """
+
+    BINDINGS: ta.ClassVar[ta.Sequence[tx.Binding]] = [
+        tx.Binding('ctrl+n', 'next_window', 'Next Window', show=False),
+        tx.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) -> tx.ComposeResult:
+        text_area = tx.TextArea(id='messages', read_only=True, show_line_numbers=False)
+        text_area.cursor_blink = False
+        yield text_area
+        yield tx.Static('', id='status')
+        yield tx.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: tx.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', tx.Input)
+                input_widget.focus()
+                # Post the key event to the input widget so it handles it naturally
+                input_widget.post_message(tx.Key(event.key, event.character))
+                # Stop the event from being processed by the messages widget
+                event.stop()
+
+    async def on_input_submitted(self, event: tx.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', tx.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', tx.Static).update(status_text)
+
+    async def on_unmount(self) -> None:
+        if (cl := self._client) is not None:
+            await cl.shutdown()