sshkeyboard

https://sshkeyboard.readthedocs.io/en/latest
Admin
sshkeyboard is a Python keyboard event callback library that works over SSH connections without...
Tokens:6,381
Snippets:55
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install sshkeyboard

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Install the library using pip.

```bash
pip install sshkeyboard

```

--------------------------------

### Install Development Dependencies

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Install the necessary development dependencies using pip, as listed in `dev-requirements.txt`, to build documentation and run pre-commit scripts.

```bash
pip install -r dev-requirements.txt
```

--------------------------------

### Install Pre-commit Hooks

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Copy the `pre-commit` script to `.git/hooks/` to automatically run the pre-commit checks on each Git commit.

```bash
cp pre-commit .git/hooks
```

--------------------------------

### Clone the SSHKeyboard Repository

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

To start development, clone the SSHKeyboard repository from GitHub and navigate into the project directory.

```bash
git clone git@github.com:ollipal/sshkeyboard.git
cd sshkeyboard
```

--------------------------------

### Keyboard Listener Example

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Demonstrates how to use the `listen_keyboard` function (presumably from an imported library) to capture key press and release events. Press 'esc' to exit.

```python
import asyncio

# Assume listen_keyboard and listen_keyboard_manual are defined elsewhere
def listen_keyboard(on_press, on_release):
    pass
async def listen_keyboard_manual(press, release):
    pass

async def press(key):
    print(f"'{key}' pressed")

def release(key):
    print(f"'{key}' released")

if __name__ == "__main__":

    print("listening keyboard, press keys, and press 'esc' to exit")
    listen_keyboard(on_press=press, on_release=release)
    # ^this is the same as
    # asyncio.run(listen_keyboard_manual(press, release))
```

--------------------------------

### listen_keyboard

Source: https://sshkeyboard.readthedocs.io/en/latest/reference.html

Starts listening for keyboard events and executes callback functions on press or release. This function blocks the thread until the specified 'until' key is pressed or stop_listening is called.

```APIDOC
## listen_keyboard

### Description
Listens for keyboard events and fires on_press and on_release callback functions. Supports asynchronous callbacks and blocks the thread until the 'until' key is pressed.

### Parameters
- **on_press** (Callable[[str], Any]) - Optional - Function called when a key is pressed.
- **on_release** (Callable[[str], Any]) - Optional - Function called when a key is released.
- **until** (str) - Optional - Key that ends listening. Defaults to 'esc'.
- **sequential** (bool) - Optional - If True, callbacks execute one by one. Defaults to False.
- **delay_second_char** (float) - Optional - Timeout between first and second character. Defaults to 0.75.
- **delay_other_chars** (float) - Optional - Timeout between other characters. Defaults to 0.05.
- **lower** (bool) - Optional - If True, converts keys to lowercase. Defaults to True.
- **debug** (bool) - Optional - Print debug messages. Defaults to False.
- **max_thread_pool_workers** (int) - Optional - Number of workers in ThreadPoolExecutor. Defaults to None.
- **sleep** (float) - Optional - asyncio.sleep amount between reads. Defaults to 0.01.
```

--------------------------------

### Concurrent Callback Example

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Demonstrates concurrent execution of callbacks. When keys are pressed, the 'on_press' function executes immediately, allowing other callbacks to run before the current one finishes. This can lead to overlapping execution if callbacks have long-running operations.

```python
import time
from sshkeyboard import listen_keyboard

def press(key):
    print(f"'{key}' pressed")
    time.sleep(3)
    print(f"'{key}' slept")

listen_keyboard(on_press=press)

```

--------------------------------

### Listen with Debug Mode Enabled

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Enable debug mode in `listen_keyboard` to get additional logs, which can help in troubleshooting if keys are not registering correctly.

```python
from sshkeyboard import listen_keyboard

def press(key):
    print(f"'{key}' pressed")

listen_keyboard(
    on_press=press,
    debug=True,
)
```

--------------------------------

### Sequential Callback Mode

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Enables sequential execution of callbacks. Ensures that one callback completes before the next one starts, preventing overlap. Useful when callback operations must not interfere with each other.

