import math
import queue

import soundcard as sc
import numpy as np
import threading
import time
import torch
from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
from queue import Queue
from scipy.io import wavfile
import io

file_counter = 0

print(torch.cuda.is_available())
device = "cuda:0" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32

model_id = "openai/whisper-large-v3"

model = AutoModelForSpeechSeq2Seq.from_pretrained(
model_id, torch_dtype=torch_dtype, low_cpu_mem_usage=True, use_safetensors=True
)
model.to(device)

processor = AutoProcessor.from_pretrained(model_id)

pipe = pipeline(
"automatic-speech-recognition",
model=model,
tokenizer=processor.tokenizer,
feature_extractor=processor.feature_extractor,
torch_dtype=torch_dtype,
device=device,
# chunk_length_s=30,
# batch_size=16,
)

sLast_point = []

print("---DSAFDSFSDDFS")
print(type(pipe))

generate_kwargs = {
"max_new_tokens": 445, # Уменьшаем значение до 445
"num_beams": 3, # Увеличиваем количество лучей для более качественного результата
"condition_on_prev_tokens": True, # Учитываем предыдущие токены для непрерывности
"compression_ratio_threshold": 1.35, # Оставляем без изменений
"temperature": 0.3, # Устанавливаем фиксированное значение для стабильности
"logprob_threshold": -1.0, # Оставляем без изменений
"no_speech_threshold": 0.6, # Немного понижаем порог для лучшего восприятия слабой речи
"return_timestamps": True # Оставляем без изменений
}
for item in pipe("C:\Users\NameIsApulaz\Desktop\Whisper\whisperTest\vid.mp4", return_timestamps="word"):
print(item["partial"][0])
for item in pipe("C:\Users\NameIsApulaz\Desktop\Whisper\whisperTest\vid.mp4", return_timestamps="word"):
print(item["partial"][0])
filePath = "C:\Users\NameIsApulaz\PycharmProjects\pythonProject\file_13.wav"
filePath = "C:\Users\NameIsApulaz\PycharmProjects\pythonProject\all_13.wav"

sampleRate, data = wavfile.read(filePath)
result = pipe(filePath, return_timestamps=True)
for chunk in result["chunks"]:
print(chunk["timestamp"][0])
print(chunk["timestamp"][1])
print(chunk["text"])
print(len(data))
print(f"Длительность аудиофайла: {len(data) / sampleRate:.2f} секунд")
exit()
Step 2: Save the audio data to a bytes array
for item in pipe("C:\Users\NameIsApulaz\Desktop\Whisper\whisperTest\vid.mp4", return_timestamps="word"):
print(item["partial"][0])
with open("output.txt", "w", encoding="utf-8") as file:
file.write(result["text"])
Параметры записи
duration = 5 # Продолжительность блока записи в секундах
sample_rate = 16000 # Частота дискретизации
frame_size = sample_rate * 1 # Размер блока для записи (уменьшаем для снижения вероятности пропусков)
buffer_size = 999 * sample_rate

Кольцевой буфер для записи звука
audio_queue = Queue(maxsize=buffer_size) # Очередь для хранения аудио данных

Флаг для завершения записи
recording_active = True

Выбор динамика (по умолчанию используется первый в списке)
default_speaker = sc.default_speaker()
print(f"Используется динамик по умолчанию: {default_speaker}")

Настройка микрофона для захвата системного звука
micer = sc.get_microphone(id=str(default_speaker.name), include_loopback=True)

q = np.ndarray(shape=(16000,), dtype=np.int16)

def audio_stream():
"""Функция генератора для потоковой передачи аудио"""
with micer.recorder(samplerate=sample_rate, blocksize=frame_size) as recorder:
while recording_active:
try:
rData = recorder.record(numframes=frame_size)
if len(rData.shape) > 1 and rData.shape[1] > 1:
rData = np.mean(rData, axis=1) # Усредняем каналы для получения моно
block = rData
yield block # Возвращаем блок в поток
except Exception as e:
print(f"Ошибка при записи: {e}")
break
def audio_stream():
while True:
global q


    item = q
    q = np.ndarray(shape=(16000,), dtype=np.int16)
    if item is None:
        break

    print(len(item))
    print(type(item))
    yield item
