pyrepl-hacks 0.1.0__tar.gz

pyrepl_hacks-0.1.0/PKG-INFO

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: pyrepl-hacks
+Version: 0.1.0
+Summary: Hacky extensions and helper functions for the new Python REPL.
+Requires-Python: <3.15,>=3.13
+Description-Content-Type: text/markdown
+
+# pyrepl-hacks
+
+Hacky extensions and helper functions for the new Python REPL.
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("Alt+M", "move-to-indentation")   # Move to first non-space in current line
+repl.bind("Shift+Tab", "dedent")            # Dedent the whole input
+repl.bind("Alt+Down", "move-line-down")     # Swap current line with next in block
+repl.bind("Alt+Up", "move-line-up")         # Swap current line with previous in block
+repl.bind("Shift+Home", "home")             # Move to first character in the input
+repl.bind("Shift+End", "end")               # Move to last character in the input
+
+# Make Ctrl+N insert a specific list of numbers
+repl.bind_to_insert("Ctrl+N", "[2, 1, 3, 4, 7, 11, 18, 29]")
+
+
+@repl.bind(r"Ctrl+X Ctrl+R", with_event=True)
+def subprocess_run(reader, event_name, event):
+    """Ctrl+X followed by Ctrl+R will insert a subprocess.run command."""
+    reader.insert("import subprocess\n")
+    code = 'subprocess.run("", shell=True)'
+    reader.insert(code)
+    for _ in range(len(code) - code.index('""') - 1):
+        repl.commands.left(reader, event_name, event)
+```
+
+
+## ⚠️ WARNING: this could all break
+
+This library relies on Python implementation details which may change in future Python versions.
+
+This library uses the `_pyrepl` module (and optionally `_colorize`).
+As the `_` prefix implies, these modules are not designed for public use.
+
+That means that when you upgrade to a newer Python (for example Python 3.15) this code may break.
+For that reason, the Python versions this package claims to work with are pinned to only known-to-be-working Python versions.
+
+
+## Installing
+
+To install globally:
+
+```console
+pip install pyrepl-hacks
+```
+
+Then you can use it in [your `PYTHONSTARTUP` file][PYTHONSTARTUP]:
+
+```python
+def _main():
+    try:
+        import pyrepl_hacks as repl
+    except ImportError:
+        pass  # We must be on Python 3.12 or earlier
+    else:
+        repl.bind("Alt+M", "move-to-indentation")
+        repl.bind("Shift+Tab", "dedent")
+        repl.bind("Alt+Down", "move-line-down")
+        repl.bind("Alt+Up", "move-line-up")
+        repl.bind("Shift+Home", "home")
+        repl.bind("Shift+End", "end")
+
+        repl.bind_to_insert("Ctrl+N", "[2, 1, 3, 4, 7, 11, 18, 29]")
+
+_main()
+del _main  # Don't polute the global namespace in our REPL
+```
+
+Note that this will only modify the REPL in environments where `pyrepl-hacks` is installed.
+So if you want it everywhere, you would need to install `pyrepl-hacks` system-wide *and* in every virtual environment.
+
+If you just want to play with this tool, try this:
+
+```console
+uvx --with pyrepl-hacks python
+```
+
+
+## Command Registering and Key Binding
+
+This library includes features for easily registering and binding new REPL commands.
+
+### Binding to existing commands
+
+You can bind a key to an existing command:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("Shift+Home", "home")
+```
+
+### Inserting text with a binding
+
+You can use the `bind_to_insert` helper to bind a key to insert specific text:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind_to_insert("Ctrl+P", "Python?!")
+```
+
+### Registering new commands
+
+Need something fancy that doesn't exist yet?
+
+You can register a new command:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.register_command
+def exit(reader):
+    """Exits Python immediately."""
+    import sys
+    sys.exit(0)
+```
+
+The `register_command` decorator will turn the `under_score` separated name into a `kebab-case` name by default.
+
+The `register_command` can optionally accept a command name and, if the command needs access to the event name and event object, a `with_event=True` argument can be provided:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.register_command("delete-line", with_event=True)
+def delete_whole_line(reader, event_name, event):
+    """Move to beginning of line and delete all text."""
+    reader.pos = reader.bol()
+    repl.commands.kill_line(reader, event_name, event)
+```
+
+After commands have been registered, they can be used with the `bind` function to bind them to specific keys:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("F4", "exit")
+repl.bind("Ctrl+X Ctrl+D", "delete-line")
+```
+
+### Binding keys while registering
+
+The `bind` function can also be used as a decorator to register a command and bind it to a specific key combination at the same time:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.bind("F4")
+def exit(reader):
+    """Exits Python immediately."""
+    import sys
+    sys.exit(0)
+```
+
+Since there's not much point in making a new command *without* binding it, you'll usually want to use `bind` instead of `register_command`.
+
+Just like `register_command`, `bind` decorator can also accept a `with_event=True` argument to pass the event name and event object into the command function.
+
+
+## Available Commands
+
+Here are some of the interesting commands provided by Python (in `_pyrepl.commands`):
+
+- `clear-screen`: Clear screen (`Ctrl+L`)
+- `accept`: Run current code block (`Alt+Enter`)
+- `beginning-of-line`: Move cursor to the first character of the current line (`Ctrl+A`)
+- `end-of-line`: Move cursor to the last character of the current line (`Ctrl+E`)
+- `home`: Move cursor the first character in the code block
+- `end`: Move cursor the last character in the code block
+- `kill-line`: Delete to end of line (`Ctrl+K`)
+- `unix-line-discard`: Delete to beginning of line (`Ctrl+U`)
+- `backward-word`: Move cursor back one word (`Ctrl+Left`)
+- `forward-word`: Move cursor forward one word (`Ctrl+Right`)
+- `backward-kill-word`:  Delete to beginning of word (`Alt+Backspace`)
+- `kill-word`:  Delete to end of word (`Alt+D`)
+
+This `pyrepl-hacks` project provides some additional commands as well:
+
+- `move-to-indentation`: Move to first non-space in current line
+- `dedent`: Dedent the whole code block
+- `move-line-down`: Swap current line with next one in the block
+- `move-line-up`: Swap current line with previous one in the block
+
+These 4 additional commands have no key bindings by default.
+
+I recommend binding these commands as well as the `home` and `end` commands (provided by `_pyrepl.commands`) which are also unbound by default:
+
+```python
+repl.bind("Alt+M", "move-to-indentation")   # Move to first non-space in current line
+repl.bind("Shift+Tab", "dedent")            # Dedent the whole input
+repl.bind("Alt+Down", "move-line-down")     # Swap current line with next in block
+repl.bind("Alt+Up", "move-line-up")         # Swap current line with previous in block
+repl.bind("Shift+Home", "home")             # Move to first character in the input
+repl.bind("Shift+End", "end")               # Move to last character in the input
+```
+
+Note that these custom REPL commands and all existing commands provided by `_pyrepl.commands` include wrapper functions in the `commands` submodule.
+These functions are named the same as their command name, except `-` must be replaced by `_`:
+
+```python
+from repl.commands import move_to_indentation, clear_screen
+```
+
+
+## The Future is Obsolescence?
+
+My hope is that this package will be obsolete one day.
+
+I hope that Python will eventually include an official interface for creating new REPL commands and binding keys to commands.
+
+I also hope that some (or all?) of the 4 new commands this module includes will eventually be included with Python by default.
+
+
+[PYTHONSTARTUP]: https://nedbatchelder.com/blog/201001/running_code_at_python_startup.html

pyrepl_hacks-0.1.0/README.md

@@ -0,0 +1,217 @@
+# pyrepl-hacks
+
+Hacky extensions and helper functions for the new Python REPL.
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("Alt+M", "move-to-indentation")   # Move to first non-space in current line
+repl.bind("Shift+Tab", "dedent")            # Dedent the whole input
+repl.bind("Alt+Down", "move-line-down")     # Swap current line with next in block
+repl.bind("Alt+Up", "move-line-up")         # Swap current line with previous in block
+repl.bind("Shift+Home", "home")             # Move to first character in the input
+repl.bind("Shift+End", "end")               # Move to last character in the input
+
+# Make Ctrl+N insert a specific list of numbers
+repl.bind_to_insert("Ctrl+N", "[2, 1, 3, 4, 7, 11, 18, 29]")
+
+
+@repl.bind(r"Ctrl+X Ctrl+R", with_event=True)
+def subprocess_run(reader, event_name, event):
+    """Ctrl+X followed by Ctrl+R will insert a subprocess.run command."""
+    reader.insert("import subprocess\n")
+    code = 'subprocess.run("", shell=True)'
+    reader.insert(code)
+    for _ in range(len(code) - code.index('""') - 1):
+        repl.commands.left(reader, event_name, event)
+```
+
+
+## ⚠️ WARNING: this could all break
+
+This library relies on Python implementation details which may change in future Python versions.
+
+This library uses the `_pyrepl` module (and optionally `_colorize`).
+As the `_` prefix implies, these modules are not designed for public use.
+
+That means that when you upgrade to a newer Python (for example Python 3.15) this code may break.
+For that reason, the Python versions this package claims to work with are pinned to only known-to-be-working Python versions.
+
+
+## Installing
+
+To install globally:
+
+```console
+pip install pyrepl-hacks
+```
+
+Then you can use it in [your `PYTHONSTARTUP` file][PYTHONSTARTUP]:
+
+```python
+def _main():
+    try:
+        import pyrepl_hacks as repl
+    except ImportError:
+        pass  # We must be on Python 3.12 or earlier
+    else:
+        repl.bind("Alt+M", "move-to-indentation")
+        repl.bind("Shift+Tab", "dedent")
+        repl.bind("Alt+Down", "move-line-down")
+        repl.bind("Alt+Up", "move-line-up")
+        repl.bind("Shift+Home", "home")
+        repl.bind("Shift+End", "end")
+
+        repl.bind_to_insert("Ctrl+N", "[2, 1, 3, 4, 7, 11, 18, 29]")
+
+_main()
+del _main  # Don't polute the global namespace in our REPL
+```
+
+Note that this will only modify the REPL in environments where `pyrepl-hacks` is installed.
+So if you want it everywhere, you would need to install `pyrepl-hacks` system-wide *and* in every virtual environment.
+
+If you just want to play with this tool, try this:
+
+```console
+uvx --with pyrepl-hacks python
+```
+
+
+## Command Registering and Key Binding
+
+This library includes features for easily registering and binding new REPL commands.
+
+### Binding to existing commands
+
+You can bind a key to an existing command:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("Shift+Home", "home")
+```
+
+### Inserting text with a binding
+
+You can use the `bind_to_insert` helper to bind a key to insert specific text:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind_to_insert("Ctrl+P", "Python?!")
+```
+
+### Registering new commands
+
+Need something fancy that doesn't exist yet?
+
+You can register a new command:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.register_command
+def exit(reader):
+    """Exits Python immediately."""
+    import sys
+    sys.exit(0)
+```
+
+The `register_command` decorator will turn the `under_score` separated name into a `kebab-case` name by default.
+
+The `register_command` can optionally accept a command name and, if the command needs access to the event name and event object, a `with_event=True` argument can be provided:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.register_command("delete-line", with_event=True)
+def delete_whole_line(reader, event_name, event):
+    """Move to beginning of line and delete all text."""
+    reader.pos = reader.bol()
+    repl.commands.kill_line(reader, event_name, event)
+```
+
+After commands have been registered, they can be used with the `bind` function to bind them to specific keys:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("F4", "exit")
+repl.bind("Ctrl+X Ctrl+D", "delete-line")
+```
+
+### Binding keys while registering
+
+The `bind` function can also be used as a decorator to register a command and bind it to a specific key combination at the same time:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.bind("F4")
+def exit(reader):
+    """Exits Python immediately."""
+    import sys
+    sys.exit(0)
+```
+
+Since there's not much point in making a new command *without* binding it, you'll usually want to use `bind` instead of `register_command`.
+
+Just like `register_command`, `bind` decorator can also accept a `with_event=True` argument to pass the event name and event object into the command function.
+
+
+## Available Commands
+
+Here are some of the interesting commands provided by Python (in `_pyrepl.commands`):
+
+- `clear-screen`: Clear screen (`Ctrl+L`)
+- `accept`: Run current code block (`Alt+Enter`)
+- `beginning-of-line`: Move cursor to the first character of the current line (`Ctrl+A`)
+- `end-of-line`: Move cursor to the last character of the current line (`Ctrl+E`)
+- `home`: Move cursor the first character in the code block
+- `end`: Move cursor the last character in the code block
+- `kill-line`: Delete to end of line (`Ctrl+K`)
+- `unix-line-discard`: Delete to beginning of line (`Ctrl+U`)
+- `backward-word`: Move cursor back one word (`Ctrl+Left`)
+- `forward-word`: Move cursor forward one word (`Ctrl+Right`)
+- `backward-kill-word`:  Delete to beginning of word (`Alt+Backspace`)
+- `kill-word`:  Delete to end of word (`Alt+D`)
+
+This `pyrepl-hacks` project provides some additional commands as well:
+
+- `move-to-indentation`: Move to first non-space in current line
+- `dedent`: Dedent the whole code block
+- `move-line-down`: Swap current line with next one in the block
+- `move-line-up`: Swap current line with previous one in the block
+
+These 4 additional commands have no key bindings by default.
+
+I recommend binding these commands as well as the `home` and `end` commands (provided by `_pyrepl.commands`) which are also unbound by default:
+
+```python
+repl.bind("Alt+M", "move-to-indentation")   # Move to first non-space in current line
+repl.bind("Shift+Tab", "dedent")            # Dedent the whole input
+repl.bind("Alt+Down", "move-line-down")     # Swap current line with next in block
+repl.bind("Alt+Up", "move-line-up")         # Swap current line with previous in block
+repl.bind("Shift+Home", "home")             # Move to first character in the input
+repl.bind("Shift+End", "end")               # Move to last character in the input
+```
+
+Note that these custom REPL commands and all existing commands provided by `_pyrepl.commands` include wrapper functions in the `commands` submodule.
+These functions are named the same as their command name, except `-` must be replaced by `_`:
+
+```python
+from repl.commands import move_to_indentation, clear_screen
+```
+
+
+## The Future is Obsolescence?
+
+My hope is that this package will be obsolete one day.
+
+I hope that Python will eventually include an official interface for creating new REPL commands and binding keys to commands.
+
+I also hope that some (or all?) of the 4 new commands this module includes will eventually be included with Python by default.
+
+
+[PYTHONSTARTUP]: https://nedbatchelder.com/blog/201001/running_code_at_python_startup.html

