pych9329 0.1.5__tar.gz

pych9329-0.1.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wevsty
+
+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.

pych9329-0.1.5/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.3
+Name: pych9329
+Version: 0.1.5
+Summary: Python module to control the ch9329
+License: MIT
+Author: wevsty
+Author-email: ty@wevs.org
+Requires-Python: >3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pyserial (>=3.5,<4.0)
+Project-URL: Repository, https://github.com/wevsty/pych9329
+Description-Content-Type: text/markdown
+
+# pych9329
+Python module to control ch9329
+
+## Installation
+
+You can install the package via pip:
+
+```bash
+pip install pych9329
+```
+
+## Usage
+
+```py
+from serial import Serial
+
+from pych9329 import keyboard
+from pych9329 import mouse
+from pych9329.chip_command import get_manufacturer
+from pych9329.chip_command import get_product
+from pych9329.chip_command import get_serial_number
+
+
+def main():
+    ser = Serial("COM10", 9600, timeout=0.50)
+
+    keyboard.click(ser, "a")
+    keyboard.click(ser, "A")
+    keyboard.send_text_data(ser, "\n")
+    keyboard.send_text_data(ser, "Hello World\n")
+    keyboard.send_text_data(ser, "abcdefghijklmnopqrstuvwxyz\n")
+    keyboard.send_text_data(ser, "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n")
+    keyboard.send_text_data(ser, "0123456789\n")
+    keyboard.send_text_data(ser, "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n")
+
+    mouse.move(ser, x=500, y=500)
+    mouse.move(ser, x=50, y=50, relative_mode=True)
+    # For supported key names, please see mouse.MOUSE_BUTTON_NAME_MAP
+    mouse.click(ser, button_name="left")
+
+    # 2019A152BB40
+    print(get_serial_number(ser))
+    # WCH UART TO KB-MS_V1.8
+    print(get_product(ser))
+    # WWW.WCH.CN
+    print(get_manufacturer(ser))
+    ser.close()
+
+
+if __name__ == "__main__":
+    main()
+
+```
+
+## License
+
+MIT license.
+
+## Contributing
+
+This project is modified from ch9329 library.
+
+Thanks to the original author of the ch9329 library [Pradish Bijukchhe](https://github.com/pradishb)
+

pych9329-0.1.5/README.md

@@ -0,0 +1,63 @@
+# pych9329
+Python module to control ch9329
+
+## Installation
+
+You can install the package via pip:
+
+```bash
+pip install pych9329
+```
+
+## Usage
+
+```py
+from serial import Serial
+
+from pych9329 import keyboard
+from pych9329 import mouse
+from pych9329.chip_command import get_manufacturer
+from pych9329.chip_command import get_product
+from pych9329.chip_command import get_serial_number
+
+
+def main():
+    ser = Serial("COM10", 9600, timeout=0.50)
+
+    keyboard.click(ser, "a")
+    keyboard.click(ser, "A")
+    keyboard.send_text_data(ser, "\n")
+    keyboard.send_text_data(ser, "Hello World\n")
+    keyboard.send_text_data(ser, "abcdefghijklmnopqrstuvwxyz\n")
+    keyboard.send_text_data(ser, "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n")
+    keyboard.send_text_data(ser, "0123456789\n")
+    keyboard.send_text_data(ser, "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n")
+
+    mouse.move(ser, x=500, y=500)
+    mouse.move(ser, x=50, y=50, relative_mode=True)
+    # For supported key names, please see mouse.MOUSE_BUTTON_NAME_MAP
+    mouse.click(ser, button_name="left")
+
+    # 2019A152BB40
+    print(get_serial_number(ser))
+    # WCH UART TO KB-MS_V1.8
+    print(get_product(ser))
+    # WWW.WCH.CN
+    print(get_manufacturer(ser))
+    ser.close()
+
+
+if __name__ == "__main__":
+    main()
+
+```
+
+## License
+
+MIT license.
+
+## Contributing
+
+This project is modified from ch9329 library.
+
+Thanks to the original author of the ch9329 library [Pradish Bijukchhe](https://github.com/pradishb)

pych9329-0.1.5/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "pych9329"
+version = "0.1.5"
+description = "Python module to control the ch9329"
+authors = ["wevsty <ty@wevs.org>"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/wevsty/pych9329"
+
+[tool.poetry.dependencies]
+python = ">3.10"
+pyserial = "^3.5"
+
+[tool.poetry.group.dev.dependencies]
+black = "^25.1.0"
+isort = "^6.0.1"
+pytest = "^8.3.5"
+pytest-mock = "^3.14.0"
+pytest-datadir = "^1.6.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

pych9329-0.1.5/src/pych9329/chip_command.py

@@ -0,0 +1,200 @@
+from enum import Enum
+
+from serial import Serial
+
+import pych9329.exceptions as exceptions
+import pych9329.frame_utils as frame_utils
+from pych9329.struct_utils import Structure
+
+
+class ChipParameter(Structure):
+    _fields_ = [
+        ('c', 'work_mode'),
+        ('c', 'serial_communication_mode'),
+        ('c', 'serial_address'),
+        ('>I', 'serial_baud_rate'),
+        ('>H', 'reserve_00'),
+        ('>H', 'communication_packet_interval'),
+        ('<H', 'usb_vid'),
+        ('<H', 'usb_pid'),
+        ('>H', 'keyboard_upload_interval'),
+        ('>H', 'keyboard_release_delay'),
+        ('>H', 'keyboard_auto_enter_flag'),
+        ('4s', 'keyboard_enter_data_1'),
+        ('4s', 'keyboard_enter_data_2'),
+        ('4s', 'keyboard_filtering_start'),
+        ('c', 'usb_string_descriptor_flag'),
+        ('4s', 'keyboard_fast_upload_flag'),
+        ('12s', 'reserve_01'),
+    ]
+
+
+def get_chip_parameters(serial_object: Serial) -> ChipParameter:
+    # request frame
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x08',
+        b'\x00',
+        b'',
+    )
+    request_packet = data_frame.create_frame()
+    serial_object.write(request_packet)
+    serial_object.flush()
+    # Reply frame should be 56 bytes
+    reply_length = 56
+    reply_buffer = serial_object.read(reply_length)
+    result = data_frame.parse_frame(reply_buffer)
+    if result is False:
+        raise exceptions.ProtocolError('parser buffer error')
+    chip_parameter = ChipParameter.from_buffer(data_frame.get_data())
+    return chip_parameter
+
+
+def set_chip_parameters(serial_object: Serial, parameter: ChipParameter) -> bool:
+    parameter.buffer_flush()
+    parameter_buffer = parameter.buffer
+    # request frame
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x09',
+        b'\x00',
+        b'\x00',
+    )
+    data_frame.set_data(parameter_buffer)
+    request_packet = data_frame.create_frame()
+    serial_object.write(request_packet)
+    serial_object.flush()
+    # Reply frame should be 7 bytes
+    reply_length = 7
+    reply_buffer = serial_object.read(reply_length)
+    result = data_frame.parse_frame(reply_buffer)
+    if result is False:
+        raise exceptions.ProtocolError('parser buffer error')
+    reply_data = data_frame.get_data()
+    if reply_data == frame_utils.DataFrameStatus.SUCCESS.value:
+        return True
+    return False
+
+
+class USBStringSubCommand(Enum):
+    MANUFACTURER = b'\x00'
+    PRODUCT = b'\x01'
+    SERIAL_NUMBER = b'\x02'
+
+
+def get_usb_string_info(serial_object: Serial, sub_command: bytes) -> str:
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x0a',
+        b'\x01',
+        sub_command,
+    )
+    request_packet = data_frame.create_frame()
+    serial_object.readall()
+    serial_object.write(request_packet)
+    serial_object.flush()
+    reply_buffer = serial_object.readall()
+    result = data_frame.parse_frame(reply_buffer)
+    if result is False:
+        raise exceptions.ProtocolError('parser buffer error')
+    if data_frame.get_data_length() < 2:
+        raise exceptions.ProtocolError('parser buffer error')
+    data_buffer = data_frame.get_data()
+    # string_length = data_buffer[1]
+    string_bytes = data_buffer[2:]
+    # usb_info = string_bytes.decode('utf-8', 'ignore')
+    try:
+        usb_info = string_bytes.decode('utf-8')
+    except UnicodeDecodeError:
+        raise exceptions.InvalidStringEncoding('unable decode string')
+    return usb_info
+
+
+def set_usb_string_info(
+    serial_object: Serial, sub_command: bytes, string_info: str
+) -> bool:
+    info_data = string_info.encode('utf-8')
+    if len(info_data) > 23:
+        raise InvalidStringLength('string too long')
+    data_buffer = (
+        sub_command + int.to_bytes(len(info_data), byteorder='big') + info_data
+    )
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x0b',
+        b'',
+        b'',
+    )
+    data_frame.set_data(data_buffer)
+    request_packet = data_frame.create_frame()
+    serial_object.readall()
+    serial_object.write(request_packet)
+    serial_object.flush()
+    reply_buffer = serial_object.readall()
+    result = data_frame.parse_frame(reply_buffer)
+    if result is False:
+        raise exceptions.ProtocolError('parser buffer error')
+    reply_data = data_frame.get_data()
+    if reply_data == frame_utils.DataFrameStatus.SUCCESS.value:
+        return True
+    return False
+
+
+def get_serial_number(serial_object: Serial) -> str:
+    return get_usb_string_info(serial_object, USBStringSubCommand.SERIAL_NUMBER.value)
+
+
+def set_serial_number(serial_object: Serial, string_data: str):
+    return set_usb_string_info(
+        serial_object, USBStringSubCommand.SERIAL_NUMBER.value, string_data
+    )
+
+
+def get_manufacturer(serial_object: Serial) -> str:
+    return get_usb_string_info(serial_object, USBStringSubCommand.MANUFACTURER.value)
+
+
+def set_manufacturer(serial_object: Serial, string_data: str):
+    return set_usb_string_info(
+        serial_object, USBStringSubCommand.MANUFACTURER.value, string_data
+    )
+
+
+def get_product(serial_object: Serial) -> str:
+    return get_usb_string_info(serial_object, USBStringSubCommand.PRODUCT.value)
+
+
+def set_product(serial_object: Serial, string_data: str):
+    return set_usb_string_info(
+        serial_object, USBStringSubCommand.PRODUCT.value, string_data
+    )
+
+
+def send_command_reset(serial_object: Serial) -> None:
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x0f',
+        b'\x00',
+        b'',
+    )
+    request_packet = data_frame.create_frame()
+    serial_object.write(request_packet)
+
+def send_command_restore_factory_config(serial_object: Serial) -> None:
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x0c',
+        b'\x00',
+        b'',
+    )
+    request_packet = data_frame.create_frame()
+    serial_object.write(request_packet)
+
+if __name__ == '__main__':
+    pass