```python
# ...
listen_keyboard(
    on_press=press,
    sequential=True,
)

```

--------------------------------

### Check for Unix ANSI Character

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Determines if a given character string is likely the start of a Unix ANSI escape sequence.

```python
def _is_unix_ansi(char):
    rep = repr(char)
    return len(rep) >= 2 and rep[1] == "\" and rep[2] == "x"
```

--------------------------------

### Set Up and Activate Virtual Environment

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Create and activate a Python virtual environment for the project to manage dependencies. Use `python3` if `python` is not aliased.

```bash
python -m venv .env
source .env/bin/activate
```

--------------------------------

### Build Documentation Locally

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Navigate to the `docs/` directory and use `make html` to build the project documentation locally. The output will be in `docs/build/html/`.

```bash
cd docs
make html
```

--------------------------------

### Force Documentation Rebuild

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

To ensure a clean build of the documentation, remove the existing build directory and then run `make html`.

```bash
rm -rf build/ && make html
```

--------------------------------

### Enable Automatic Documentation Rebuilding

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Use `sphinx-autobuild` to automatically rebuild and serve the documentation locally when changes are made to the source files.

```bash
sphinx-autobuild ./source/ ./build/html/
```

--------------------------------

### Run Pre-commit Script

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Execute the `./pre-commit` script to run tests, formatting, and linting checks locally before committing code.

```bash
./pre-commit
```

--------------------------------

### Manual keyboard listening

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Shows the manual invocation pattern for keyboard listening, which requires the caller to handle the awaitable.

```python
from sshkeyboard import listen_keyboard_manual
# ...
asyncio.run(listen_keyboard_manual(...))
```

```python
from sshkeyboard import listen_keyboard
# ...
listen_keyboard(...)
```

--------------------------------

### listen_keyboard_manual

Source: https://sshkeyboard.readthedocs.io/en/latest/reference.html

An asynchronous version of listen_keyboard where the caller must handle the awaiting process.

```APIDOC
## listen_keyboard_manual

### Description
Functions identically to listen_keyboard, but the awaiting must be handled by the caller, allowing for manual control over the asynchronous execution flow.
```

--------------------------------

### sshkeyboard Module Reference

Source: https://sshkeyboard.readthedocs.io/en/latest/_sources/reference.md.txt

Documentation for the sshkeyboard module members.

```APIDOC
## Module: sshkeyboard

### Description
This module provides functionality for handling keyboard input over SSH connections.

### Members
- **listen_keyboard**: Function to start listening for keyboard events.
- **stop_keyboard**: Function to stop the keyboard listener.
- **is_pressed**: Function to check if a specific key is currently pressed.
```

--------------------------------

### listen_keyboard_manual API

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

This is an asynchronous version of `listen_keyboard`. The caller is responsible for handling the awaiting of this coroutine. It has the same parameters and functionality as `listen_keyboard` but requires manual management of the asyncio event loop.

```APIDOC
## listen_keyboard_manual

### Description
An asynchronous function that listens for keyboard events. The caller must handle the awaiting of this coroutine. It provides the same functionality as :func:`~sshkeyboard.listen_keyboard` but requires manual event loop management.

### Method
Asynchronous coroutine function.

### Endpoint
N/A (This is a Python function, not a network endpoint)

### Parameters
#### Arguments
- **on_press** (Optional[Callable[[str], Any]]) - Optional - Function called when a key is pressed. Takes the pressed key as a parameter.
- **on_release** (Optional[Callable[[str], Any]]) - Optional - Function called when a key is released. Takes the released key as a parameter.
- **until** (Optional[str]) - Optional - A key that will end keyboard listening. Defaults to "esc". If None, listening stops only when :func:`~sshkeyboard.stop_listening` is called or an error is raised.
- **sequential** (bool) - Optional - If enabled, callbacks are forced to happen one by one instead of concurrently or asynchronously. Defaults to False.
- **delay_second_char** (float) - Optional - Timeout between the first and second character when holding down a key. Used for parsing input. Defaults to 0.75.
- **delay_other_chars** (float) - Optional - Timeout between all other characters when holding down a key. Used for parsing input. Defaults to 0.05.
- **lower** (bool) - Optional - If enabled, the callback 'key' parameter is converted to lowercase. Defaults to True.
- **debug** (bool) - Optional - Enables printing of debug messages. Defaults to False.
- **max_thread_pool_workers** (Optional[int]) - Optional - Defines the number of workers in ThreadPoolExecutor. None uses a default value. Ignored if sequential=True. Defaults to None.
- **sleep** (float) - Optional - Amount for asyncio.sleep() between attempted keyboard input reads. Defaults to 0.01.

### Request Example
```python
import asyncio
from sshkeyboard import listen_keyboard_manual

