kovarctl 0.1.0__py3-none-any.whl

kovarctl/layouts.py

@@ -0,0 +1,273 @@
+"""Key name to firmware matrix slot maps.
+
+The firmware stores the keys in a matrix of 6 rows, column by column,
+so slot = column * 6 + row."""
+
+FULL_KEYS = {
+    'escape': 0,
+    'back_tick': 1,
+    'tab': 2,
+    'caps_lock': 3,
+    'left_shift': 4,
+    'left_control': 5,
+    '1': 7,
+    'q': 8,
+    'a': 9,
+    'iso_back_slash': 10,
+    'f1': 12,
+    '2': 13,
+    'w': 14,
+    's': 15,
+    'z': 16,
+    'left_windows': 17,
+    'f2': 18,
+    '3': 19,
+    'e': 20,
+    'd': 21,
+    'x': 22,
+    'left_alt': 23,
+    'f3': 24,
+    '4': 25,
+    'r': 26,
+    'f': 27,
+    'c': 28,
+    'f4': 30,
+    '5': 31,
+    't': 32,
+    'g': 33,
+    'v': 34,
+    'f5': 36,
+    '6': 37,
+    'y': 38,
+    'h': 39,
+    'b': 40,
+    'space': 41,
+    'f6': 42,
+    '7': 43,
+    'u': 44,
+    'j': 45,
+    'n': 46,
+    'right_alt': 47,
+    'f7': 48,
+    '8': 49,
+    'i': 50,
+    'k': 51,
+    'm': 52,
+    'right_function': 53,
+    'f8': 54,
+    '9': 55,
+    'o': 56,
+    'l': 57,
+    'comma': 58,
+    'menu': 59,
+    'f9': 60,
+    '0': 61,
+    'p': 62,
+    'semicolon': 63,
+    'period': 64,
+    'right_control': 65,
+    'f10': 66,
+    'minus': 67,
+    'left_bracket': 68,
+    'quote': 69,
+    'forward_slash': 70,
+    'left_arrow': 71,
+    'f11': 72,
+    'equals': 73,
+    'right_bracket': 74,
+    'right_shift': 76,
+    'down_arrow': 77,
+    'f12': 78,
+    'backspace': 79,
+    'pound': 80,
+    'ansi_enter': 81,
+    'up_arrow': 82,
+    'right_arrow': 83,
+    'print_screen': 84,
+    'insert': 85,
+    'delete': 86,
+    'numpad_7': 87,
+    'numpad_4': 88,
+    'numpad_1': 89,
+    'scroll_lock': 90,
+    'home': 91,
+    'end': 92,
+    'numpad_8': 93,
+    'numpad_5': 94,
+    'numpad_2': 95,
+    'pause_break': 96,
+    'page_up': 97,
+    'page_down': 98,
+    'numpad_9': 99,
+    'numpad_6': 100,
+    'numpad_3': 101,
+    'calculator': 102,
+    'volume_up': 103,
+    'numpad_lock': 104,
+    'numpad_times': 105,
+    'numpad_period': 106,
+    'numpad_0': 107,
+    'volume_down': 108,
+    'mute': 109,
+    'numpad_divide': 110,
+    'numpad_minus': 111,
+    'numpad_plus': 112,
+    'numpad_enter': 113,
+}
+
+TKL_KEYS = {
+    'escape': 0,
+    'back_tick': 1,
+    'tab': 2,
+    'caps_lock': 3,
+    'left_shift': 4,
+    'left_control': 5,
+    '1': 7,
+    'q': 8,
+    'a': 9,
+    'iso_back_slash': 10,
+    'f1': 12,
+    '2': 13,
+    'w': 14,
+    's': 15,
+    'z': 16,
+    'left_windows': 17,
+    'f2': 18,
+    '3': 19,
+    'e': 20,
+    'd': 21,
+    'x': 22,
+    'left_alt': 23,
+    'f3': 24,
+    '4': 25,
+    'r': 26,
+    'f': 27,
+    'c': 28,
+    'f4': 30,
+    '5': 31,
+    't': 32,
+    'g': 33,
+    'v': 34,
+    'f5': 36,
+    '6': 37,
+    'y': 38,
+    'h': 39,
+    'b': 40,
+    'space': 41,
+    'f6': 42,
+    '7': 43,
+    'u': 44,
+    'j': 45,
+    'n': 46,
+    'right_alt': 47,
+    'f7': 48,
+    '8': 49,
+    'i': 50,
+    'k': 51,
+    'm': 52,
+    'right_function': 53,
+    'f8': 54,
+    '9': 55,
+    'o': 56,
+    'l': 57,
+    'comma': 58,
+    'menu': 59,
+    'f9': 60,
+    '0': 61,
+    'p': 62,
+    'semicolon': 63,
+    'period': 64,
+    'right_control': 65,
+    'f10': 66,
+    'minus': 67,
+    'left_bracket': 68,
+    'quote': 69,
+    'forward_slash': 70,
+    'left_arrow': 71,
+    'f11': 72,
+    'equals': 73,
+    'right_bracket': 74,
+    'right_shift': 76,
+    'down_arrow': 77,
+    'f12': 78,
+    'backspace': 79,
+    'pound': 80,
+    'ansi_enter': 81,
+    'up_arrow': 82,
+    'right_arrow': 83,
+    'print_screen': 84,
+    'insert': 85,
+    'delete': 86,
+    'scroll_lock': 90,
+    'home': 91,
+    'end': 92,
+    'pause_break': 96,
+    'page_up': 97,
+    'page_down': 98,
+}
+
+SIXTY_KEYS = {
+    'escape': 1,
+    'tab': 2,
+    'caps_lock': 3,
+    'left_shift': 4,
+    'left_control': 5,
+    '1': 7,
+    'q': 8,
+    'a': 9,
+    'iso_back_slash': 10,
+    '2': 13,
+    'w': 14,
+    's': 15,
+    'z': 16,
+    'left_windows': 17,
+    '3': 19,
+    'e': 20,
+    'd': 21,
+    'x': 22,
+    'left_alt': 23,
+    '4': 25,
+    'r': 26,
+    'f': 27,
+    'c': 28,
+    '5': 31,
+    't': 32,
+    'g': 33,
+    'v': 34,
+    '6': 37,
+    'y': 38,
+    'h': 39,
+    'b': 40,
+    'space': 41,
+    '7': 43,
+    'u': 44,
+    'j': 45,
+    'n': 46,
+    '8': 49,
+    'i': 50,
+    'k': 51,
+    'm': 52,
+    '9': 55,
+    'o': 56,
+    'l': 57,
+    'comma': 58,
+    '0': 61,
+    'p': 62,
+    'semicolon': 63,
+    'period': 64,
+    'right_alt': 65,
+    'minus': 67,
+    'left_bracket': 68,
+    'quote': 69,
+    'forward_slash': 70,
+    'menu': 71,
+    'equals': 73,
+    'right_bracket': 74,
+    'right_shift': 76,
+    'right_control': 77,
+    'backspace': 79,
+    'pound': 80,
+    'ansi_enter': 81,
+    'right_function': 83,
+}
+