pyrepl_hacks-0.1.0/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "pyrepl-hacks"
+version = "0.1.0"
+description = "Hacky extensions and helper functions for the new Python REPL."
+readme = "README.md"
+requires-python = ">=3.13,<3.15"
+dependencies = []

pyrepl_hacks-0.1.0/pyrepl_hacks/__init__.py

@@ -0,0 +1,7 @@
+from .bind_utils import bind, bind_to_insert
+from .command_utils import register_command
+from .theme_utils import update_theme
+from . import commands
+
+
+__all__ = ["bind", "bind_to_insert", "register_command", "update_theme"]

pyrepl_hacks-0.1.0/pyrepl_hacks/bind_utils.py

@@ -0,0 +1,52 @@
+from _pyrepl.simple_interact import _get_reader
+from collections.abc import Callable
+import logging
+
+from .command_utils import register_command
+from .key_utils import slugify, to_keyspec
+
+
+__all__ = ["bind", "bind_to_insert"]
+
+
+logger = logging.getLogger(__name__)
+
+
+def _bind_decorator(keybinding: str, with_event: bool):
+    def decorator(command_function: Callable):
+        command = register_command(command_function, with_event=with_event)
+        return _bind_existing_command(keybinding, command.name)
+    return decorator
+
+
+def _bind_existing_command(keybinding: str, command_name: str = None):
+    keyspec = to_keyspec(keybinding)
+    logger.debug("binding: %s for %s", keyspec, command_name)
+    reader = _get_reader()
+    reader.bind(keyspec, command_name)
+
+
+def _bind_new_command(keybinding: str, command_name: str = None, command_function: Callable = None):
+    command = register_command(command_name)(command_function)
+    _bind_existing_command(keybinding, command_name)
+    return command
+
+
+def bind(
+    keybinding: str,
+    command_name: str = None,
+    command_function: Callable = None,
+    *,
+    with_event = False,
+):
+    if command_function is not None:
+        return _bind_new_command(keybinding, command_name, command_function)
+    elif command_name is not None:
+        return _bind_existing_command(keybinding, command_name)
+    else:
+        return _bind_decorator(keybinding, with_event)
+
+
+def bind_to_insert(keybinding: str, text: str):
+    def command_function(reader): reader.insert(text)
+    bind(keybinding, slugify(keybinding), command_function)

