Winrt API Python getting Bluetooth signal strength

Question

I am trying to measure Bluetooth signal strength using winrt APi in python using winsdk. My workflow is to measure Bluetooth Signal strength of a device that is already connected with my Windows machine. I followed the guideline from Pywinrt documentation found here:

Here is my code snippet:

import asyncio

import  winsdk.windows.devices.enumeration as e
import winsdk.windows.devices.bluetooth as bl

async def scan():

    sig_strength = "System.Devices.Aep.SignalStrength"
    additionalProperties = [sig_strength]
    watcher = e.DeviceInformation.create_watcher(bl.BluetoothDevice.get_device_selector(), additionalProperties)
    received_queue = asyncio.Queue()
    
    def added_w(device_watcher, device_info_update):
        if(device_info_update.name == "my_device"):
            
            print("found!")
            for value, key in enumerate(device_info_update.properties):
                if key == "System.Devices.Aep.SignalStrength":
                    print("signal strength: {}".format(value) ) 

    def updated_w(device_watcher, device_info_update):
        print("update for {} with kind {}".format(device_info_update.id, device_info_update.kind))


    def removed_w(device_watcher, device_info_update):
        pass

    def stopped_w(device_watcher, device_info_update):
        pass

    
    received_token = watcher.add_added(
        lambda s, e: event_loop.call_soon_threadsafe(added_w, s, e)
    )
    updated_token = watcher.add_updated(
        lambda s, e: event_loop.call_soon_threadsafe(updated_w, s, e)
    )
   
    removed_token = watcher.add_removed(
        lambda s, e: event_loop.call_soon_threadsafe(removed_w, s, e)
    )
    
    event_loop = asyncio.get_running_loop()
    stopped_future = event_loop.create_future()

    def handle_stopped(sender, event_args):
      stopped_future.set_result(event_args)

    
    

    
    try:
        print("scanning...")
        watcher.start()

        # this is the consumer for the received event queue
        async def print_received():
          while True:
            event_args = await received_queue.get()
            print(
                "received:",
                event_args.bluetooth_address.to_bytes(6, "big").hex(":"),
                event_args.raw_signal_strength_in_d_bm, "dBm",
            )

        printer_task = asyncio.create_task(print_received())

        # since the print task is an infinite loop, we have to cancel it when we don't need it anymore
        stopped_future.add_done_callback(printer_task.cancel)

        # scan for 30 seconds or until an unexpected stopped event (due to error)
        done, pending = await asyncio.wait(
            [stopped_future, printer_task], timeout=30, return_when=asyncio.FIRST_COMPLETED
        )

        if stopped_future in done:
            print("unexpected stopped event", stopped_future.result().error)
        else:
            print("stopping...")
            watcher.stop()
            await stopped_future
    finally:
        # event handler are removed in a finally block to ensure we don't leak
        watcher.remove_received(received_token)
        watcher.remove_stopped(handle_stopped)
        

asyncio.run(scan())

However, I only get a fixed RSSI value 8 in my print in added_w function.

Any help on potential solution would be greatly appreciated!