kovarctl/protocol.py

@@ -0,0 +1,247 @@
+"""ROYUAN YC500 lighting protocol (KOVAR keyboards).
+
+Everything here is pure: it builds and parses 64 byte feature report
+payloads but never talks to a device. Byte 0 of a payload is the command.
+
+Most commands carry a checksum in byte 7 (0xFF minus the sum of bytes
+0-6). The LED parameter commands carry it in byte 8 (over bytes 0-7).
+
+Flash: LED parameters (0x07), side light parameters (0x08), the custom
+picture (0x0C) and single custom keys (0x14) are stored in flash. The
+firmware keeps the USB interface busy afterwards and locks up if it
+receives anything during that time. The live color (0x0E) is RAM only.
+"""
+
+from dataclasses import dataclass
+
+from . import layouts
+
+REPORT_LENGTH = 64
+
+CMD_GET_REV = 0x80
+CMD_GET_DEVICE_INFO = 0x8F
+CMD_SET_LED_PARAMS = 0x07
+CMD_GET_LED_PARAMS = 0x87
+CMD_SET_SIDE_PARAMS = 0x08
+CMD_GET_SIDE_PARAMS = 0x88
+CMD_SET_PICTURE = 0x0C
+CMD_GET_PICTURE = 0x8C
+CMD_SET_LIVE_COLOR = 0x0E
+CMD_SET_PICTURE_KEY = 0x14
+
+# Measured on a KOVAR and a KOVAR Wireless (seconds of USB silence needed)
+BUSY_LED_PARAMS = 1.0
+BUSY_PICTURE = 1.4
+BUSY_PICTURE_KEY = 0.15
+
+PICTURE_SLOTS = 128
+PICTURE_SIZE = PICTURE_SLOTS * 3
+PICTURE_FRAMES = 7
+PICTURE_FRAME_SIZE = 56
+PICTURE_PAGE_SIZE = 64
+PICTURE_FRAME_DELAY = 0.02
+
+SPEED_MAX = 4
+BRIGHTNESS_MAX = 4
+
+OPTION_USER_COLOR = 0x07
+OPTION_RAINBOW = 0x08
+OPTION_CUSTOM_SLOT_1 = 0x00
+
+EFFECT_OFF = 0x00
+EFFECT_CUSTOM = 0x0D
+EFFECT_LIVE = 0x15
+
+# The firmware does not take pure white as a user color
+WHITE = (0xFF, 0xFF, 0xFF)
+WHITE_SUBSTITUTE = (0xFA, 0xFF, 0xFA)
+
+PRESET_COLORS = [
+    (0xFF, 0x00, 0x00), (0xFF, 0x80, 0x00), (0xFF, 0xFF, 0x00), (0x00, 0xFF, 0x00),
+    (0x00, 0xFF, 0xFF), (0x00, 0x00, 0xFF), (0xFF, 0x00, 0xFF),
+]
+
+
+@dataclass(frozen=True)
+class Effect:
+    name: str
+    value: int
+    speed: bool = True
+    color: bool = True
+    # Direction names in the order of their option value (high nibble)
+    directions: tuple = ()
+
+
+EFFECTS = [
+    Effect("off", EFFECT_OFF, speed=False, color=False),
+    Effect("static", 0x01, speed=False),
+    Effect("breathing", 0x02),
+    Effect("spectrum-cycle", 0x03, color=False),
+    Effect("wave", 0x04, directions=("right", "left", "down", "up")),
+    Effect("ripple", 0x05),
+    Effect("raindrop", 0x06),
+    Effect("snake", 0x07),
+    Effect("reactive", 0x08),
+    Effect("converge", 0x09),
+    Effect("sine-wave", 0x0A),
+    Effect("kaleidoscope", 0x0B),
+    Effect("line-wave", 0x0C, directions=("right", "left")),
+    Effect("custom", EFFECT_CUSTOM, speed=False, color=False),
+    Effect("laser", 0x0E),
+    Effect("circle-wave", 0x0F, directions=("anticlockwise", "clockwise")),
+    Effect("dazzling", 0x10),
+    Effect("rain-down", 0x11),
+    Effect("meteor", 0x12),
+    Effect("reactive-off", 0x13),
+    Effect("live", EFFECT_LIVE, speed=False, color=False),
+]
+
+SIDE_EFFECTS = [effect for effect in EFFECTS if effect.value in (0x00, 0x01, 0x02, 0x03)]
+
+EFFECTS_BY_NAME = {effect.name: effect for effect in EFFECTS}
+EFFECTS_BY_VALUE = {effect.value: effect for effect in EFFECTS}
+
+
+@dataclass(frozen=True)
+class Model:
+    device_id: int
+    name: str
+    keys: dict
+    side_light: bool
+
+
+MODELS = {
+    738: Model(738, "KOVAR", layouts.FULL_KEYS, True),
+    723: Model(723, "KOVAR Wireless", layouts.FULL_KEYS, True),
+    737: Model(737, "KOVAR TKL", layouts.TKL_KEYS, False),
+    736: Model(736, "KOVAR 60", layouts.SIXTY_KEYS, False),
+}
+
+
+@dataclass(frozen=True)
+class LightState:
+    """Decoded LED or side light parameters. Speed 0 is slowest."""
+
+    effect: int
+    speed: int
+    brightness: int
+    option: int
+    color: tuple
+
+    @property
+    def rainbow(self):
+        return (self.option & 0x0F) == OPTION_RAINBOW
+
+    @property
+    def variant(self):
+        return self.option >> 4
+
+    @property
+    def effective_color(self):
+        preset = self.option & 0x0F
+        if preset < len(PRESET_COLORS):
+            return PRESET_COLORS[preset]
+        if self.color == WHITE_SUBSTITUTE:
+            return WHITE
+        return self.color
+
+
+def checksum(data):
+    return (0xFF - (sum(data) & 0xFF)) & 0xFF
+
+
+def payload(*values, checksum_at=7):
+    """Build a payload from leading bytes and add the checksum."""
+    buffer = bytearray(REPORT_LENGTH)
+    buffer[:len(values)] = bytes(values)
+    if checksum_at is not None:
+        buffer[checksum_at] = checksum(buffer[:checksum_at])
+    return bytes(buffer)
+
+
+def query(command):
+    return payload(command)
+
+
+def led_params(effect, speed, brightness, option, color, side=False):
+    """SET_LEDPARAM (keys) or SET_SLEDPARAM (side light).
+
+    The keys take the speed reversed (0 is fastest), the side light does not.
+    """
+    if not 0 <= speed <= SPEED_MAX or not 0 <= brightness <= BRIGHTNESS_MAX:
+        raise ValueError("speed and brightness must be between 0 and 4")
+    if tuple(color) == WHITE:
+        color = WHITE_SUBSTITUTE
+    raw_speed = speed if side else SPEED_MAX - speed
+    command = CMD_SET_SIDE_PARAMS if side else CMD_SET_LED_PARAMS
+    return payload(command, effect, raw_speed, brightness, option, *color, checksum_at=8)
+
+
+def parse_led_params(response, side=False):
+    """Decode a GET_LEDPARAM / GET_SLEDPARAM response (64 bytes, command first)."""
+    expected = CMD_GET_SIDE_PARAMS if side else CMD_GET_LED_PARAMS
+    if response[0] != expected:
+        raise ValueError(f"unexpected response 0x{response[0]:02X}")
+    raw_speed = min(response[2], SPEED_MAX)
+    speed = raw_speed if side else SPEED_MAX - raw_speed
+    return LightState(response[1], speed, min(response[3], BRIGHTNESS_MAX), response[4], tuple(response[5:8]))
+
+
+def state_bytes(state, side=False):
+    """The bytes of a SET payload that matter when comparing with a read back state."""
+    return led_params(state.effect, state.speed, state.brightness, state.option, state.color, side)[:8]
+
+
+def live_color(color):
+    return payload(CMD_SET_LIVE_COLOR, *color)
+
+
+def picture_frames(picture):
+    """SET_USERPIC frames for a full 384 byte picture."""
+    if len(picture) != PICTURE_SIZE:
+        raise ValueError(f"picture must be {PICTURE_SIZE} bytes")
+    data = bytes(picture).ljust(PICTURE_FRAMES * PICTURE_FRAME_SIZE, b"\0")
+    frames = []
+    for frame in range(PICTURE_FRAMES):
+        header = payload(CMD_SET_PICTURE, 0x00, PICTURE_SIZE & 0xFF, PICTURE_SIZE >> 8, frame)
+        chunk = data[frame * PICTURE_FRAME_SIZE:(frame + 1) * PICTURE_FRAME_SIZE]
+        frames.append(header[:8] + chunk)
+    return frames
+
+
+def picture_page_request(page):
+    return payload(CMD_GET_PICTURE, 0x00, page)
+
+
+def picture_key(slot, color, layer=0):
+    """SET_USERPIC_SIMPLE: one key of the custom picture."""
+    buffer = bytearray(payload(CMD_SET_PICTURE_KEY, layer, slot))
+    buffer[8:11] = bytes(color)
+    return bytes(buffer)
+
+
+def parse_device_id(response):
+    if response[0] != CMD_GET_DEVICE_INFO:
+        raise ValueError(f"unexpected response 0x{response[0]:02X}")
+    return int.from_bytes(response[1:5], "little")
+
+
+def parse_color(text):
+    """Parse 'ff8000', '#FF8000' or a few names into an (r, g, b) tuple."""
+    names = {
+        "black": (0, 0, 0), "off": (0, 0, 0), "white": WHITE, "red": (255, 0, 0),
+        "green": (0, 255, 0), "blue": (0, 0, 255), "yellow": (255, 255, 0),
+        "cyan": (0, 255, 255), "magenta": (255, 0, 255), "orange": (255, 128, 0),
+    }
+    text = text.strip().lower()
+    if text in names:
+        return names[text]
+    text = text.removeprefix("#").removeprefix("0x")
+    if len(text) != 6:
+        raise ValueError(f"not a color: {text!r}")
+    value = int(text, 16)
+    return (value >> 16, (value >> 8) & 0xFF, value & 0xFF)
+
+
+def format_color(color):
+    return "#{:02X}{:02X}{:02X}".format(*color)

