[AIOBLE] What is the recommended way to handle a burst of notified packets as a client?

[ekspla]

Client: MPY-1.23.0 on ESP32-WROOM
Peripheral: a device that seems to be using Nordic UART service

It seems to me that a burst of notified packets cannot be handled with Client.notified(),
because of self._notify_queue = deque((), 1) (size of 1) in aioble/client.py.

By using a while loop and characteristic.notified , lots of notified packets were lost.

In client.py there is, in a comment, as follows:

# Append the data. By default this is a deque with max-length==1, so it
# replaces. But if capture is enabled then it will append.

I have a question:
How can I specify capture=True or increase the size of the _notify_queue?
As a woraround, I use a code like followings (this is not a real code that works as is) to handle
the burst of packets, and it seems to be working in my use case.
But I do not think that using characteristic._notify_queue from outside is recommended.
There may be a better way in such a case.

[EDITED]

import sys
sys.path.append('')
import asyncio, aioble, bluetooth
from collections import deque

_SERVICE_UUID = bluetooth.UUID("6e400001-b5a3-f393-e0a9-e50e24dcca9e")
_TX_CHARACTERISTIC_UUID = bluetooth.UUID("6e400003-b5a3-f393-e0a9-e50e24dcca9e")# Peripheral -> MPY Client
_RX_CHARACTERISTIC_UUID = bluetooth.UUID("6e400002-b5a3-f393-e0a9-e50e24dcca9e")# MPY Client -> Peripheral

class MyClass:
    def __init__(self):
        self.buf = bytearray(130)
        self.idx = 0

    async def main(self):
        connection = await _TARGET_DEVICE.connect()
        async with connection:
            service = await connection.service(_SERVICE_UUID)
            self.tx_characteristic = await service.characteristic(_TX_CHARACTERISTIC_UUID)
            self.rx_characteristic = await service.characteristic(_RX_CHARACTERISTIC_UUID)
            self.tx_characteristic._notify_queue = deque((), 6) # I had to change the size of the queue (default was 1).
            await self.tx_characteristic.subscribe(notify=True)

            notif_handler_task = asyncio.create_task(self.handling_notifications())
            while True:
                # Send command (rx channel) to start transport from the peripheral to the client.
                await self.request_transport()
                # Do something with the accumulated buffer.

    async def handling_notifications(self):
        def append_to_buf(packet):
            if (len_packet := len(packet)):
                self.buf[self.idx:self.idx + len_packet] = packet
                self.idx += len_packet
        while True:
            packet = await self.tx_characteristic.notified()
            await asyncio.sleep(1) # Wait until the notify packets are populated in deque.
            if packet == SOME_CONDITION:
                # Do something
            else:
                append_to_buf(packet)
                while len(dq := self.tx_characteristic._notify_queue) >= 1:
                    packet = dq.popleft()
                    append_to_buf(packet)
            await asyncio.sleep(0)

communication = MyClass()
asyncio.run(communication.main())