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

omdev/tools/git/cli.py

@@ -21,6 +21,7 @@ TODO:
   fatal: Need to specify how to reconcile divergent branches.
 """
 import dataclasses as dc
+import glob
 import os
 import shutil
 import tempfile
@@ -452,6 +453,7 @@ class Cli(ap.Cli):
     BUILTIN_COMMIT_MESSAGES: ta.Mapping[str, str] = {
         'tableflip': '(╯°□°)╯︵ ┻━┻',
         'tableunflip': '┬─┬ノ(º _ ºノ)',
+        'shrug': r'¯\_(ツ)_/¯',
     }
 
     @ap.cmd(
@@ -501,10 +503,18 @@ class Cli(ap.Cli):
                 repo_dir = os.path.join(tmp_dir, repo_dir_name)
                 check.state(os.path.isdir(repo_dir))
 
+                #
+
                 git_dir = os.path.join(repo_dir, '.git')
                 check.state(os.path.isdir(git_dir))
                 shutil.rmtree(git_dir)
 
+                for f in glob.glob(os.path.join(repo_dir, '**/.gitattributes'), recursive=True):
+                    if os.path.isfile(f):
+                        os.unlink(f)
+
+                #
+
                 shutil.move(repo_dir, cwd)
 
                 out_dir = repo_dir_name

omdev/tools/json/processing.py

@@ -53,8 +53,11 @@ class Processor:
 
     def _marshal(self, v: ta.Any) -> ta.Any:
         return msh.MarshalContext(
-            config_registry=msh.global_config_registry(),
-            factory=self._marshaler_factory(),
+            configs=msh.global_config_registry(),
+            marshal_factory_context=msh.MarshalFactoryContext(
+                configs=msh.global_config_registry(),
+                marshaler_factory=self._marshaler_factory(),
+            ),
         ).marshal(v)
 
     def process(self, v: ta.Any) -> ta.Iterator[ta.Any]:

omdev/tools/jsonview/cli.py

@@ -14,8 +14,10 @@ import os
 import socketserver
 import sys
 import threading
+import typing as ta
 import webbrowser
 
+from omlish import check
 from omlish import lang
 
 
@@ -69,7 +71,15 @@ HTML_TEMPLATE = """
 """
 
 
-def view_json(filepath: str, port: int) -> None:
+def view_json(
+        filepath: str,
+        port: int,
+        *,
+        mode: ta.Literal['jsonl', 'json5', 'json', None] = None,
+) -> None:
+    if filepath == '-':
+        filepath = '/dev/stdin'
+
     if not os.path.exists(filepath):
         print(f"Error: File not found at '{filepath}'", file=sys.stderr)
         return
@@ -81,13 +91,21 @@ def view_json(filepath: str, port: int) -> None:
         print(f'Error: Invalid JSON file. {e}', file=sys.stderr)
         return
 
-    if filepath.endswith('.jsonl'):
+    if mode is None:
+        if filepath.endswith('.jsonl'):
+            mode = 'json'
+        elif filepath.endswith('.json5'):
+            mode = 'json5'
+
+    if mode == 'jsonl':
         json_content = [json.loads(sl) for l in raw_content.splitlines() if (sl := l.strip())]
-    elif filepath.endswith('.json5'):
+    elif mode == 'json5':
         from omlish.formats import json5
         json_content = json5.loads(raw_content)
-    else:
+    elif mode in ('json', None):
         json_content = json.loads(raw_content)
+    else:
+        raise ValueError(mode)
 
     # Use compact dumps for embedding in JS, it's more efficient
     json_string = json.dumps(json_content)
@@ -142,9 +160,17 @@ def _main() -> None:
         default=(default_port := 8999),
         help=f'The port to run the web server on. Defaults to {default_port}.',
     )
+    parser.add_argument('-l', '--lines', action='store_true')
+    parser.add_argument('-5', '--five', action='store_true')
     args = parser.parse_args()
 
-    view_json(args.filepath, args.port)
+    check.state(not (args.lines and args.five))
+
+    view_json(
+        args.filepath,
+        args.port,
+        mode='jsonl' if args.lines else 'json5' if args.five else None,
+    )
 
 
 if __name__ == '__main__':

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,163 @@
+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%;
+            background: $surface;
+            padding: 1 2;
+        }
+
+        #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,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 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;
+        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[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()