pyrepl_hacks-0.1.0/pyrepl_hacks/command_utils.py

@@ -0,0 +1,38 @@
+from _pyrepl.simple_interact import _get_reader
+from _pyrepl.commands import Command
+from collections.abc import Callable
+
+
+__all__ = ["register_command", "custom_commands"]
+
+
+def under_to_kebab(name):
+    """Convert under_score_case to kebab-case."""
+    return name.replace("_", "-")
+
+
+def register_command(command_name: str = None, /, *, with_event: bool = False):
+    def decorator(command_function: Callable):
+        name = command_name or under_to_kebab(command_function.__name__)
+
+        def do(self):
+            if with_event:
+                return command_function(self.reader, self.event_name, self.event)
+            else:
+                return command_function(self.reader)
+        command_class = type(
+            name,
+            (Command,),
+            {"do": do},
+        )
+        reader = _get_reader()
+        reader.commands[name] = command_class
+        command_function.command_class = command_class
+        command_function.name = name
+        return command_function
+    if isinstance(command_name, Callable):
+        command_function = command_name
+        command_name = None
+        return decorator(command_function)
+    else:
+        return decorator

pyrepl_hacks-0.1.0/pyrepl_hacks/commands.py

@@ -0,0 +1,112 @@
+import re
+import textwrap
+
+from .command_utils import register_command
+
+
+# _pyrepl.commands are also included later (see _add_pyrepl_commands)
+__all__ = ["move_to_indentation", "dedent", "move_line_down", "move_line_up"]
+
+
+@register_command
+def move_to_indentation(reader):
+    """Move to the start of indentation for the current line."""
+    x, y = reader.pos2xy()
+    lines = reader.get_unicode().splitlines(keepends=True)
+    line = lines[y]
+    if match := re.search(r"^\s+", line):
+        index = match.end()
+    else:
+        index = 0
+    reader.pos = reader.bol() + index
+
+
+@register_command
+def dedent(reader):
+    """Dedent the current code block."""
+    x, y = reader.pos2xy()
+    original_text = reader.get_unicode()
+    dedented_text = textwrap.dedent(original_text)
+
+    # Dedent buffer and invalidate cache
+    reader.buffer[:] = list(dedented_text)
+    reader.last_refresh_cache.invalidated = True
+    reader.dirty = True
+
+    # Reposition cursor correctly
+    original_lines = original_text.splitlines()
+    dedented_lines = dedented_text.splitlines()
+    removed_characters = sum(
+        len(old) - len(new)
+        for old, new in zip(original_lines[:y+1], dedented_lines)
+    )
+    reader.pos -= removed_characters
+
+
+@register_command
+def move_line_down(reader):
+    """Move the current line down."""
+    x, y = reader.pos2xy()
+    lines = reader.get_unicode().splitlines(keepends=True)
+
+    # Can't move down if we're on the last line
+    if y >= len(lines) - 1:
+        return
+
+    # Swap current line with next line
+    lines[y], lines[y+1] = lines[y+1], lines[y]
+
+    if not lines[y].endswith("\n"):
+        lines[y] += "\n"
+
+    # Update buffer with swapped lines
+    reader.buffer[:] = list("".join(lines))
+    reader.last_refresh_cache.invalidated = True
+    reader.dirty = True
+
+    # Move cursor to same column in the moved line (one line up)
+    reader.pos += len(lines[y])
+
+
+@register_command
+def move_line_up(reader):
+    """Move the current line up."""
+    x, y = reader.pos2xy()
+    lines = reader.get_unicode().splitlines(keepends=True)
+
+    # Can't move up if we're on the first line
+    if y <= 0:
+        return
+
+    # Swap current line with previous line
+    lines[y-1], lines[y] = lines[y], lines[y-1]
+
+    # Update buffer with swapped lines
+    reader.buffer[:] = list("".join(lines))
+    reader.last_refresh_cache.invalidated = True
+    reader.dirty = True
+
+    # Move cursor to same column in the moved line (one line up)
+    reader.pos -= len(lines[y])
+
+
+def _add_pyrepl_commands():
+    """Create simple command functions for all _pyrepl commands also."""
+    import _pyrepl.commands
+    from functools import wraps
+    for name, value in vars(_pyrepl.commands).items():
+        if (
+                isinstance(value, type)
+                and issubclass(value, _pyrepl.commands.Command)
+                and hasattr(value, "do")
+        ):
+            def wrapper(command_class):
+                @wraps(value, assigned=["__name__", "__doc__"], updated=[])
+                def command_function(reader, event_name, event):
+                    return command_class(reader, event_name, event).do()
+                return command_function
+            globals()[name] = wrapper(value)
+            __all__.append(name)
+
+
+_add_pyrepl_commands()

