How do I selectively edit hex bytes in a byte array without changing other

I’m writing a python program that is sending a byte array to a BLE device using a byte array. I can manipulate the data sent to the device and that works. The device is an 8 button Bluetooth switch panel. The byte array when read from the device looks like this

x08x00x00x00x00

To clarify what this means in context, x08 I believe is the header which is position 0 of the array. Position 1 is switch 1 and 2, Position 2 is switch 3 and 4, and so on

The array appears to be looking at each position as a hex code so if I want to turn on switch number 4 I have to send 01 but if I want to turn on switch 3 I have to send 16 if I want both it would be 17 which would breakdown something like this

Switch 4 only
switch_status[2] = 01

output:
x08x00x01x00x00

Switch 3 only
x08x00x16x00x00

There are other functions like momentary mode and flash but I’m keeping this simple for now.

I’m trying to avoid writing an entire function that writes the entire array each time as I don’t want to manipulate all the switch just to turn one switch on. However since each byte in the array controls 2 switches I either have to run a check to determine the state then change the byte for both switches to ensure I’m not turning on or off the wrong switch or I need to find a better way to manipulate the array elements. I’m not sure what the right call is here. Any advice would be appreciated. I’m still learning python so I may be using the wrong concepts here.

I’ve attempted directly writing the bytes for individual switch pairs and that works. However it makes the code a bit cumbersome when I have to check each pair for current status and write if statements to ensure I’m not overwriting a value I want to keep if another switch is already on. I can do that but it seems inefficient. Could be that is the correct answer but I thought I would ask. I’ve considered dumping the array to a string and converting back after a specific edit has been made but that seemed like over handling. If statements by comparison seemed more efficient. Then end goal is to turn this into a function call that gets used by another part of the app. The ability to reliably push commands over BLE to do what I need the switches to do was the logical first step.

Here is the code I’m working on

import asyncio
from bleak import BleakClient

#Define the device we are manipulating

address = "{DEVICE HW ADDRESS}"
SWITCH_UUID = "0000fff1-0000-1000-8000-00805f9b34fb"

#Define our Variables. Outside of testing these should all be set to 0
sign = 0
left = 0
right =
rear = 0
bar = 0
cargo = 0
jump = 0
booster = 0

#Convert our variables to a hex string then store them in a byte array. At some point we will need to get current switch status so we can parse and change variables in the array to reflect current configuration.
simplearray = "08" + str(sign) + str(left) + str(right) + str(rear) + str(bar) + str(cargo) + str(jump) + str(booster)
#array = bytes.fromhex("08" + str(sign) + str(left) + str(right) + str(rear) + str(bar) + str(cargo) + str(jump) + str(booster))
array = bytes.fromhex(simplearray)

#Print list of current states for switches for troubleshooting.
print("Switch1: " + simplearray[2])
print("Switch2: " + simplearray[3])
print("Switch3: " + simplearray[4])
print("Switch4: " + simplearray[5])
print("Switch5: " + simplearray[6])
print("Switch6: " + simplearray[7])
print("Switch7: " + simplearray[8])
print("Switch8: " + simplearray[9])

#Use asyncio to connect to our BLE GATT server
async def main(address):
    async with BleakClient(address) as client:

        #verify connection to our server
        print(f"Connected: {client.is_connected}")

        #Get the switch status from the UUID imput above and print current status. Later we will use this to make sure we are only changing desired switches.
        switch_status = await client.read_gatt_char(SWITCH_UUID)
        print("Switch Status:" + str(switch_status))

        #Set security level. What is this for anyway?
        paired = await client.pair(protection_level=2)

        #Make sure we are paired before operating switches. Error handler needed here.
        print(f"Paired: {paired}")

        #Signal lights to turn on and re-read status.
        print("Turning Switches On....")

        #For some reason this doesn't work. Can't manually assign values to a position in simplearray.
        #Would have to use a replace command instead but leaves us sending the entire hex byte array to the unit instead of switching one output like we want
        #will likely read hex value and manipulate for values we want
        #simplearray[5] = 1
        #print(simplearray[5])

        #print output of the array to check our status while testing. Will be removed later
        print(array)
        #This sends the array to the switch. I can send commands to individual pairs but not individual switches. Will need to investigate further.
        await client.write_gatt_char(SWITCH_UUID, array)
        switch_status = await client.read_gatt_char(SWITCH_UUID)
        print(switch_status)
        await asyncio.sleep(5.0)
        print(switch_status[0])
        print(switch_status[1])
        print(switch_status[2])
        print(switch_status[3])
        print(switch_status[4])
        #Signla turn switches off after wait.
        print("Turning Switches Off...")

        #For testing purposes turn all switches off before we exit.
        await client.write_gatt_char(SWITCH_UUID, b"x08x00x00x00x00")
        switch_status = await client.read_gatt_char(SWITCH_UUID)
        print(switch_status)
        await asyncio.sleep(1.0)

#Disconnect I guess? Look into this one.
asyncio.run(main(address))