script1 from scipy.io.wavfile import write import numpy as np import whisper import os…
- User
script1
from scipy.io.wavfile import write import numpy as np import whisper import os
import sounddevice as sd
tex1 = ""
modelo = 'c:\meu\large.pt'
samplerate = 44100 blocksize = 111 threshold = 0.06 vocals = [20, 20000] endblocks = 8 noise_blocks = 3
class StreamHandler: def init(self): self.running = True self.padding = 0 self.noise_counter = 0 self.prevblock = self.buffer = np.zeros((0, 1)) self.fileready = False print("\033[96mLoading Whisper modelo…\033[0m", end='', flush=True) self.modelo = whisper.load_model(f'{modelo}') print("\033[90m Done.\033[0m")
def process_audio_buffer(self, indata, frames, time, status): if any(indata): freq = np.argmax(np.abs(np.fft.rfft(indata[:, 0]))) * samplerate / frames if indata.max() > threshold and vocals[0] <= freq <= vocals[1]: self.noise_counter = 0 print('.', end='', flush=True) if self.padding < 1: self.buffer = self.prevblock.copy() self.buffer = np.concatenate((self.buffer, indata)) self.padding = endblocks else: if self.noise_counter < noise_blocks: self.noise_counter += 1 else: self.padding -= 1 if self.padding > 1: self.buffer = np.concatenate((self.buffer, indata)) elif self.padding < 1 and 1 < self.buffer.shape[0] > samplerate: self.fileready = True write('dictate.wav', samplerate, self.buffer) self.buffer = np.zeros((0,1)) elif self.padding < 1 and 1 < self.buffer.shape[0] < samplerate: self.buffer = np.zeros((0,1)) print("\033[2K\033[0G", end='', flush=True) else: self.prevblock = indata.copy() else: print("\033[31mNo input or device is muted.\033[0m") self.running = False def process_transcription(self): global tex1 if self.fileready: print("\n\033[90mTranscribing…\033[0m") result = self.modelo.transcribe('dictate.wav', language='pt', task='transcribe', initial_prompt='Eu quero comprar um colar de pérolas. Colar e colar. Vou colar ali') tex1 = str(result['text']) print(tex1) tex1 = " ".join([word for word in tex1.split()]) #tex1 = "" self.fileready = False def listen(self): #print('passaporaqui3') print("\033[92mListening… \033[37m(Ctrl+C to Quit)\033[0m") with sd.InputStream(channels=1, callback=self.process_audio_buffer, blocksize=int(samplerate * blocksize / 1000), samplerate=samplerate) as stream: while self.running: self.process_transcription()def main(): try:
handler = StreamHandler() handler.listen() except (KeyboardInterrupt, SystemExit): pass finally: print("\n\033[93mQuitting…\033[0m") if os.path.exists('dictate.wav'): os.remove('dictate.wav')if name == 'main': main()
ajudar a melhorar o script de modo a lidar com entradas de voz consecutivas sem que uma interfira na outra. Existem várias estratégias que você pode usar para garantir que cada entrada de voz seja transcrita corretamente. Vou sugerir uma abordagem a seguir:
Abordagem Sugerida: Filas e Threads
Uma maneira eficaz de lidar com entradas de voz sequenciais é usar uma fila para gerenciar os clipes de áudio a serem transcritos e processar a transcrição em uma thread separada. Isso pode evitar que as gravações de áudio se sobreponham, e cada clip de áudio será tratado de forma independente.
Aqui está uma implementação conceitual de como você pode modificar o script:
from queue import Queue from threading import Thread
Adicione estas duas linhas no início do script
audio_queue = Queue() transcription_thread = None
Modifique a classe StreamHandler
… restante da classe …
def process_transcription(self): global tex1
while not audio_queue.empty(): audio_clip = audio_queue.get() print(“\n\033[90mTranscribing…\033[0m”) result = self.modelo.transcribe(audio_clip, language=‘pt’, task=‘transcribe’) tex1 = str(result[‘text’]) print(tex1) tex1 = " “.join([word for word in tex1.split()]) audio_queue.task_done() # Marca o item atual como processado.… restante da classe …
Modificações na função main
def main(): global transcription_thread
transcription_thread = Thread(target=StreamHandler().process_transcription) transcription_thread.start() try: handler = StreamHandler() handler.listen() except (KeyboardInterrupt, SystemExit): pass finally: print(”\n\033[93mQuitting…\033[0m") transcription_thread.join() # Aguarda até que a transcrição das gravações pendentes seja concluída if os.path.exists(‘dictate.wav’): os.remove(‘dictate.wav’)if name == ‘main’: main()
Com essas alterações, sempre que um clip de áudio for completo e pronto para ser transcrito, ele será colocado na audio_queue. A thread chamada transcription_thread irá executar o método process_transcription que estará escutando esta fila e processará os clipes de áudio um por um sem importar quando a próxima entrada de voz acontecer. queria perguntar se posso fazer a transcrição num segundo script, utlizando uma estrutura do genero:
scriptA.py, seria uma espécie de integração com script1
import subprocess import time from multiprocessing.managers import BaseManager
class MyManager(BaseManager): pass
MyManager.register('get_shared_data')
def main(): caminho_para_o_servidor = "C:\meu\servidor.py" time.sleep(3) caminho_para_o_script_b = "C:\meu\scriptB.py"
# Inicia o servidor.py SOMENTE se ainda não estiver em execução # (Você precisa verificar se o servidor está em execução antes de iniciar um novo) subprocess.Popen(['python', caminho_para_o_servidor]) # Conecta ao servidor gerenciado pelo servidor.py m = MyManager(address=('localhost', 50000), authkey=b'mypassword') m.connect() # Obtém o dicionário compartilhado # Corrigido aqui! shared_data = m.get_shared_data() # Aguarda um pouco para garantir que o servidor comece a funcionar time.sleep(2) # Inicia o scriptB.py subprocess.Popen(['python', caminho_para_o_script_b]) # Agora o servidor e o scriptB estão rodando # Você pode fazer algo com as variáveis aqui, como imprimir os valores compartilhados """ while True: print("—scriptA----") print(f"Num1: {shared_data['num1']}, Nome1: {shared_data['nome1']}") time.sleep(3) """ while True: print('—scriptA—\n') num1 = shared_data.get('num1') # Use o método get() para acessar um valor nome1 = shared_data.get('nome1') # Use o método get() para acessar outro valor print(f"Num1: {num1}, Nome1: {nome1}") # Exibe os valores lidos time.sleep(10) shared_data.update({'num1': 3250, 'nome1': 'Outra Mariana dos SS'})if name == "main": main()
#scriptB.py- o script onde trataria a transcição---------------------------------------------------------------------------
import time from multiprocessing.managers import BaseManager
Define uma subclasse de BaseManager
class MyManager(BaseManager): pass
Registra o proxy para o dicionário compartilhado
MyManager.register('get_shared_data')
def main(): # Cria uma instância do manager e se conecta ao servidor m = MyManager(address=('localhost', 50000), authkey=b'mypassword') m.connect()
# Obtém o dicionário compartilhado shared_data = m.get_shared_data() # Agora podemos acessar e modificar os dados usando métodos do dicionário shared_data.update({'num1': 10, 'nome1': 'Amadoria Petrarca'}) # E para ler os valores, você também usa os métodos do dicionário, como: num1 = shared_data.get('num1') nome1 = shared_data.get('nome1') print(f"Num1: {num1}, Nome1: {nome1}") while True: print('—scriptB—\n') num1 = shared_data.get('num1') # Use o método get() para acessar um valor nome1 = shared_data.get('nome1') # Use o método get() para acessar outro valor print(f"Num1: {num1}, Nome1: {nome1}") # Exibe os valores lidos time.sleep(3)if name == "main": main() #servidor.py:
from multiprocessing.managers import BaseManager from multiprocessing import Process, Manager
def start_server(): with Manager() as manager: # Aqui você define o dicionário compartilhado no gerenciador. shared_data = manager.dict({'num1': 0, 'num2': 0, 'nome1': '', 'nome2': ''})
# BaseManager é o mecanismo que permite acesso aos dados compartilhados de outro processo. class MyManager(BaseManager): pass # Registra o dicionário para ser compartilhado em 'shared_data'. MyManager.register('get_shared_data', callable=lambda: shared_data) # Inicializa o gerenciador com um endereço que o scriptB.py possa acessar. m = MyManager(address=('', 50000), authkey=b'mypassword') # Inicia o servidor. s = m.get_server() print('Server is starting…') s.serve_forever()if name == "main": start_server() como é que passo para o scriptB por ex dictate.wav
- Assistant
Você está corretamente pensando em desacoplar a captura de áudio da transcrição usando um servidor de gerenciamento de estado compartilhado (Server.py) e a execução em scripts separados (ScriptA.py e ScriptB.py). Isso permitirá que a captação de áudio continue enquanto o processamento de transcrição seja realizado simultaneamente, sem bloquear ou interferir um no outro.
Para passar o arquivo
dictate.wavpara oScriptB.py, você tem algumas opções. Vou sugerir uma abordagem que você pode usar com a sua arquitetura atual:-
No
ScriptA.py(ou no seu script de captura de áudio original), após gravardictate.wav, você pode definir um indicativo no dicionário compartilhado que um arquivo está pronto para ser transcrito. -
No
ScriptB.py, você terá uma lógica de loop que continuamente verifica esse indicativo no dicionário compartilhado. -
Quando o
ScriptB.pydetectar que o arquivo está pronto, ele pode realizar a transcrição.
Aqui está como você pode modificar o
ScriptB.pypara fazer essa verificação e transcrever o áudio:# ScriptB.py import time from multiprocessing.managers import BaseManager import whisper class MyManager(BaseManager): pass MyManager.register('get_shared_data') def main(): m = MyManager(address=('localhost', 50000), authkey=b'mypassword') m.connect() shared_data = m.get_shared_data() modelo = 'c:\\meu\\large.pt' modelo = whisper.load_model(f'{modelo}') while True: audio_ready = shared_data.get('audio_ready') if audio_ready: print(f"Começando a transcrição de dictate.wav") # Aqui você pode adicionar o código de transcrição atual do Whisper # Por exemplo, você pode usar o modelo Whisper para transcrever o arquivo result = modelo.transcribe('dictate.wav', language='pt', task='transcribe') transcript = str(result['text']) print(transcript) # Depois da transcrição, defina a variável 'audio_ready' de volta para False shared_data.update({'audio_ready': False}) time.sleep(1) # Dê um tempo entre as verificações. if __name__ == "__main__": main()E então no seu
ScriptA.py, ou no script que grava o áudio, depois de gravar odictate.wav, você precisa atualizar o dicionário compartilhado para indicar que o áudio está pronto:# ... Dentro da sua função onde o arquivo 'dictate.wav' foi gravado: shared_data.update({'audio_ready': True})Esta é uma forma simples de comunicação entre os scripts que pode servir ao seu propósito. No entanto, em um ambiente de produção, você provavelmente usaria algo mais robusto e escalável como uma fila de mensagens (como RabbitMQ, AWS SQS, etc.) para gerenciar os trabalhos de transcrição.
-
- User
não entendi, dictate.wav nunca chega a passar(estar disponivel no scriptB)? é que é preciso processar ruido normalizar etc e não quero fazer isso em A ou 1
- Assistant
Peço desculpas pela confusão. Se você deseja transferir o arquivo de áudio
dictate.wavdo script que gerencia a gravação (que estou chamando de ScriptA) para outro script que gerencia a transcrição (ScriptB), você não precisa necessariamente passar o arquivo por memória compartilhada ou algo do tipo. Na verdade, ambos os scripts podem acessar o arquivo diretamente do sistema de arquivos, desde que estejam em execução no mesmo sistema.O que você precisa é simplesmente sinalizar para o ScriptB que existe um novo arquivo de áudio pronto para ser processado. Isso pode ser feito atualizando uma flag no dicionário compartilhado, conforme mencionei anteriormente.
Vou simplificar os passos para que fique claro:
ScriptA.py (Gravação e sinalização)
- Grava o áudio e salva como
dictate.wav. - Atualiza
shared_datacom uma flag para indicar que um novo arquivo está pronto, por exemplo:shared_data.update({'audio_ready': True}).
ScriptB.py (Transcrição e processamento)
- Em um loop contínuo, verifica a flag
audio_readynoshared_data. - Quando
audio_readyforTrue, ele sabe que há um novo arquivodictate.wavpara processar. - Realiza o pré-processamento necessário no áudio, como limpeza de ruído, normalização etc.
- Utiliza um modelo (por exemplo, o modelo do Whisper) para transcrever o
dictate.wav. - Após a conclusão da transcrição, atualiza
shared_datapara resetar a flag:shared_data.update({'audio_ready': False}).
Uma preocupação importante é evitar condições de corrida. Você precisa garantir que o ScriptA não tente gravar um novo
dictate.wavenquanto o ScriptB ainda está processando o arquivo anterior. Para resolver isso, você pode:- Fazer com que o ScriptA aguarde a flag
audio_readyser resetada paraFalseantes de tentar gravar novamente. - Gravar cada áudio com um nome de arquivo único (usando um timestamp, por exemplo) e ter uma estrutura de dados mais complexa que gerencia o status de cada arquivo.
Uma abordagem usando nomes de arquivo únicos:
No ScriptA, após a gravação, você poderia:
from datetime import datetime filename = datetime.now().strftime("dictate_%Y%m%d%H%M%S.wav") # ... código de gravação ... write(filename, samplerate, seu_dado_de_áudio) # Atualiza o dicionário compartilhado com o novo arquivo shared_data.update({filename: True})Então, no ScriptB, você processaria cada arquivo que aparece no dicionário:
# ... loop ... for filename, is_ready in list(shared_data.items()): if is_ready: # Processa o arquivo print(f"Começando a transcrição de {filename}") # Seu código de transcrição vai aqui # Após a conclusão da transcrição, remover do compartilhado del shared_data[filename]Usando esse método, cada arquivo seria tratado de forma independente, e os scripts poderiam ser executados concorrentemente, reduzindo a chance de conflitos no uso dos arquivos.
- Grava o áudio e salva como
- User
self.modelo = whisper.load_model(f'{modelo}') foi carregado em script1, deveria carregá-lo em B, ou estando carregado em 1 fica disponivel tambem para a transcrição em B
- Assistant
O modelo do Whisper precisa ser carregado no script onde será realizado o processamento da transcrição. Se você carregar o modelo no Script1, ele não estará disponível automaticamente no ScriptB. Cada script Python executa em seu próprio processo (ou no seu próprio espaço de memória), e os objetos em um processo não são automaticamente acessíveis em outro.
Portanto, se você está planejando realizar a transcrição no ScriptB, então é lá que você deve carregar o modelo. Aqui está uma estrutura básica de como você pode fazer isso em ScriptB:
# ScriptB.py import whisper from multiprocessing.managers import BaseManager class MyManager(BaseManager): pass MyManager.register('get_shared_data') def load_model(): # Suponha que o caminho do modelo seja conhecido e apropriado para o ScriptB modelo_path = 'caminho/para/o/modelo/large.pt' modelo = whisper.load_model(modelo_path) return modelo def main(): m = MyManager(address=('localhost', 50000), authkey=b'mypassword') m.connect() shared_data = m.get_shared_data() modelo = load_model() # Carregar o modelo do Whisper no ScriptB while True: # Verifique a flag no dicionário compartilhado para ver se existe um novo arquivo de áudio para ser transcrito # Assume-se que a chave `audio_ready` está presente no dicionário audio_ready = shared_data.get('audio_ready', False) if audio_ready: # Suponhamos que 'dictate.wav' seja o nome do arquivo que sabemos que será gravado por Script1 print("Transcrevendo 'dictate.wav' usando Whisper...") result = modelo.transcribe('dictate.wav') # ... Outro processamento do resultado da transcrição ... # Resetar a flag para indicar a conclusão da tarefa de transcrever o arquivo atual shared_data.update({'audio_ready': False}) # ... Possível lógica para dormir ou checar o dicionário periodicamente ... if __name__ == "__main__": main()Note que sempre que você reiniciar o processo que executa o ScriptB (ou qualquer script Python), e quer usar o modelo do Whisper, você precisará recarregar o modelo, pois o estado anterior não é persistido entre execuções.
Lembre-se também de que o modelo do Whisper é grande e possui uso intenso de recursos. Se você for carregar o modelo mais de uma vez (em múltiplos scripts ou instâncias), certifique-se de que seu sistema tem recursos suficientes para lidar com múltiplas cargas do modelo em memória simultaneamente.
- User
podias mostrar script da função de transcrição usando thred e quee
- Assistant
Claro, você pode utilizar threads e um sistema de fila para gerenciar e processar tarefas de transcrição assincronamente. Abaixo está um exemplo que utiliza a biblioteca
threadingequeuepara criar um sistema onde uma thread é dedicada a ouvir por novos arquivos de áudio e outra thread é responsável pela transcrição.import threading import queue import whisper import os import time # Define o caminho para o modelo do Whisper modelo_path = 'path/to/whisper/model.pt' # Inicializa a fila e carrega o modelo fora das threads para evitar recarregamento audio_queue = queue.Queue() modelo = whisper.load_model(modelo_path) def transcriber(): while True: # Espera por um novo arquivo de áudio na fila audio_path = audio_queue.get() print(f"Iniciando transcrição para: {audio_path}") try: # Realiza a transcrição usando o modelo do Whisper result = modelo.transcribe(audio_path) transcript = result['text'] print(f"Transcrição: {transcript}") # Processamento adicional... # Por exemplo, salvar a transcrição em um arquivo ou banco de dados except Exception as e: print(f"Erro ao transcrever arquivo {audio_path}: {e}") # Marca a tarefa como concluída para essa entrada de áudio audio_queue.task_done() # Remove o arquivo de áudio processado para limpar o espaço os.remove(audio_path) def audio_listener(): while True: # Simula a chegada de um novo arquivo de áudio (em produção, você teria lógica diferente) # Por exemplo, você pode verificar um diretório ou receber uma sinalização de outro processo # Para este exemplo, vamos apenas criar um nome de arquivo falso a cada 10 segundos time.sleep(10) audio_path = f"audio_{int(time.time())}.wav" print(f"Novo arquivo de áudio detectado: {audio_path}") # Adiciona o caminho do novo arquivo de áudio à fila de transcrição audio_queue.put(audio_path) def main(): # Cria e inicia a thread de transcrição transcriber_thread = threading.Thread(target=transcriber, daemon=True) transcriber_thread.start() # Cria e inicia a thread que ouve por novos arquivos de áudio audio_listener_thread = threading.Thread(target=audio_listener, daemon=True) audio_listener_thread.start() # Mantém o script principal vivo indefinidamente para que as threads criadas possam executar try: while True: time.sleep(1) except KeyboardInterrupt: print("Encerrando...") if __name__ == "__main__": main()Neste exemplo:
audio_listener: É uma função que simula a chegada de novos arquivos de áudio, no mundo real, você teria uma lógica para detectar novos arquivos (eg. watchdog para monitoramento de diretório). Cada novo arquivo é colocado na filaaudio_queue.transcriber: Uma função que continuamente espera por novos arquivos na filaaudio_queuee executa o processo de transcrição. É aqui que o modelo do Whisper é utilizado para transcrever o áudio, e quaisquer operações pós-transcrição podem ser feitas.main: Define e inicia as threadstranscriber_threadeaudio_listener_thread, depois entra em um loop para manter o programa principal em execução. Note que as threads são marcadas comodaemon=True, significando que elas serão encerradas quando o programa principal for encerrado.
Espero que este exemplo ajude a estruturar seu sistema de transcrição com o uso de threads e fila!
- User
mas tinhamos referido que o script B ia ser chamado para fazer a transcrição!?
- Assistant
Peço desculpa pela confusão e entendo que deseja processar as transcrições em um script separado, que chamamos de ScriptB. Para isso, você pode usar um mecanismo de fila de mensagens interprocessos.
O Python fornece a biblioteca
multiprocessingque tem uma implementação deQueueprópria para comunicação entre processos. Vamos adaptar o sistema para usarmultiprocessing.Queuee iniciar o ScriptB como um processo separado.Script1 (Produtor) - O script que capta o áudio e o coloca na fila.
# script1.py from multiprocessing import Process, Queue import time import os # Aqui, criamos a fila do multiprocessing. Esta fila permite a comunicação interprocessos. audio_queue = Queue() def listen_for_audio(audio_queue): # Simulação: Detecta novo áudio e coloca na fila. while True: # Alguma lógica para detecção e gravação de áudio... audio_path = 'path_to_new_audio_file.wav' print(f"Novo áudio detectado: {audio_path}") # Adiciona o que você precisa na fila - pode ser o caminho para o arquivo audio_queue.put(audio_path) # Espere um pouco antes de 'detectar' o próximo áudio time.sleep(10) def run_transcription_process(audio_queue): # Inicia o ScriptB como um subprocesso independente transcribe_process = Process(target=transcribe_audio, args=(audio_queue,)) transcribe_process.start() def transcribe_audio(audio_queue): # Este seria o código do seu ScriptB os.system('python scriptB.py') if __name__ == '__main__': # Inicie o processo de escuta por áudios listen_process = Process(target=listen_for_audio, args=(audio_queue,)) listen_process.start() # Inicie o processo de transcrição run_transcription_process(audio_queue) # Encerre o processo de escuta quando necessário # listen_process.terminate() # Quando você decidir encerrar a escutaScriptB (Consumidor) - O script que será chamado para processar a transcrição.
# scriptB.py from multiprocessing import Queue import whisper # Vamos supor que o modelo do Whisper é carregado aqui modelo = whisper.load_model('path/to/whisper/model.pt') def transcribe(audio_queue): while True: # Opere de forma bloqueante, esperando por um novo caminho de arquivo audio_path = audio_queue.get() print(f"Iniciando transcrição para: {audio_path}") # Aqui você transcreveria o áudio recebido result = modelo.transcribe(audio_path) # ... outras operações ... # Assim que terminar, você pode sinalizar que concluiu este objeto da fila # Note que, por estarmos em diferentes processos, audio_queue.task_done() não é necessário if __name__ == '__main__': audio_queue = Queue() transcribe(audio_queue)Note que o
scriptB.pyagora precisa ser uma entidade independente que possa ser iniciada separadamente. Ele irá entrar em um loop e esperar pelos novos caminhos de arquivos de áudio para transcrição. Oscript1.pyé responsável por colocar os caminhos de arquivos na fila e iniciar oscriptB.pycomo um processo separado.Neste exemplo, não estamos trazendo os detalhes de como terminar graciosamente os processos ou gerenciar erros para manter o exemplo focado na comunicação entre os scripts. Na prática, você deverá incluir tratamento de exceções e garantir que os recursos sejam limpos adequadamente quando os processos terminarem.
- User
Este seria o código do seu ScriptB os.system(‘python scriptB.py’) posso chamar o scriptB ou queres dizer inclui-lo aqui? já não necessito de utilizar?: #servidor.py:
from multiprocessing.managers import BaseManager from multiprocessing import Process, Manager
def start_server(): with Manager() as manager: # Aqui você define o dicionário compartilhado no gerenciador. shared_data = manager.dict({'num1': 0, 'num2': 0, 'nome1': '', 'nome2': ''})
# BaseManager é o mecanismo que permite acesso aos dados compartilhados de outro processo. class MyManager(BaseManager): pass # Registra o dicionário para ser compartilhado em 'shared_data'. MyManager.register('get_shared_data', callable=lambda: shared_data) # Inicializa o gerenciador com um endereço que o scriptB.py possa acessar. m = MyManager(address=('', 50000), authkey=b'mypassword') # Inicia o servidor. s = m.get_server() print('Server is starting…') s.serve_forever()if name == "main": start_server()
- Assistant
Você está correto, baseado no exemplo anterior, você não precisaria mais do código mostrado em
servidor.py, já que ele estava relacionado a um exemplo de uso doManagerpara datas compartilhadas entre processos, algo que não é mais necessário se você está usandomultiprocessing.Queuepara a comunicação entre os scripts.Referente à chamada do
scriptB.py, a funçãotranscribe_audionoscript1.pyapenas simula a chamada para oscriptB.pyusandoos.system. Isso não é a prática ideal para iniciar um novo processo Python a partir de outro script. Em vez disso, você deve utilizar o módulomultiprocessingpara iniciar oscriptBcomo um processo separado diretamente.Aqui está um exemplo de como o
script1.pypode iniciar oscriptB.pycorretamente como um novo processo:# script1.py from multiprocessing import Process, Queue import time # Crie a fila para comunicação entre processos audio_queue = Queue() def listen_for_audio(audio_queue): # Simulação: Detectar novo áudio e colocar os caminhos na fila while True: # Simular a captura de novo áudio após algum tempo time.sleep(5) audio_file_path = 'novo_audio.wav' # Você teria lógica de captura de áudio aqui print(f"Capturado novo áudio: {audio_file_path}") audio_queue.put(audio_file_path) def main(): # Cria um processo que executa o scriptB e passa a fila para ele p = Process(target=lambda q: exec(open('scriptB.py').read(), {'audio_queue': q}), args=(audio_queue,)) p.start() # Continua com a lógica de captura de áudio listen_for_audio(audio_queue) # Não se esqueça de unir o processo do scriptB quando tudo terminar p.join() if __name__ == '__main__': main()E o
scriptB.pyseria o processador consumidor da fila:# scriptB.py # Assumimos que este script é chamado pelo 'script1.py' e recebe a fila como um parâmetro 'audio_queue'. import whisper # Carregue o modelo do Whisper (pode exigir recursos significativos) modelo = whisper.load_model('path/to/whisper/model.pt') def transcribe(): while True: # Bloqueia até que um novo caminho de arquivo esteja disponível audio_path = audio_queue.get() print(f"Iniciando transcrição para: {audio_path}") # Faça a transcrição usando o modelo Whisper result = modelo.transcribe(audio_path) print(result['text']) # Para este exemplo, não há uma maneira elegante de lidar com o término # No caso real, você teria um mecanismo para sair do loop enquanto aguarda transcribe()Isso permite que você mantenha a lógica de transcrição separada no
scriptB.pyenquanto controla seu início e comunicação a partir doscript1.py. Essa abordagem também lhe dá maior controle sobre a inicialização e encerramento do processo de transcrição, garantindo que ele seja limpo e terminado corretamente. - User
em jeito de resumo podias adaptar o que fizeste atrás a: def process_transcription(self): global tex1 ... (o que punhas aqui)
- Assistant
Para adaptar a função
process_transcriptionno contexto de processamento de áudio e transcrição em um ambiente multi-threaded ou multi-process, e levando em consideração a utilização de umaQueuepara passagem do arquivo de áudio (comodictate.wavdo Script1 para o ScriptB), a função pode ser estruturada da seguinte maneira:# Script1 (Producer) - Captura áudio e coloca o caminho do arquivo na fila para processamento from multiprocessing import Process, Queue import time def capture_audio_and_enqueue(audio_queue): while True: # Simulação: Capturar e salvar áudio para 'dictate.wav' print("Gravando áudio...") time.sleep(5) # Simulação de tempo de gravação audio_path = 'dictate.wav' print(f"Áudio gravado e salvo como {audio_path}.") # Coloque o caminho do arquivo de áudio na fila audio_queue.put(audio_path) def main(): # Crie a fila para comunicação interprocesso audio_queue = Queue() # Inicia o Script1, que captura o áudio e coloca na fila producer = Process(target=capture_audio_and_enqueue, args=(audio_queue,)) producer.start() # Inicia o ScriptB, que irá processar os arquivos de áudio na fila consumer = Process(target=lambda q: exec(open('scriptB.py').read(), {'audio_queue': q}), args=(audio_queue,)) consumer.start() # Aguarde os processos terminarem (normalmente, você teria uma maneira de encerrar graciosamente) producer.join() consumer.join() if __name__ == '__main__': main()# ScriptB (Consumer) - Processa a transcrição dos arquivos de áudio da fila import whisper from multiprocessing import Queue # Nesse ponto, espera-se que a `Queue` seja injetada no ambiente do scriptB.py pelo script1.py # Se o scriptB.py estiver sendo chamado diretamente em um contexto de teste, defina uma nova `Queue` abaixo # audio_queue = Queue() def transcribe_audio(model, audio_queue): while True: audio_path = audio_queue.get() # Aguarda o próximo arquivo de áudio print(f"Iniciando transcrição para: {audio_path}") # Use o modelo carregado para transcrever o áudio result = model.transcribe(audio_path) transcript = result['text'] print(f"Transcrição completa: {transcript}") # Após a transcrição, você poderia salvar a transcrição, enviar para outro serviço, etc. # ... modelo = whisper.load_model('path/to/whisper/model.pt') # Substitua pelo caminho correto para o modelo transcribe_audio(modelo, audio_queue)Neste resumo, o Script1 age como o produtor, capturando áudio e colocando o caminho do arquivo na fila. Por outro lado, o ScriptB age como o consumidor, retirando os caminhos dos arquivos de áudio da fila e realizando a transcrição.
Lembre-se de que nesses exemplos:
- A variável
audio_queuedeve ser acessada globalmente por ambas as partes para que a comunicação seja realizada. exec(open('scriptB.py').read(), {'audio_queue': q})é uma forma simplificada e para demonstração. Em um ambiente de produção, a lógica deve ser encapsulada em uma função ou classe apropriada para ser importada e executada de forma mais limpa e segura.- O código simulado de gravação e o loop infinito devem ser substituídos pela lógica real de captura de áudio e um mecanismo de término apropriado.
- A variável
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.