pyrepl_hacks-0.1.0/pyrepl_hacks/key_utils.py

@@ -0,0 +1,54 @@
+import re
+
+
+bindings_to_specs = {
+    "ctrl": r"\C",
+    "alt": r"\M",
+    "pgup": r"\<page up>",
+    "pgdn": r"\<page down>",
+}
+
+
+# Cases that can't be handled by \C- or \M- notation
+SPECIAL_CASES = {
+    "alt+up": r"\e[1;3A",
+    "alt+down": r"\e[1;3B", 
+    "alt+right": r"\e[1;3C",
+    "alt+left": r"\e[1;3D",
+    "shift+tab": r"\e[Z",
+    "shift+up": r"\e[1;2A",
+    "shift+down": r"\e[1;2B",
+    "shift+right": r"\e[1;2C", 
+    "shift+left": r"\e[1;2D",
+    "shift+home": r"\e[1;2H",
+    "shift+end": r"\e[1;2F",
+    "shift+pageup": r"\e[5;2~",
+    "shift+pagedown": r"\e[6;2~",
+    "shift+pgup": r"\e[5;2~",
+    "shift+pgdn": r"\e[6;2~",
+    "shift+insert": r"\e[2;2~",
+    "shift+delete": r"\e[3;2~",
+    # Add more as we discover them
+}
+
+
+def slugify(keybinding):
+    """Create unique slug for keybinding."""
+    return "_" + "".join(
+        c if c.isalnum() else "_"
+        for c in keybinding
+    )
+
+
+def to_keyspec(keybinding: str):
+    r"""Convert human-readable bindings to specs (e.g. Ctrl+A to \C-a)."""
+    normalized = keybinding.lower().strip()
+    if normalized in SPECIAL_CASES:
+        return SPECIAL_CASES[normalized]
+    spec = ""
+    for section in normalized.split():
+        spec += "-".join([
+            bindings_to_specs.get(part, rf"\<{part}>") if len(part) != 1 else part
+            for part in section.split("+")
+        ])
+    return spec

