Appending a stream of repeated bytes to IO in Python

I am writing a program that allows recording audio packets continuously from an event loop. Each iteration I would either get an actual packet of data, or no packet at all. I have to track the time since the last packet and append the silence packets to IO upon the next received packet.

The problem with that though is that the silence could be very long, and I don't want to create a large buffer of repeated data in order to write it to file, but it would also be extremely slow to write each silence frame individually in a loop, so my current solution is to combine the two and write in a loop with bigger to smaller segments of pre-generated silence.

I'm looking for a better optimal method. I have been looking at BufferedWriter's write method and noticed that it takes a bytes-like object. If that is possible, the optimal method would be being able to create a "bytes-like" object that simulates a stream of repeated data, that can be written x amount of times by the buffer without using a Python loop.

So far to no avail, so I'm asking this question here.

In order to simplify the question, I will be using representations of the data. buffer is always the returned result of open(file_name, "a+")

Suppose a silence packet is represented as "0", but of course in reality it is a lot larger than that, and 50,000 frames have passed since the last packet, I will need to append this silence to IO before writing the data from the packet. There are 3 ways of doing this I've thought of thus far.

The first way is to generate the data in memory first, then write it (which uses a lot of memory)

silence = b"0" * 50_000
buffer.write(silence)

The second way is to write all the silence frames in a loop (which is extremely slow)

for _ in range(50_000):
    buffer.write(b"0")

Lastly the third way is to combine the two, and write bigger segments (which is a lot faster than the second option, but slower than the first, and on top of that, it uses memory even when it's in use, plus overall this design is extremely ugly)

silence_1 = b"0"
silence_10 = b"0" * 10
silence_100 = b"0" * 100
silence_1000 = b"0" * 1000

# writing in a loop using bigger to smaller segments
# until there is no more silence to write
num_left = 50_000
while num_left > 0:
    if num_left >= 1000:
        buffer.write(silence_1000)
        num_left -= 1000
    elif num_left >= 100:
        buffer.write(silence_100)
        num_left -= 100
    elif num_left >= 10:
        buffer.write(silence_10)
        num_left -= 10
    else:
        buffer.write(silence_1)
        num_left -= 1

source https://stackoverflow.com/questions/77462225/appending-a-stream-of-repeated-bytes-to-io-in-python