kovarctl-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: kovarctl
+Version: 0.1.0
+Summary: Control the lighting of KOVAR keyboards (ROYUAN YC500 firmware) on Linux
+Author-email: Lars Kiesow <lkiesow@uos.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lkiesow/kovarctl
+Project-URL: Issues, https://github.com/lkiesow/kovarctl/issues
+Keywords: kovar,keyboard,rgb,lighting,hidraw
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8
+Dynamic: license-file
+
+# kovarctl
+
+Command line tool for the lighting of KOVAR keyboards (ROYUAN YC500 firmware, USB ID `3151:4010`) on Linux.
+
+Supported models, identified by the firmware model ID:
+
+| ID  | Model                       | Tested |
+|-----|-----------------------------|--------|
+| 738 | KOVAR                       | yes    |
+| 723 | KOVAR Wireless (USB cable)  | yes    |
+| 737 | KOVAR TKL                   | no     |
+| 736 | KOVAR 60                    | no     |
+
+The 2.4 GHz dongle (`3151:4011`) is not supported, because it uses a different protocol. Connect the keyboard with a USB cable instead.
+
+## Installation
+
+```sh
+pipx install kovarctl
+```
+
+`pip install --user kovarctl` and `uv tool install kovarctl` work as well.
+
+The only dependency is [click](https://click.palletsprojects.com/). Your user needs access to the keyboard's `/dev/hidraw*` nodes. Desktop sessions usually grant it, and the OpenRGB udev rules do too.
+
+## Usage
+
+```sh
+kovarctl list                                    # connected keyboards
+kovarctl info                                    # model, firmware, current lighting
+kovarctl effects                                 # effects and their options
+kovarctl mode wave --direction left --color 00ffff
+kovarctl mode breathing --speed 3                # options not given stay as they are
+kovarctl mode static --rainbow
+kovarctl off
+kovarctl side breathing --color red              # side light
+kovarctl live ff8000                             # one color for all keys, no flash write
+kovarctl live --fade 30                          # rainbow fade for 30 s
+some-program | kovarctl live --stdin             # one color per line
+kovarctl keys                                    # key names
+kovarctl custom set escape=red w=green --activate
+kovarctl custom set all=000040
+kovarctl custom save picture.json
+kovarctl custom load picture.json --activate
+kovarctl recover                                 # if the keyboard stopped answering
+```
+
+Use `--dry-run` to see what would be written, `-v` to report flash writes, and `--device` or `--id` to choose a keyboard when several are connected.
+
+## Shell completion
+
+kovarctl can complete commands, effect names and option values such as `--direction`. This needs the installed `kovarctl` command; it does not work with `python3 -m kovarctl`.
+
+**Bash** (version 4.4 or newer), add to `~/.bashrc`:
+
+```sh
+eval "$(_KOVARCTL_COMPLETE=bash_source kovarctl)"
+```
+
+**Zsh**, add to `~/.zshrc` after `compinit` has run (frameworks like Oh My Zsh run it for you):
+
+```sh
+eval "$(_KOVARCTL_COMPLETE=zsh_source kovarctl)"
+```
+
+**Fish**, add to `~/.config/fish/config.fish`:
+
+```sh
+_KOVARCTL_COMPLETE=fish_source kovarctl | source
+```
+
+Open a new shell afterwards. The completion is generated each time a shell starts (about 30 ms), so it always matches the installed version.
+
+## Keyboard flash
+
+The keyboard stores effect settings, the side light and the custom picture in its flash memory. Each write keeps the firmware busy for up to 1.4 seconds. During that time the keyboard ignores requests and can even lock up its lighting interface. kovarctl protects the keyboard in four ways:
+
+- It reads the current state first and skips writes that change nothing.
+- It waits until the keyboard is idle before sending anything, including across separate kovarctl calls.
+- It refuses more than 12 flash writes per minute unless you pass `--force`.
+- It refuses to run while another program, such as OpenRGB, has the keyboard open.
+
+For colors that change often, use `live`. Only switching into live mode is a flash write; after that, colors can change as often as you like.
+
+The blue LED between Esc and F1 cannot be controlled.
+
+## Development
+
+Install from a checkout of the repository and run the tests:
+
+```sh
+pip install -e . pytest
+python3 -m pytest
+```
+
+## License
+
+MIT, see [LICENSE](https://github.com/lkiesow/kovarctl/blob/main/LICENSE).
+
+## Releasing
+
+1. Set the new version in `pyproject.toml`, commit and tag it:
+
+   ```sh
+   git commit -am 'Release 0.2.0'
+   git tag v0.2.0
+   ```
+
+2. Build the packages and check them, in a virtual environment:
+
+   ```sh
+   rm -rf dist/
+   python3 -m build
+   twine check --strict dist/*
+   ```
+
+3. Upload to [PyPI](https://pypi.org/project/kovarctl/) and push the tag:
+
+   ```sh
+   twine upload dist/*
+   git push origin main v0.2.0
+   ```

kovarctl-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+kovarctl/__init__.py,sha256=XMnlKhwCwCPfyzMtlCERcvBQA5fBMP2Lg6lUiaJF-r0,71
+kovarctl/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+kovarctl/cli.py,sha256=h-8hPyM1zYjiNFo_Aw8Bxb3DRK1iK6-vC9I6h55ur8w,16263
+kovarctl/device.py,sha256=S16FK-Var86Z4yaVa-VqIgpEIML6B_4UdvfSq2eL5lM,9655
+kovarctl/layouts.py,sha256=8_nFxLSufyfz80WFdc2FTQwVgcGZ4nFmTnTbDIyJ_go,4570
+kovarctl/protocol.py,sha256=qWy7KV4EdzPloCWlbGZGof2QZ-Y0fguMPagNbNuqvXY,7658
+kovarctl-0.1.0.dist-info/licenses/LICENSE,sha256=4guhcrbie02tYRBGzNZfHykrZ__5Pglwh4hcFgGoPpA,1068
+kovarctl-0.1.0.dist-info/METADATA,sha256=Rv8GPpJRcYXiEcvVfjodE3xOMuT96jYs3R30atgLNjM,5054
+kovarctl-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+kovarctl-0.1.0.dist-info/entry_points.txt,sha256=QG2Xb3x-KpgY2SkR8SCTkUYiLzkZFw05bsdCr4CuulU,47
+kovarctl-0.1.0.dist-info/top_level.txt,sha256=qvghpK7hRjuXCXy_fEkF0-Bql4e70ax7UaZL-oJ_Qas,9
+kovarctl-0.1.0.dist-info/RECORD,,

kovarctl-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kovarctl-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kovarctl = kovarctl.cli:main

kovarctl-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lars Kiesow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.