pych9329-0.1.5/src/pych9329/exceptions.py

@@ -0,0 +1,50 @@
+class ChipBaseException(Exception):
+    pass
+
+
+# 协议错误
+class ProtocolError(ChipBaseException):
+    pass
+
+
+# 无效的字符串编码
+class InvalidStringEncoding(ChipBaseException):
+    pass
+
+
+# 无效的字符串长度
+class InvalidStringLength(ChipBaseException):
+    pass
+
+
+# 无效的坐标值
+class InvalidCoordinateValue(ChipBaseException):
+    pass
+
+
+# 无效的滚轮值
+class InvalidWheelValue(ChipBaseException):
+    pass
+
+
+# 无效的特殊按键
+class InvalidModifierKey(ChipBaseException):
+    pass
+
+
+# 无效的按键
+class InvalidKey(ChipBaseException):
+    pass
+
+
+# 传入太多按键
+class TooManyKeys(ChipBaseException):
+    pass
+
+
+# 缓冲区太小
+class BufferTooSmall(ChipBaseException):
+    pass
+
+if __name__ == '__main__':
+    pass

pych9329-0.1.5/src/pych9329/frame_utils.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class DataFrameStatus(Enum):
+    SUCCESS = b'\x00'
+    ERROR_TIMEOUT = b'\xe1'
+    ERROR_HEAD = b'\xe2'
+    ERROR_CMD = b'\xe3'
+    ERROR_SUM = b'\xe4'
+    ERROR_PARA = b'\xe5'
+    ERROR_OPERATE = b'\xe6'
+
+
+@dataclass
+class DataFrame:
+    HEAD: bytes
+    ADDR: bytes
+    CMD: bytes
+    LEN: bytes = b'\x00'
+    DATA: bytes = b''
+
+    def create_frame(self) -> bytes:
+        checksum = self.calc_checksum()
+        frame = (
+            self.HEAD + self.ADDR + self.CMD + self.LEN + self.DATA + bytes([checksum])
+        )
+        return frame
+
+    def get_data(self) -> bytes:
+        return self.DATA
+
+    def get_data_length(self) -> int:
+        length = int.from_bytes(self.LEN, byteorder='big')
+        return length
+
+    def set_data(self, data: bytes) -> None:
+        self.DATA = data
+        self.set_data_length(len(data))
+
+    def set_data_length(self, length: int) -> None:
+        self.LEN = int.to_bytes(length, byteorder='big')
+
+    def calc_frame_length(self, buffer: bytes) -> int:
+        header_size = 5
+        frame_length = 0
+        buffer_length = len(buffer)
+        if buffer_length < header_size:
+            return frame_length
+        head_first = buffer[0:1]
+        head_last = buffer[1:2]
+        self.ADDR = buffer[2:3]
+        self.CMD = buffer[3:4]
+        self.LEN = buffer[4:5]
+        self.HEAD = head_first + head_last
+        data_length = self.get_data_length()
+        frame_length = header_size + data_length + 1
+        return frame_length
+
+    def calc_checksum(self) -> int:
+        head_list = list(self.HEAD)
+        head_sum = sum(head_list)
+        data_list = list(self.DATA)
+        data_sum = sum(data_list)
+        checksum = (
+            sum(
+                [
+                    head_sum,
+                    int.from_bytes(self.ADDR, byteorder='big'),
+                    int.from_bytes(self.CMD, byteorder='big'),
+                    int.from_bytes(self.LEN, byteorder='big'),
+                    data_sum,
+                ]
+            )
+            % 256
+        )
+        return checksum
+
+    def parse_frame(self, buffer: bytes) -> bool:
+        header_size = 5
+        parse_result = False
+        buffer_length = len(buffer)
+        if buffer_length < header_size:
+            return parse_result
+        frame_length = self.calc_frame_length(buffer)
+        if buffer_length < frame_length:
+            return parse_result
+        data_length = self.get_data_length()
+        if data_length >= 0:
+            self.DATA = buffer[header_size : header_size + data_length]
+            _checksum = buffer[
+                header_size + data_length : header_size + data_length + 1
+            ]
+            parse_result = True
+        return parse_result
+
+
+if __name__ == '__main__':
+    pass