def writer(q):
with micer.recorder(samplerate=sample_rate, blocksize=frame_size) as recorder:
while recording_active:
try:
rData = recorder.record(numframes=frame_size)
if len(rData.shape) > 1 and rData.shape[1] > 1:
rData = np.mean(rData, axis=1) # Усредняем каналы для получения моно


            recording_int16 = np.int16(rData * 32767)

            print(type(recording_int16))
            print(recording_int16.shape)
            q.append(recording_int16)
        except Exception as e:
            print(f"Ошибка при записи: {e}")
            break
def transcribe_audio_periodically(audio_stream_gen):
"""Функция для периодического распознавания речи"""
global file_counter


print("GOGOGOGOGO")
while recording_active:
    time.sleep(3)  # Ожидание 5 секунд перед следующим распознаванием
    frames = []
    while not audio_queue.empty():
        frames.append(audio_queue.get())  # Извлечение всех доступных блоков

    if frames:
        recording_data = np.concatenate(frames)  # Объединяем все блоки

        recording_data.p
        # recording_data = recording_data.astype(np.float32)  # Преобразуем в float32

        # Распознавание речи
        try:
            recording_int16 = np.int16(recording_data * 32767)

            # Step 2: Save the audio data to a bytes array
            wav_bytes_io = io.BytesIO()
            wavfile.write(wav_bytes_io, sample_rate, recording_int16)

            # Get the byte data from the BytesIO object
            wav_bytes = wav_bytes_io.getvalue()

            # Close the BytesIO object
            wav_bytes_io.close()

            # result = pipe(wav_bytes, generate_kwargs=generate_kwargs)
            result = pipe(wav_bytes, return_timestamps="word")

            wavfile.write(f"all_{file_counter}.wav", sample_rate, recording_int16)

            last_point = result["chunks"][-2:]

            # for chunk in result["chunks"]:
            #     print(chunk["timestamp"][0])
            #     print(chunk["timestamp"][1])
            #     print(chunk["text"])

            start_point = float(last_point["timestamp"][0])
            end_point = float(last_point["timestamp"][1])

            bStart_point = math.floor(start_point * sample_rate)
            bEnd_point = math.floor(end_point * sample_rate)

            print("Points: " + str(bStart_point) + " - " + str(bEnd_point))
            print("fLength: ", len(recording_data))

            print(f"Длительность аудиофайла: {len(recording_data) / sample_rate:.2f} секунд")

            selected_range = recording_data[bStart_point:bEnd_point]
            sLast_point.append(selected_range)

            # wavfile.write(f"file_{file_counter}.wav", sample_rate, np.int16(selected_range * 32767))

            # with open(f"file_{file_counter}.txt", 'w') as f:
            #     f.write(chunk["text"])
            #
            # print("File count: ", file_counter)
            # file_counter += 1


            # print("Распознанный текст:", result["chunks"])
            print("-------------------end--------------")
        except Exception as e:
            print("Ошибка распознавания:", e)
writer_thread = threading.Thread(target=writer, args=(q,))
writer_thread.start()

audio_stream_gen = audio_stream()

transcribe_thread = threading.Thread(target=transcribe_audio_periodically, args=(audio_stream_gen,))
transcribe_thread.start()
for item in pipe(audio_stream_gen, return_timestamps=True):
print(item)

try:
# Запись и распознавание будут происходить, пока не остановят вручную
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Остановка записи и распознавания...")
recording_active = False
# record_thread.join()
# transcribe_thread.join()
print("Запись и распознавание завершены.")

Как мне сделать так чтобы массив ndarray расширялся по мере поступления данных, я хочу поведение похоже на лист байтов, допутсим изначально там 0, я добавил в него 16000 байтов, стало 16000, а добавил еще и т.д