async def press(key):
    print(f"'{key}' pressed")

def release(key):
    print(f"'{key}' released")

asyncio.run(listen_keyboard_manual(
    on_press=press,
    on_release=release,
))
```

### Response
This coroutine does not return a value directly. It operates by calling the provided callbacks.

#### Success Response
N/A

#### Response Example
N/A
```

--------------------------------

### Listen for Keyboard Events with Callbacks

Source: https://sshkeyboard.readthedocs.io/en/latest/reference.html

Use this function to capture keyboard presses and releases. Supports both asynchronous and regular callback functions. The listener blocks until a specified key is pressed or stop_listening() is called.

```python
from sshkeyboard import listen_keyboard

async def press(key):
    print(f"'{key}' pressed")

def release(key):
    print(f"'{key}' released")

listen_keyboard(
    on_press=press,
    on_release=release,
)
```

--------------------------------

### Listen for Keyboard Events Until a Specific Key

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Use `listen_keyboard` to capture key presses. The listening stops automatically when the specified key (e.g., 'space') is pressed.

```python
from sshkeyboard import listen_keyboard

def press(key):
    print(f"'{key}' pressed")

listen_keyboard(
    on_press=press,
    until="space",
)
```

--------------------------------

### Basic Keyboard Listening

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Listen for key press and release events. The 'esc' key stops listening by default. Requires importing the listen_keyboard function.

```python
from sshkeyboard import listen_keyboard

def press(key):
    print(f"'{key}' pressed")

def release(key):
    print(f"'{key}' released")

listen_keyboard(
    on_press=press,
    on_release=release,
)

```

--------------------------------

### Manually Handle Keyboard Event Listening

Source: https://sshkeyboard.readthedocs.io/en/latest/reference.html

This function is similar to listen_keyboard but requires the caller to manage the asyncio event loop. Use this when you need more control over the asynchronous execution context.

```python
from sshkeyboard import listen_keyboard_manual
import asyncio
# ...
asyncio.run(listen_keyboard_manual(...))
```

--------------------------------

### Mixing Async and Sync Callbacks

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Combines asynchronous and synchronous callback functions. This allows for flexible handling of different types of operations within the same keyboard listening session.

```python
import asyncio
import time
from sshkeyboard import listen_keyboard

async def press(key):
    print(f"'{key}' pressed")
    await asyncio.sleep(3)
    print(f"'{key}' press slept")

def release(key):
    print(f"'{key}' relased")
    time.sleep(3)
    print(f"'{key}' release slept")

listen_keyboard(
    on_press=press,
    on_release=release,
)

```

--------------------------------

### Sequential Async and Sync Callbacks

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Configures sequential execution for a mix of asynchronous and synchronous callbacks. This ensures that callbacks are processed one after another, even when mixing different concurrency models.

```python
# ...
listen_keyboard(
    on_press=press,
    on_release=release,
    sequential=True,
)

```

--------------------------------

### Adjust Keyboard Event Timing

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Customize timing parameters like `delay_second_char` and `delay_other_chars` in `listen_keyboard` to manage callback frequency and responsiveness, especially if multiple callbacks occur or releasing keys is slow.

```python
from sshkeyboard import listen_keyboard

def press(key):
    print(f"'{key}' pressed")

listen_keyboard(
    on_press=press,
    delay_second_char=0.75,
    delay_other_chars=0.05,
)
```