pych9329-0.1.5/src/pych9329/hid_code_map.py

@@ -0,0 +1,190 @@
+import pych9329.hid_code_table as hid_code
+
+HID_CODE_MAP = {
+    '': (hid_code.KEY_NONE, False),
+    # release alias
+    'null': (hid_code.KEY_NONE, False),
+    'none': (hid_code.KEY_NONE, False),
+    'a': (hid_code.KEY_A, False),
+    'b': (hid_code.KEY_B, False),
+    'c': (hid_code.KEY_C, False),
+    'd': (hid_code.KEY_D, False),
+    'e': (hid_code.KEY_E, False),
+    'f': (hid_code.KEY_F, False),
+    'g': (hid_code.KEY_G, False),
+    'h': (hid_code.KEY_H, False),
+    'i': (hid_code.KEY_I, False),
+    'j': (hid_code.KEY_J, False),
+    'k': (hid_code.KEY_K, False),
+    'l': (hid_code.KEY_L, False),
+    'm': (hid_code.KEY_M, False),
+    'n': (hid_code.KEY_N, False),
+    'o': (hid_code.KEY_O, False),
+    'p': (hid_code.KEY_P, False),
+    'q': (hid_code.KEY_Q, False),
+    'r': (hid_code.KEY_R, False),
+    's': (hid_code.KEY_S, False),
+    't': (hid_code.KEY_T, False),
+    'u': (hid_code.KEY_U, False),
+    'v': (hid_code.KEY_V, False),
+    'w': (hid_code.KEY_W, False),
+    'x': (hid_code.KEY_X, False),
+    'y': (hid_code.KEY_Y, False),
+    'z': (hid_code.KEY_Z, False),
+    '1': (hid_code.KEY_1, False),
+    '2': (hid_code.KEY_2, False),
+    '3': (hid_code.KEY_3, False),
+    '4': (hid_code.KEY_4, False),
+    '5': (hid_code.KEY_5, False),
+    '6': (hid_code.KEY_6, False),
+    '7': (hid_code.KEY_7, False),
+    '8': (hid_code.KEY_8, False),
+    '9': (hid_code.KEY_9, False),
+    '0': (hid_code.KEY_0, False),
+    'enter': (hid_code.KEY_ENTER, False),
+    'esc': (hid_code.KEY_ESCAPE, False),
+    'escape': (hid_code.KEY_ESCAPE, False),
+    'backspace': (hid_code.KEY_BACKSPACE, False),
+    'tab': (hid_code.KEY_TAB, False),
+    'space': (hid_code.KEY_SPACE, False),
+    'bracket_left': (hid_code.KEY_BRACKET_LEFT, False),
+    'bracket_right': (hid_code.KEY_BRACKET_RIGHT, False),
+    'backslash': (hid_code.KEY_CODE_29, False),
+    # 'europe_1': (hid_code.KEY_EUROPE_1, False),
+    'semicolon': (hid_code.KEY_SEMICOLON, False),
+    'apostrophe': (hid_code.KEY_APOSTROPHE, False),
+    'grave': (hid_code.KEY_GRAVE, False),
+    'comma': (hid_code.KEY_COMMA, False),
+    'period': (hid_code.KEY_PERIOD, False),
+    'slash': (hid_code.KEY_SLASH, False),
+    'caps_lock': (hid_code.KEY_CAPS_LOCK, False),
+    'f1': (hid_code.KEY_F1, False),
+    'f2': (hid_code.KEY_F2, False),
+    'f3': (hid_code.KEY_F3, False),
+    'f4': (hid_code.KEY_F4, False),
+    'f5': (hid_code.KEY_F5, False),
+    'f6': (hid_code.KEY_F6, False),
+    'f7': (hid_code.KEY_F7, False),
+    'f8': (hid_code.KEY_F8, False),
+    'f9': (hid_code.KEY_F9, False),
+    'f10': (hid_code.KEY_F10, False),
+    'f11': (hid_code.KEY_F11, False),
+    'f12': (hid_code.KEY_F12, False),
+    'print_screen': (hid_code.KEY_PRINT_SCREEN, False),
+    'scroll_lock': (hid_code.KEY_SCROLL_LOCK, False),
+    'pause': (hid_code.KEY_PAUSE, False),
+    'insert': (hid_code.KEY_INSERT, False),
+    'home': (hid_code.KEY_HOME, False),
+    'page_up': (hid_code.KEY_PAGE_UP, False),
+    'delete': (hid_code.KEY_DELETE, False),
+    'del': (hid_code.KEY_DELETE, False),
+    'end': (hid_code.KEY_END, False),
+    'page_down': (hid_code.KEY_PAGE_DOWN, False),
+    'arrow_right': (hid_code.KEY_ARROW_RIGHT, False),
+    'arrow_left': (hid_code.KEY_ARROW_LEFT, False),
+    'arrow_down': (hid_code.KEY_ARROW_DOWN, False),
+    'arrow_up': (hid_code.KEY_ARROW_UP, False),
+    'right': (hid_code.KEY_ARROW_RIGHT, False),
+    'left': (hid_code.KEY_ARROW_LEFT, False),
+    'down': (hid_code.KEY_ARROW_DOWN, False),
+    'up': (hid_code.KEY_ARROW_UP, False),
+    'num_lock': (hid_code.KEY_NUM_LOCK, False),
+    'keypad_divide': (hid_code.KEY_KEYPAD_DIVIDE, False),
+    'keypad_multiply': (hid_code.KEY_KEYPAD_MULTIPLY, False),
+    'keypad_subtract': (hid_code.KEY_KEYPAD_SUBTRACT, False),
+    'keypad_add': (hid_code.KEY_KEYPAD_ADD, False),
+    'keypad_enter': (hid_code.KEY_KEYPAD_ENTER, False),
+    'keypad_1': (hid_code.KEY_KEYPAD_1, False),
+    'keypad_2': (hid_code.KEY_KEYPAD_2, False),
+    'keypad_3': (hid_code.KEY_KEYPAD_3, False),
+    'keypad_4': (hid_code.KEY_KEYPAD_4, False),
+    'keypad_5': (hid_code.KEY_KEYPAD_5, False),
+    'keypad_6': (hid_code.KEY_KEYPAD_6, False),
+    'keypad_7': (hid_code.KEY_KEYPAD_7, False),
+    'keypad_8': (hid_code.KEY_KEYPAD_8, False),
+    'keypad_9': (hid_code.KEY_KEYPAD_9, False),
+    'keypad_0': (hid_code.KEY_KEYPAD_0, False),
+    'keypad_decimal': (hid_code.KEY_KEYPAD_DECIMAL, False),
+    # modifiers
+    'ctrl': (hid_code.KEY_CTRL_L, False),
+    'ctrl_left': (hid_code.KEY_CTRL_L, False),
+    'ctrl_right': (hid_code.KEY_CTRL_R, False),
+    'shift': (hid_code.KEY_SHIFT_L, False),
+    'shift_left': (hid_code.KEY_SHIFT_L, False),
+    'shift_right': (hid_code.KEY_SHIFT_R, False),
+    'alt': (hid_code.KEY_ALT_L, False),
+    'alt_left': (hid_code.KEY_ALT_L, False),
+    'alt_right': (hid_code.KEY_ALT_R, False),
+    'win': (hid_code.KEY_WIN_L, False),
+    'win_left': (hid_code.KEY_WIN_L, False),
+    'win_right': (hid_code.KEY_WIN_R, False),
+    'win_app': (hid_code.KEY_WIN_APP, False),
+    'gui': (hid_code.KEY_WIN_L, False),
+    'gui_left': (hid_code.KEY_WIN_L, False),
+    'gui_right': (hid_code.KEY_WIN_R, False),
+    # white spaces
+    ' ': (hid_code.KEY_SPACE, False),
+    '\t': (hid_code.KEY_TAB, False),
+    '\n': (hid_code.KEY_ENTER, False),
+    # symbols
+    '-': (hid_code.KEY_MINUS, False),
+    '=': (hid_code.KEY_EQUAL, False),
+    '[': (hid_code.KEY_BRACKET_LEFT, False),
+    ']': (hid_code.KEY_BRACKET_RIGHT, False),
+    '\\': (hid_code.KEY_CODE_29, False),
+    ';': (hid_code.KEY_SEMICOLON, False),
+    '\'': (hid_code.KEY_APOSTROPHE, False),
+    '`': (hid_code.KEY_GRAVE, False),
+    ',': (hid_code.KEY_COMMA, False),
+    '.': (hid_code.KEY_PERIOD, False),
+    '/': (hid_code.KEY_SLASH, False),
+    # symbols (shift)
+    '^': (hid_code.KEY_6, True),
+    '_': (hid_code.KEY_MINUS, True),
+    '{': (hid_code.KEY_BRACKET_LEFT, True),
+    '|': (hid_code.KEY_CODE_29, True),
+    '}': (hid_code.KEY_BRACKET_RIGHT, True),
+    '~': (hid_code.KEY_GRAVE, True),
+    '!': (hid_code.KEY_1, True),
+    '\"': (hid_code.KEY_APOSTROPHE, True),
+    '#': (hid_code.KEY_3, True),
+    '$': (hid_code.KEY_4, True),
+    '%': (hid_code.KEY_5, True),
+    '&': (hid_code.KEY_7, True),
+    '(': (hid_code.KEY_9, True),
+    ')': (hid_code.KEY_0, True),
+    '*': (hid_code.KEY_8, True),
+    '+': (hid_code.KEY_EQUAL, True),
+    ':': (hid_code.KEY_SEMICOLON, True),
+    '<': (hid_code.KEY_COMMA, True),
+    '>': (hid_code.KEY_PERIOD, True),
+    '?': (hid_code.KEY_SLASH, True),
+    '@': (hid_code.KEY_2, True),
+    # shift keys
+    'A': (hid_code.KEY_A, True),
+    'B': (hid_code.KEY_B, True),
+    'C': (hid_code.KEY_C, True),
+    'D': (hid_code.KEY_D, True),
+    'E': (hid_code.KEY_E, True),
+    'F': (hid_code.KEY_F, True),
+    'G': (hid_code.KEY_G, True),
+    'H': (hid_code.KEY_H, True),
+    'I': (hid_code.KEY_I, True),
+    'J': (hid_code.KEY_J, True),
+    'K': (hid_code.KEY_K, True),
+    'L': (hid_code.KEY_L, True),
+    'M': (hid_code.KEY_M, True),
+    'N': (hid_code.KEY_N, True),
+    'O': (hid_code.KEY_O, True),
+    'P': (hid_code.KEY_P, True),
+    'Q': (hid_code.KEY_Q, True),
+    'R': (hid_code.KEY_R, True),
+    'S': (hid_code.KEY_S, True),
+    'T': (hid_code.KEY_T, True),
+    'U': (hid_code.KEY_U, True),
+    'V': (hid_code.KEY_V, True),
+    'W': (hid_code.KEY_W, True),
+    'X': (hid_code.KEY_X, True),
+    'Y': (hid_code.KEY_Y, True),
+    'Z': (hid_code.KEY_Z, True),
+}