pyrepl_hacks-0.1.0/pyrepl_hacks/theme_utils.py

@@ -0,0 +1,17 @@
+def _convert_color(color):
+    """Convert strings like 'reset, intense blue' into valid color."""
+    subcolors = color.split(",")
+    return "".join(
+        getattr(ANSIColors, c.strip().replace(" ", "_").upper())
+        for c in subcolors
+    )
+
+
+def update_theme(**kwargs):
+    from _colorize import set_theme, default_theme, Syntax, ANSIColors
+    items = {
+        name: _convert_color(color)
+        for name, color in kwargs.items()
+    }
+    new_theme = default_theme.copy_with(syntax=Syntax(**items))
+    set_theme(new_theme)

pyrepl_hacks-0.1.0/pyrepl_hacks.egg-info/PKG-INFO

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: pyrepl-hacks
+Version: 0.1.0
+Summary: Hacky extensions and helper functions for the new Python REPL.
+Requires-Python: <3.15,>=3.13
+Description-Content-Type: text/markdown
+
+# pyrepl-hacks
+
+Hacky extensions and helper functions for the new Python REPL.
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("Alt+M", "move-to-indentation")   # Move to first non-space in current line
+repl.bind("Shift+Tab", "dedent")            # Dedent the whole input
+repl.bind("Alt+Down", "move-line-down")     # Swap current line with next in block
+repl.bind("Alt+Up", "move-line-up")         # Swap current line with previous in block
+repl.bind("Shift+Home", "home")             # Move to first character in the input
+repl.bind("Shift+End", "end")               # Move to last character in the input
+
+# Make Ctrl+N insert a specific list of numbers
+repl.bind_to_insert("Ctrl+N", "[2, 1, 3, 4, 7, 11, 18, 29]")
+
+
+@repl.bind(r"Ctrl+X Ctrl+R", with_event=True)
+def subprocess_run(reader, event_name, event):
+    """Ctrl+X followed by Ctrl+R will insert a subprocess.run command."""
+    reader.insert("import subprocess\n")
+    code = 'subprocess.run("", shell=True)'
+    reader.insert(code)
+    for _ in range(len(code) - code.index('""') - 1):
+        repl.commands.left(reader, event_name, event)
+```
+
+
+## ⚠️ WARNING: this could all break
+
+This library relies on Python implementation details which may change in future Python versions.
+
+This library uses the `_pyrepl` module (and optionally `_colorize`).
+As the `_` prefix implies, these modules are not designed for public use.
+
+That means that when you upgrade to a newer Python (for example Python 3.15) this code may break.
+For that reason, the Python versions this package claims to work with are pinned to only known-to-be-working Python versions.
+
+
+## Installing
+
+To install globally:
+
+```console
+pip install pyrepl-hacks
+```
+
+Then you can use it in [your `PYTHONSTARTUP` file][PYTHONSTARTUP]:
+
+```python
+def _main():
+    try:
+        import pyrepl_hacks as repl
+    except ImportError:
+        pass  # We must be on Python 3.12 or earlier
+    else:
+        repl.bind("Alt+M", "move-to-indentation")
+        repl.bind("Shift+Tab", "dedent")
+        repl.bind("Alt+Down", "move-line-down")
+        repl.bind("Alt+Up", "move-line-up")
+        repl.bind("Shift+Home", "home")
+        repl.bind("Shift+End", "end")
+
+        repl.bind_to_insert("Ctrl+N", "[2, 1, 3, 4, 7, 11, 18, 29]")
+
+_main()
+del _main  # Don't polute the global namespace in our REPL
+```
+
+Note that this will only modify the REPL in environments where `pyrepl-hacks` is installed.
+So if you want it everywhere, you would need to install `pyrepl-hacks` system-wide *and* in every virtual environment.
+
+If you just want to play with this tool, try this:
+
+```console
+uvx --with pyrepl-hacks python
+```
+
+
+## Command Registering and Key Binding
+
+This library includes features for easily registering and binding new REPL commands.
+
+### Binding to existing commands
+
+You can bind a key to an existing command:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("Shift+Home", "home")
+```
+
+### Inserting text with a binding
+
+You can use the `bind_to_insert` helper to bind a key to insert specific text:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind_to_insert("Ctrl+P", "Python?!")
+```
+
+### Registering new commands
+
+Need something fancy that doesn't exist yet?
+
+You can register a new command:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.register_command
+def exit(reader):
+    """Exits Python immediately."""
+    import sys
+    sys.exit(0)
+```
+
+The `register_command` decorator will turn the `under_score` separated name into a `kebab-case` name by default.
+
+The `register_command` can optionally accept a command name and, if the command needs access to the event name and event object, a `with_event=True` argument can be provided:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.register_command("delete-line", with_event=True)
+def delete_whole_line(reader, event_name, event):
+    """Move to beginning of line and delete all text."""
+    reader.pos = reader.bol()
+    repl.commands.kill_line(reader, event_name, event)
+```
+
+After commands have been registered, they can be used with the `bind` function to bind them to specific keys:
+
+```python
+import pyrepl_hacks as repl
+
+repl.bind("F4", "exit")
+repl.bind("Ctrl+X Ctrl+D", "delete-line")
+```
+
+### Binding keys while registering
+
+The `bind` function can also be used as a decorator to register a command and bind it to a specific key combination at the same time:
+
+```python
+import pyrepl_hacks as repl
+
+@repl.bind("F4")
+def exit(reader):
+    """Exits Python immediately."""
+    import sys
+    sys.exit(0)
+```
+
+Since there's not much point in making a new command *without* binding it, you'll usually want to use `bind` instead of `register_command`.
+
+Just like `register_command`, `bind` decorator can also accept a `with_event=True` argument to pass the event name and event object into the command function.
+
+
+## Available Commands
+
+Here are some of the interesting commands provided by Python (in `_pyrepl.commands`):
+
+- `clear-screen`: Clear screen (`Ctrl+L`)
+- `accept`: Run current code block (`Alt+Enter`)
+- `beginning-of-line`: Move cursor to the first character of the current line (`Ctrl+A`)
+- `end-of-line`: Move cursor to the last character of the current line (`Ctrl+E`)
+- `home`: Move cursor the first character in the code block
+- `end`: Move cursor the last character in the code block
+- `kill-line`: Delete to end of line (`Ctrl+K`)
+- `unix-line-discard`: Delete to beginning of line (`Ctrl+U`)
+- `backward-word`: Move cursor back one word (`Ctrl+Left`)
+- `forward-word`: Move cursor forward one word (`Ctrl+Right`)
+- `backward-kill-word`:  Delete to beginning of word (`Alt+Backspace`)
+- `kill-word`:  Delete to end of word (`Alt+D`)
+
+This `pyrepl-hacks` project provides some additional commands as well:
+
+- `move-to-indentation`: Move to first non-space in current line
+- `dedent`: Dedent the whole code block
+- `move-line-down`: Swap current line with next one in the block
+- `move-line-up`: Swap current line with previous one in the block
+
+These 4 additional commands have no key bindings by default.
+
+I recommend binding these commands as well as the `home` and `end` commands (provided by `_pyrepl.commands`) which are also unbound by default:
+
+```python
+repl.bind("Alt+M", "move-to-indentation")   # Move to first non-space in current line
+repl.bind("Shift+Tab", "dedent")            # Dedent the whole input
+repl.bind("Alt+Down", "move-line-down")     # Swap current line with next in block
+repl.bind("Alt+Up", "move-line-up")         # Swap current line with previous in block
+repl.bind("Shift+Home", "home")             # Move to first character in the input
+repl.bind("Shift+End", "end")               # Move to last character in the input
+```
+
+Note that these custom REPL commands and all existing commands provided by `_pyrepl.commands` include wrapper functions in the `commands` submodule.
+These functions are named the same as their command name, except `-` must be replaced by `_`:
+
+```python
+from repl.commands import move_to_indentation, clear_screen
+```
+
+
+## The Future is Obsolescence?
+
+My hope is that this package will be obsolete one day.
+
+I hope that Python will eventually include an official interface for creating new REPL commands and binding keys to commands.
+
+I also hope that some (or all?) of the 4 new commands this module includes will eventually be included with Python by default.
+
+
+[PYTHONSTARTUP]: https://nedbatchelder.com/blog/201001/running_code_at_python_startup.html

pyrepl_hacks-0.1.0/pyrepl_hacks.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+pyrepl_hacks/__init__.py
+pyrepl_hacks/bind_utils.py
+pyrepl_hacks/command_utils.py
+pyrepl_hacks/commands.py
+pyrepl_hacks/key_utils.py
+pyrepl_hacks/theme_utils.py
+pyrepl_hacks.egg-info/PKG-INFO
+pyrepl_hacks.egg-info/SOURCES.txt
+pyrepl_hacks.egg-info/dependency_links.txt
+pyrepl_hacks.egg-info/top_level.txt

pyrepl_hacks-0.1.0/pyrepl_hacks.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyrepl_hacks-0.1.0/pyrepl_hacks.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyrepl_hacks

pyrepl_hacks-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+