--------------------------------

### Customizing Stop Key

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Allows changing the key that terminates the keyboard listening session. The `until` parameter defaults to 'esc'.

```python
# ...
listen_keyboard(
    until='q',
)

```

--------------------------------

### Raw Mode Context Manager

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Use this context manager to temporarily set the terminal to cbreak mode, which disables line buffering and echoing of input characters. Not required on Windows.

```python
from contextlib import contextmanager
import termios
import tty

_is_windows = False # Assume not Windows for this snippet

@contextmanager
def _raw(stream):
    # Not required on Windows
    if _is_windows:
        yield
        return

    original_stty = termios.tcgetattr(stream)
    try:
        tty.setcbreak(stream)
        yield
    finally:
        termios.tcsetattr(stream, termios.TCSANOW, original_stty)
```

--------------------------------

### Asyncio Keyboard Listening

Source: https://sshkeyboard.readthedocs.io/en/latest/index.html

Utilizes asynchronous functions for callbacks. Use `asyncio.sleep` within async callbacks instead of `time.sleep` to maintain proper asynchronous behavior and avoid blocking.

```python
import asyncio
from sshkeyboard import listen_keyboard

async def press(key):
    print(f"'{key}' pressed")
    await asyncio.sleep(3)
    print(f"'{key}' slept")

listen_keyboard(on_press=press)

```

--------------------------------

### Read Character (Platform Agnostic)

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

A wrapper function that calls the appropriate platform-specific function to read a single character from standard input. Handles Windows and Unix-like systems.

```python
def _read_char(debug):
    if _is_windows:
        return _read_char_win(debug)
    else:
        return _read_char_unix(debug)
```

--------------------------------

### SSH Keyboard Library Source Code

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

The main source code for the sshkeyboard library, including imports, global state, and character mappings.

```python
__version__ = "2.3.1"

import asyncio
import concurrent.futures
import os
import sys
import traceback
from contextlib import contextmanager
from inspect import signature
from platform import system
from time import time
from types import SimpleNamespace
from typing import Any, Callable, Optional

try:
    from ._asyncio_run_backport_36 import run36
except ImportError:  # this allows local testing: python __init__.py
    from _asyncio_run_backport_36 import run36

_is_windows = system().lower() == "windows"

if _is_windows:
    import msvcrt
else:
    import fcntl
    import termios
    import tty


# Global state

# Makes sure only listener can be started at a time
_running = False
# Makes sure listener stops if error has been raised
# inside thread pool executor or asyncio task or
# stop_listening() has been called
_should_run = False

# Readable representations for selected ansi characters
# All possible ansi characters here:
# https://github.com/prompt-toolkit/python-prompt-toolkit/blob/master/prompt_toolkit/input/ansi_escape_sequences.py
# Listener does not support modifier keys for now
_UNIX_ANSI_CHAR_TO_READABLE = {
    # 'Regular' characters
    "\x1b": "esc",
    "\x7f": "backspace",
    "\x1b[2~": "insert",
    "\x1b[3~": "delete",
    "\x1b[5~": "pageup",
    "\x1b[6~": "pagedown",
    "\x1b[H": "home",
    "\x1b[F": "end",
    "\x1b[A": "up",
    "\x1b[B": "down",
    "\x1b[C": "right",
    "\x1b[D": "left",
    "\x1bOP": "f1",
    "\x1bOQ": "f2",
    "\x1bOR": "f3",
    "\x1bOS": "f4",
    "\x1b[15~": "f5",
    "\x1b[17~": "f6",
    "\x1b[18~": "f7",
    "\x1b[19~": "f8",
    "\x1b[20~": "f9",
    "\x1b[21~": "f10",
    "\x1b[23~": "f11",
    "\x1b[24~": "f12",
    "\x1b[25~": "f13",
    "\x1b[26~": "f14",
    "\x1b[28~": "f15",
    "\x1b[29~": "f16",
    "\x1b[31~": "f17",
    "\x1b[32~": "f18",
    "\x1b[33~": "f19",
    "\x1b[34~": "f20",
    # Special/duplicate:
    # Tmux, Emacs
    "\x1bOH": "home",
    "\x1bOF": "end",
    "\x1bOA": "up",
    "\x1bOB": "down",
    "\x1bOC": "right",
    "\x1bOD": "left",
    # Rrvt
    "\x1b[1~": "home",
    "\x1b[4~": "end",
    "\x1b[11~": "f1",
    "\x1b[12~": "f2",
    "\x1b[13~": "f3",
    "\x1b[14~": "f4",
    # Linux console
    "\x1b[[A": "f1",
    "\x1b[[B": "f2",
    "\x1b[[C": "f3",
    "\x1b[[D": "f4",
    "\x1b[[E": "f5",
    # Xterm
    "\x1b[1;2P": "f13",
    "\x1b[1;2Q": "f14",
    "\x1b[1;2S": "f16",
    "\x1b[15;2~": "f17",
    "\x1b[17;2~": "f18",
    "\x1b[18;2~": "f19",
    "\x1b[19;2~": "f20",
    "\x1b[20;2~": "f21",
    "\x1b[21;2~": "f22",
    "\x1b[23;2~": "f23",
    "\x1b[24;2~": "f24",
}

_WIN_CHAR_TO_READABLE = {
    "\x1b": "esc",
    "\x08": "backspace",
    "àR": "insert",
    "àS": "delete",
    "àI": "pageup",
    "àQ": "pagedown",
    "àG": "home",
    "àO": "end",
    "àH": "up",
    "àP": "down",
    "àM": "right",
    "àK": "left",
    "\x00;": "f1",
    "\x00<": "f2",
    "\x00=": "f3",
    "\x00>": "f4",
    "\x00?": "f5",
    "\x00@": "f6",
    "\x00A": "f7",
    "\x00B": "f8",
    "\x00C": "f9",
    "\x00D": "f10",
    # "": "f11", ?
    "à†": "f12",
}

```