pych9329-0.1.5/src/pych9329/hid_code_table.py

@@ -0,0 +1,161 @@
+KEY_GRAVE = b'\x35'
+KEY_1 = b'\x1e'
+KEY_2 = b'\x1f'
+KEY_3 = b'\x20'
+KEY_4 = b'\x21'
+KEY_5 = b'\x22'
+KEY_6 = b'\x23'
+KEY_7 = b'\x24'
+KEY_8 = b'\x25'
+KEY_9 = b'\x26'
+KEY_0 = b'\x27'
+KEY_MINUS = b'\x2d'
+KEY_EQUAL = b'\x2e'
+KEY_CODE_14 = b'\x89'
+KEY_BACKSPACE = b'\x2a'
+KEY_TAB = b'\x2b'
+KEY_Q = b'\x14'
+KEY_W = b'\x1a'
+KEY_E = b'\x08'
+KEY_R = b'\x15'
+KEY_T = b'\x17'
+KEY_Y = b'\x1c'
+KEY_U = b'\x18'
+KEY_I = b'\x0c'
+KEY_O = b'\x12'
+KEY_P = b'\x13'
+KEY_BRACKET_LEFT = b'\x2f'
+KEY_BRACKET_RIGHT = b'\x30'
+KEY_CODE_29 = b'\x31'  # backslash
+KEY_CAPS_LOCK = b'\x39'
+KEY_A = b'\x04'
+KEY_S = b'\x16'
+KEY_D = b'\x07'
+KEY_F = b'\x09'
+KEY_G = b'\x0a'
+KEY_H = b'\x0b'
+KEY_J = b'\x0d'
+KEY_K = b'\x0e'
+KEY_L = b'\x0f'
+KEY_SEMICOLON = b'\x33'
+KEY_APOSTROPHE = b'\x34'
+KEY_CODE_42 = b'\x32'
+KEY_ENTER = b'\x28'
+KEY_SHIFT_L = b'\xe1'
+KEY_CODE_45 = b'\x64'
+KEY_Z = b'\x1d'
+KEY_X = b'\x1b'
+KEY_C = b'\x06'
+KEY_V = b'\x19'
+KEY_B = b'\x05'
+KEY_N = b'\x11'
+KEY_M = b'\x10'
+KEY_COMMA = b'\x36'
+KEY_PERIOD = b'\x37'
+KEY_SLASH = b'\x38'
+KEY_CODE_56 = b'\x87'  # Unknown
+KEY_SHIFT_R = b'\xe5'
+KEY_CTRL_L = b'\xe0'
+#
+KEY_ALT_L = b'\xe2'
+KEY_SPACE = b'\x2c'
+KEY_ALT_R = b'\xe6'
+#
+KEY_CTRL_R = b'\xe4'
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+KEY_INSERT = b'\x49'
+KEY_DELETE = b'\x4c'
+#
+#
+KEY_ARROW_LEFT = b'\x50'
+KEY_HOME = b'\x4a'
+KEY_END = b'\x4d'
+#
+KEY_ARROW_UP = b'\x52'
+KEY_ARROW_DOWN = b'\x51'
+KEY_PAGE_UP = b'\x4b'
+KEY_PAGE_DOWN = b'\x4e'
+#
+#
+KEY_ARROW_RIGHT = b'\x4f'
+KEY_NUM_LOCK = b'\x53'
+KEY_KEYPAD_7 = b'\x5f'
+KEY_KEYPAD_4 = b'\x5c'
+KEY_KEYPAD_1 = b'\x59'
+#
+KEY_KEYPAD_DIVIDE = b'\x54'
+KEY_KEYPAD_8 = b'\x60'
+KEY_KEYPAD_5 = b'\x5d'
+KEY_KEYPAD_2 = b'\x5a'
+KEY_KEYPAD_0 = b'\x62'
+KEY_KEYPAD_MULTIPLY = b'\x55'
+KEY_KEYPAD_9 = b'\x61'
+KEY_KEYPAD_6 = b'\x5e'
+KEY_KEYPAD_3 = b'\x5b'
+KEY_KEYPAD_DECIMAL = b'\x63'
+KEY_KEYPAD_SUBTRACT = b'\x56'
+KEY_KEYPAD_ADD = b'\x57'
+KEY_CODE_107 = b'\x85'  # Unknown
+KEY_KEYPAD_ENTER = b'\x58'
+#
+KEY_ESCAPE = b'\x29'
+#
+KEY_F1 = b'\x3a'
+KEY_F2 = b'\x3b'
+KEY_F3 = b'\x3c'
+KEY_F4 = b'\x3d'
+KEY_F5 = b'\x3e'
+KEY_F6 = b'\x3f'
+KEY_F7 = b'\x40'
+KEY_F8 = b'\x41'
+KEY_F9 = b'\x42'
+KEY_F10 = b'\x43'
+KEY_F11 = b'\x44'
+KEY_F12 = b'\x45'
+KEY_PRINT_SCREEN = b'\x46'
+KEY_SCROLL_LOCK = b'\x47'
+KEY_PAUSE = b'\x48'
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+# Japanese
+# Japanese
+# Japanese
+# KoreaKC-L
+# KoreaKC-R
+# ACPI
+# ACPI
+# ACPI
+KEY_WIN_L = b'\xe3'
+KEY_WIN_R = b'\xe7'
+KEY_WIN_APP = b'\x65'
+KEY_NONE = b'\x00'
+
+# Reference: CH9329 chip document page 15 'CH9329 Key Code Table'
+# Line number denotes the serial number in the documentation

