Pywinusb: handle events from multiple keyboards

Question

I'm trying to handle events from multiple usb keyboards, so that the code knows from which keyboard an input is coming from. The code identify the different keyboards via the device instance id (they all have the same product and vendor id) but not from which an user input is coming from (it just toggles between them).

Is this even possible with pywinusb? I tried playing with the event handlers with no luck.

from time import sleep
from msvcrt import kbhit

import pywinusb.hid as hid

# feel free to test
target_vendor_id = 0xffff
target_product_id = 0x0035

def sample_handler(data):
    print("Raw data: {0}".format(data))

def getinput(data, id):
    print data
    print id
    if(id == "8&2754010&0&0000" and data == "09008708"):
        print "Success"
    else:
        print "Failed"

def raw_test():

   # example, handle the HidDeviceFilter().get_devices() result grouping items by parent ID
   all_hids = hid.HidDeviceFilter(vendor_id = target_vendor_id, product_id = target_product_id).get_devices()
   #print all_hids
   if all_hids:
       while True:
           for index, device in enumerate(all_hids):
               result = device.instance_id.split('\\')[-1]
               try:
                   device.open()
                   getinput(raw_input(), result)
               finally:
                   device.close()

if __name__ == '__main__':
    # first be kind with local encodings
    import sys

    if sys.version_info >= (3,):
       # as is, don't handle unicodes
       unicode = str
       raw_input = input
    else:
       # allow to show encoded strings
       import codecs
       sys.stdout = codecs.getwriter('mbcs')(sys.stdout)
    raw_test()

Answer 1

In your code, there is a loop that goes through all HID devices (keyboards, in this case, from the rene-aguirre/pywinusb HidDevice), and opens them one by one to check for input:

for index, device in enumerate(all_hids):
    result = device.instance_id.split('\\')[-1]
    try:
        device.open()
        getinput(raw_input(), result)
    finally:
        device.close()

That loop opens each device, waits for input (raw_input()), then closes the device. It repeats this process for each device in all_hids.

It accesses devices one after the other in a sequence. So it can only listen to one device at a time. Each device is opened, waits for a single input, and then is closed. There is no continuous monitoring of each keyboard.
The getinput function is called with the device instance ID and the user input, but this is done within the same loop, not allowing you to differentiate inputs from different keyboards.

Hence, your issue: your code recognizes different keyboards by their device instance ID, but it fails to identify in real-time from which specific keyboard an input is coming.

---

from time import sleep
import pywinusb.hid as hid

target_vendor_id = 0xffff
target_product_id = 0x0035

# Handler to process the data
def sample_handler(data, device_instance_id):
    print(f"Data from {device_instance_id}: {data}")

# Function to open devices and assign handlers
def raw_test():
    all_hids = hid.HidDeviceFilter(vendor_id=target_vendor_id, product_id=target_product_id).get_devices()
    if all_hids:
        for device in all_hids:
            device_instance_id = device.instance_id.split('\\')[-1]
            try:
                device.open()
                # Set the handler for the device
                device.set_raw_data_handler(lambda data, id=device_instance_id: sample_handler(data, id))
            except IOError as e:
                print(f"Could not open the device: {e}")

        # Keep the script running
        print("Press Ctrl+C to stop")
        try:
            while True:
                sleep(0.1)
        except KeyboardInterrupt:
            pass
        finally:
            for device in all_hids:
                device.close()

if __name__ == '__main__':
    raw_test()

That would open each device and sets a handler that includes the device instance ID. When data is received, sample_handler will be called with the data and the ID of the device from which the data originated.
The handler remains active and continuously listens for inputs specifically from its assigned keyboard: your code can distinguish inputs from different keyboards.

device.set_raw_data_handler(lambda data, id=device_instance_id: sample_handler(data, id))

Each device remains open, and its handler stays active: each keyboard is continuously monitored for input.
When an input event occurs, the corresponding handler is triggered. Since each handler knows the device_instance_id of its keyboard, it can immediately identify and report from which keyboard the input came.

def sample_handler(data, device_instance_id):
     print(f"Data from {device_instance_id}: {data}")

The device_instance_id is used to identify the source keyboard of the input data.