--------------------------------

### Read from Unix stdin

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Reads a specified number of bytes from standard input on Unix-like systems. Returns None if an IOError occurs.

```python
import sys

def _read_unix_stdin(amount):
    try:
        return sys.stdin.read(amount)
    except IOError:
        return None
```

--------------------------------

### Non-blocking Mode Context Manager

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

This context manager sets the file descriptor of a stream to non-blocking mode, allowing reads to return immediately even if no data is available. Not required on Windows.

```python
import fcntl
import os

_is_windows = False # Assume not Windows for this snippet

@contextmanager
def _nonblocking(stream):
    # Not required on Windows
    if _is_windows:
        yield
        return

    fd = stream.fileno()
    orig_fl = fcntl.fcntl(fd, fcntl.F_GETFL)
    try:
        fcntl.fcntl(fd, fcntl.F_SETFL, orig_fl | os.O_NONBLOCK)
        yield
    finally:
        fcntl.fcntl(fd, fcntl.F_SETFL, orig_fl)
```

--------------------------------

### Asynchronous Input Reaction

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

An asynchronous function that reads a character, processes it (e.g., converts to lowercase, checks for stop conditions), and calls provided callbacks for key press and release events. Includes platform-specific adjustments for timing.

```python
import asyncio
from time import time

_is_windows = False # Assume not Windows for this snippet

def stop_listening():
    pass # Placeholder for actual stop logic

async def _react_to_input(state, options):
    # Read next character
    state.current = _read_char(options.debug)

    # Skip and continue if read failed
    if state.current is None:
        return state

    # Handle any character
    elif state.current != "":

        # Make lower case if requested
        if options.lower:
            state.current = state.current.lower()

        # Stop if until character has been read
        if options.until is not None and state.current == options.until:
            stop_listening()
            return state

        # Release state.previous if new pressed
        if state.previous != "" and state.current != state.previous:
            await options.on_release_callback(state.previous)
            # Weirdly on_release fires too late on Windows unless there is
            # an extra sleep here when sequential=False...
            if _is_windows and not options.sequential:
                await asyncio.sleep(options.sleep)

        # Press if new character, update state.previous
        if state.current != state.previous:
            await options.on_press_callback(state.current)
            state.initial_press_time = time()
            state.previous = state.current

        # Update press time
        if state.current == state.previous:
            state.press_time = time()

    # Handle empty
    # - Release the state.previous character if nothing is read
    # and enough time has passed
    # - The second character comes slower than the rest on terminal
    elif state.previous != "" and (
        time() - state.initial_press_time > options.delay_second_char
        and time() - state.press_time > options.delay_other_chars
    ):
        await options.on_release_callback(state.previous)
        state.previous = state.current

    return state
```