pych9329-0.1.5/src/pych9329/keyboard.py

@@ -0,0 +1,216 @@
+import random
+import time
+from collections import OrderedDict
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+from serial import Serial
+
+import pych9329.frame_utils as frame_utils
+from pych9329.hid_code_map import HID_CODE_MAP
+
+MODIFIER_KEY_NAME_MAP = {
+    "ctrl": 0b00000001,
+    "ctrl_left": 0b00000001,
+    "shift": 0b00000010,
+    "shift_left": 0b00000010,
+    "alt": 0b00000100,
+    "alt_left": 0b00000100,
+    "win": 0b00001000,
+    "win_left": 0b00001000,
+    "ctrl_right": 0b00010000,
+    "shift_right": 0b00100000,
+    "alt_right": 0b01000000,
+    "win_right": 0b10000000,
+}
+
+
+def deduplicate_list(lt: List) -> List:
+    return list(OrderedDict.fromkeys(lt))
+
+
+def receive_indicator_status(serial_object: Serial) -> Tuple[bool, Dict[str, bool]]:
+    result_dict: Dict[str, bool] = {
+        "usb_connect_status": False,
+        "num_lock": False,
+        "caps_lock": False,
+        "scroll_lock": False,
+    }
+    result_value = False
+    data_frame = frame_utils.DataFrame(
+        b"\x57\xab",
+        b"\x00",
+        b"\x01",
+        b"\x00",
+        b"",
+    )
+    frame_packet = data_frame.create_frame()
+    # clear connection buffer
+    serial_object.readall()
+    # write command
+    serial_object.write(frame_packet)
+    serial_object.flush()
+    # read packet
+    reply_packet: bytes = serial_object.readall()
+    parse_result = data_frame.parse_frame(reply_packet)
+    if parse_result is False:
+        return result_value, result_dict
+    reply_data = data_frame.get_data()
+    # 获取USB连接状态
+    usb_connect_status: bytes = reply_data[1:2]
+    if usb_connect_status == b"0x00":
+        result_dict["usb_connect_status"] = False
+    else:
+        result_dict["usb_connect_status"] = True
+    # 获取键盘锁定状态
+    indicator_bytes: bytes = reply_data[2:3]
+    indicator_flag = int.from_bytes(indicator_bytes, byteorder="little")
+    if indicator_flag & 0x01 != 0:
+        result_dict["num_lock"] = True
+    else:
+        result_dict["num_lock"] = False
+    if indicator_flag & 0x02 != 0:
+        result_dict["caps_lock"] = True
+    else:
+        result_dict["caps_lock"] = False
+    if indicator_flag & 0x04 != 0:
+        result_dict["scroll_lock"] = True
+    else:
+        result_dict["scroll_lock"] = False
+    result_value = True
+    return result_value, result_dict
+
+
+def send_general_data(
+    serial_object: Serial,
+    key_tuple: Tuple[str, str, str, str, str, str] = ("", "", "", "", "", ""),
+    modifiers: Optional[List[str]] = None,
+) -> None:
+    if modifiers is None:
+        modifiers = []
+
+    # CMD_SEND_KB_GENERAL_DATA data has exactly 8 bytes
+    data = b""
+
+    # first byte modifiers key, each bit represents 1 key
+    #
+    # BIT0 - ctrl_left
+    # BIT1 - shift_left
+    # BIT2 - alt_left
+    # BIT3 - win_left
+    # BIT4 - ctrl_right
+    # BIT5 - shift_right
+    # BIT6 - alt_right
+    # BIT7 - win_right
+    modifier_value: int = 0x00
+    for key_name in modifiers:
+        if key_name not in MODIFIER_KEY_NAME_MAP:
+            raise InvalidModifierKey(key_name)
+        modifier_value |= MODIFIER_KEY_NAME_MAP[key_name]
+    data += modifier_value.to_bytes(1, byteorder="little")
+
+    # second byte must be 0x00
+    data += b"\x00"
+
+    # third to eighth bytes are keys
+    # we can press upto 6 buttons
+    for key in key_tuple:
+        if key not in HID_CODE_MAP:
+            raise InvalidKey(key)
+        hid_code, _ = HID_CODE_MAP[key]
+        data += hid_code
+
+    # create packet and send
+    data_frame = frame_utils.DataFrame(
+        b"\x57\xab",
+        b"\x00",
+        b"\x02",
+        b"",
+        b"",
+    )
+    data_frame.set_data(data)
+    frame_packet = data_frame.create_frame()
+    serial_object.write(frame_packet)
+    serial_object.flush()
+
+
+def trigger(
+    serial_object: Serial,
+    keys: list[str],
+    modifiers: Optional[List[str]] = None,
+) -> None:
+    press_keys = keys.copy()
+    press_modifiers = modifiers.copy()
+    press_keys = deduplicate_list(press_keys)
+    press_modifiers = deduplicate_list(press_modifiers)
+    # Supports press to 6 normal buttons at the same time
+    if len(press_keys) > 6:
+        raise TooManyKeys("CH9329 supports maximum of 6 keys to be pressed at once.")
+    if len(modifiers) > 8:
+        raise TooManyKeys(
+            "CH9329 supports maximum of 8 control keys to be pressed at once."
+        )
+    # if len(keys) <= 6, add empty keys
+    while len(press_keys) != 6:
+        press_keys.append("")
+    send_general_data(
+        serial_object,
+        (
+            press_keys[0],
+            press_keys[1],
+            press_keys[2],
+            press_keys[3],
+            press_keys[4],
+            press_keys[5],
+        ),
+        press_modifiers,
+    )
+
+
+def press(
+    serial_object: Serial, key: str, modifiers: Optional[List[str]] = None
+) -> None:
+    if modifiers is None:
+        modifiers_copy = []
+    elif isinstance(modifiers, list):
+        modifiers_copy = modifiers.copy()
+    else:
+        modifiers_copy = []
+    if key not in HID_CODE_MAP:
+        raise InvalidKey(key)
+    _, shift = HID_CODE_MAP[key]
+    if shift:
+        modifiers_copy.append("shift")
+    send_general_data(serial_object, (key, "", "", "", "", ""), modifiers_copy)
+
+
+def release(serial_object: Serial) -> None:
+    send_general_data(serial_object, ("", "", "", "", "", ""))
+
+
+def click(
+    serial_object: Serial,
+    key: str,
+    min_interval: float = 0.02,
+    max_interval: float = 0.05,
+) -> None:
+    sleep_time = random.uniform(min_interval, max_interval)
+    press(serial_object, key)
+    time.sleep(sleep_time)
+    release(serial_object)
+
+
+def send_text_data(
+    ser: Serial,
+    text: str,
+    min_interval: float = 0.02,
+    max_interval: float = 0.05,
+) -> None:
+    for char in text:
+        click(ser, char, min_interval, max_interval)
+
+
+if __name__ == "__main__":
+    pass