--------------------------------

### stop_listening

Source: https://sshkeyboard.readthedocs.io/en/latest/reference.html

Stops any ongoing keyboard listeners.

```APIDOC
## stop_listening

### Description
Stops the ongoing keyboard listeners. Can be called inside callbacks or from outside the listener loop. Does nothing if no listener is active.
```

--------------------------------

### Read Character (Unix)

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Reads a single character from Unix-like standard input. Handles ANSI escape sequences and character translations. Returns None if reading fails.

```python
def _read_char_unix(debug):
    char = _read_unix_stdin(1)

    # Skip and continue if read failed
    if char is None:
        return None

    # Handle any character
    elif char != "":
        # Read more if ansi character, skip and continue if unknown
        if _is_unix_ansi(char):
            char, raw = _read_and_parse_unix_ansi(char)
            if char is None:
                if debug:
                    print(f"Non-supported ansi char: {repr(raw)}")
                return None
        # Change some character representations to readable strings
        elif char in _CHAR_TO_READABLE:
            char = _CHAR_TO_READABLE[char]

    return char
```

--------------------------------

### Read Character (Windows)

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Reads a single character from the Windows console. Handles special keys and character translations. Returns an empty string if no character is available.

```python
import msvcrt

_WIN_SPECIAL_CHAR_STARTS = { '\x00': None, '\xe0': None } # Example, actual values needed
_WIN_REQUIRES_TWO_READS_STARTS = { '\xe0': None } # Example
_WIN_CHAR_TO_READABLE = { '\r': '\r', '\n': '\n', '\t': '\t' } # Example

def _read_char_win(debug):
    # Return if nothing to read
    if not msvcrt.kbhit():
        return ""

    char = msvcrt.getwch()
    if char in _WIN_SPECIAL_CHAR_STARTS:
        # Check if requires one more read
        if char in _WIN_REQUIRES_TWO_READS_STARTS:
            char += msvcrt.getwch()

        if char in _WIN_CHAR_TO_READABLE:
            return _WIN_CHAR_TO_READABLE[char]
        else:
            if debug:
                print(f"Non-supported win char: {repr(char)}")
            return None

    # Change some character representations to readable strings
    elif char in _CHAR_TO_READABLE:
        char = _CHAR_TO_READABLE[char]

    return char
```

--------------------------------

### Stop Keyboard Listener

Source: https://sshkeyboard.readthedocs.io/en/latest/reference.html

Call this function to terminate an active keyboard listener. It can be invoked from within a callback function or from an external context. If no listener is running, this function has no effect.

```python
from sshkeyboard import listen_keyboard, stop_listening

def press(key):
    print(f"'{key}' pressed")
    if key == "z":
        stop_listening()

listen_keyboard(on_press=press)
```

--------------------------------

### Read and Parse Unix ANSI Sequence

Source: https://sshkeyboard.readthedocs.io/en/latest/_modules/sshkeyboard.html

Reads additional characters to complete a potential ANSI escape sequence and attempts to parse it into a readable character. Returns None if the sequence is not recognized.

```python
_UNIX_ANSI_CHAR_TO_READABLE = { '\x1b[A': 'up', '\x1b[B': 'down', '\x1b[C': 'right', '\x1b[D': 'left' } # Example mappings

def _read_and_parse_unix_ansi(char):
    char += _read_unix_stdin(5)
    if char in _UNIX_ANSI_CHAR_TO_READABLE:
        return _UNIX_ANSI_CHAR_TO_READABLE[char], char
    else:
        return None, char
```
Tokens:
Raw