pych9329-0.1.5/src/pych9329/mouse.py

@@ -0,0 +1,159 @@
+import random
+import time
+import typing
+
+from serial import Serial
+
+import pych9329.exceptions as exceptions
+import pych9329.frame_utils as frame_utils
+
+MOUSE_BUTTON_NAME_MAP: typing.Final[dict[str, bytes]] = {
+    'null': b'\x00',
+    'left': b'\x01',
+    'right': b'\x02',
+    'center': b'\x04',
+    # alias
+    'none': b'\x00',
+    'middle': b'\x04',
+}
+
+
+def check_integer_range(value: int, minimum: int, maximum: int) -> bool:
+    if value < minimum or value > maximum:
+        return False
+    return True
+
+
+def send_absolute_data(
+    serial_object: Serial,
+    x: int,
+    y: int,
+    button_name: str = 'null',
+    x_max: int = 1920,
+    y_max: int = 1080,
+    wheel_value: int = 0,
+) -> None:
+    if not check_integer_range(x_max, 0, 4096):
+        raise exceptions.InvalidCoordinateValue(
+            'Max coordinate value should be between 0 and 4096'
+        )
+    if not check_integer_range(y_max, 0, 4096):
+        raise exceptions.InvalidCoordinateValue(
+            'Max coordinate value should be between 0 and 4096'
+        )
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x04',
+        b'',
+        b'',
+    )
+    # CMD_SEND_MS_ABS_DATA requires 7 bytes data
+    # first byte is always 0x02
+    buffer = b'\x02'
+
+    # second byte is mouse button value
+    buffer += MOUSE_BUTTON_NAME_MAP[button_name]
+
+    # third and fourth bytes are x-coordinates
+    x_value = (4096 * x) // x_max
+    buffer += x_value.to_bytes(2, byteorder='little')
+
+    # fifth and sixth bytes are y-coordinates
+    y_value = (4096 * y) // y_max
+    buffer += y_value.to_bytes(2, byteorder='little')
+
+    # seventh byte contains wheel data
+    # If it is 0x00, it means there is no scrolling action
+    # 0x01-0x7F, means scroll up
+    # 0x81-0xFF, means scroll down
+    if not check_integer_range(wheel_value, -128, 127):
+        raise exceptions.InvalidWheelValue(
+            'Wheel value should be between -127 and 128'
+        )
+    buffer += wheel_value.to_bytes(1, byteorder='little', signed=True)
+    data_frame.set_data(buffer)
+    request_packet = data_frame.create_frame()
+    serial_object.write(request_packet)
+
+
+def send_relative_data(
+    serial_object: Serial,
+    x: int,
+    y: int,
+    button_name: str = 'null',
+    wheel_value: int = 0,
+) -> None:
+    data_frame = frame_utils.DataFrame(
+        b'\x57\xab',
+        b'\x00',
+        b'\x05',
+        b'',
+        b'',
+    )
+    # CMD_SEND_MS_REL_DATA requires 5 bytes data
+    # first byte is always 0x01
+    buffer = b'\x01'
+    buffer += MOUSE_BUTTON_NAME_MAP[button_name]
+
+    # x value
+    if not check_integer_range(x, -128, 127):
+        raise exceptions.InvalidCoordinateValue(
+            'Coordinate value should be between -127 and 128'
+        )
+    buffer += x.to_bytes(1, byteorder='little', signed=True)
+    # y value
+    if not check_integer_range(y, -128, 127):
+        raise exceptions.InvalidCoordinateValue(
+            'Coordinate value should be between -127 and 128'
+        )
+    buffer += y.to_bytes(1, byteorder='little', signed=True)
+
+    # wheel value
+    if not check_integer_range(wheel_value, -128, 127):
+        raise exceptions.InvalidWheelValue(
+            'Wheel value should be between -127 and 128'
+        )
+    buffer += wheel_value.to_bytes(1, byteorder='little', signed=True)
+
+    data_frame.set_data(buffer)
+    request_packet = data_frame.create_frame()
+    serial_object.write(request_packet)
+
+
+def move(
+    serial_object: Serial,
+    x: int,
+    y: int,
+    relative_mode: bool = False,
+    monitor_width: int = 1920,
+    monitor_height: int = 1080,
+) -> None:
+    if relative_mode:
+        send_relative_data(serial_object, x, y, 'null')
+    else:
+        send_absolute_data(serial_object, x, y, 'null', monitor_width, monitor_height)
+
+
+def press(serial_object: Serial, button_name: str = 'left') -> None:
+    send_relative_data(serial_object, 0, 0, button_name, 0)
+
+
+def release(serial_object: Serial) -> None:
+    send_relative_data(serial_object, 0, 0, 'null', 0)
+
+
+def click(serial_object: Serial, button_name: str = 'left') -> None:
+    press(serial_object, button_name)
+    # 100 to 400 milliseconds delay for simulating natural behavior
+    sleep_time = random.uniform(0.20, 0.40)
+    time.sleep(sleep_time)
+    release(serial_object)
+
+
+def wheel(serial_object: Serial, wheel_value: int = 1) -> None:
+    send_relative_data(serial_object, 0, 0, 'null', wheel_value=wheel_value)
+
+
+if __name__ == '__main__':
+    pass

pych9329-0.1.5/src/pych9329/struct_utils.py

@@ -0,0 +1,95 @@
+import struct
+import typing
+import pych9329.exceptions as exceptions
+from typing import Any
+
+
+class StructureMeta(type):
+    def __init__(
+        cls, _cls_name: str, _bases: tuple[type, ...], _cls_dict: dict[str, Any]
+    ):
+        super().__init__(cls)
+        fields = getattr(cls, '_fields_', [])
+
+        offset = 0
+        for field_format, field_name in fields:
+            if field_format.startswith(('<', '>', '!', '@')):
+                byte_order = field_format[0]
+                field_format = field_format[1:]
+            else:
+                byte_order = ''
+            field_format = byte_order + field_format
+            offset += struct.calcsize(field_format)
+        setattr(cls, '_fields_struct_size_', offset)
+
+
+class Structure(metaclass=StructureMeta):
+    def __init__(self, data: bytes):
+        self.buffer = data
+        self.attribute = dict()
+        self.load()
+
+    def load(self):
+        fields = self._fields_
+        offset = 0
+        for field_format, field_name in fields:
+            field_length = struct.calcsize(field_format)
+            field_data = struct.unpack_from(field_format, self.buffer, offset)
+            if len(field_data) == 1:
+                self.attribute[field_name] = field_data[0]
+            elif len(field_data) == field_length:
+                buffer = bytearray()
+                for item in field_data:
+                    buffer += item
+                self.attribute[field_name] = bytes(buffer)
+            else:
+                self.attribute[field_name] = None
+            offset += struct.calcsize(field_format)
+
+    def save(self):
+        fields = self._fields_
+        binary_data = bytearray()
+        for field_format, field_name in fields:
+            field_data = self.attribute[field_name]
+            field_bytes = struct.pack(field_format, field_data)
+            binary_data += bytearray(field_bytes)
+        self.buffer = bytes(binary_data)
+
+    def get(self, key: str) -> Any:
+        data = self.attribute.get(key, None)
+        return data
+
+    def set(self, key: str, value: Any) -> None:
+        self.attribute[key] = value
+
+    def buffer_load(self, buffer: bytes) -> None:
+        self.buffer = buffer
+        self.attribute.clear()
+        self.load()
+
+    def buffer_flush(self) -> None:
+        self.save()
+
+    @classmethod
+    def from_buffer(cls, buffer: bytes):
+        buffer_len = len(buffer)
+        if buffer_len >= cls._fields_struct_size_:
+            return cls(buffer)
+        else:
+            raise exceptions.BufferTooSmall()
+
+    @classmethod
+    def from_file(cls, buffer: typing.BinaryIO):
+        return cls(buffer.read(cls._fields_struct_size_))
+
+
+'''
+class ExampleStruct(Structure):
+    _fields_ = [
+        ('d', 'min_x'),
+        ('d', 'min_y'),
+    ]
+'''
+
+if __name__ == '__main__':
+    pass