Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

script1 from scipy.io.wavfile import write import numpy as np import whisper import os…

  1. 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

  2. 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.wav para o ScriptB.py, você tem algumas opções. Vou sugerir uma abordagem que você pode usar com a sua arquitetura atual:

    1. No ScriptA.py (ou no seu script de captura de áudio original), após gravar dictate.wav, você pode definir um indicativo no dicionário compartilhado que um arquivo está pronto para ser transcrito.

    2. No ScriptB.py, você terá uma lógica de loop que continuamente verifica esse indicativo no dicionário compartilhado.

    3. Quando o ScriptB.py detectar que o arquivo está pronto, ele pode realizar a transcrição.

    Aqui está como você pode modificar o ScriptB.py para 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 o dictate.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.

  3. 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

  4. Assistant

    Peço desculpas pela confusão. Se você deseja transferir o arquivo de áudio dictate.wav do 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)

    1. Grava o áudio e salva como dictate.wav.
    2. Atualiza shared_data com uma flag para indicar que um novo arquivo está pronto, por exemplo: shared_data.update({'audio_ready': True}).

    ScriptB.py (Transcrição e processamento)

    1. Em um loop contínuo, verifica a flag audio_ready no shared_data.
    2. Quando audio_ready for True, ele sabe que há um novo arquivo dictate.wav para processar.
    3. Realiza o pré-processamento necessário no áudio, como limpeza de ruído, normalização etc.
    4. Utiliza um modelo (por exemplo, o modelo do Whisper) para transcrever o dictate.wav.
    5. Após a conclusão da transcrição, atualiza shared_data para 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.wav enquanto o ScriptB ainda está processando o arquivo anterior. Para resolver isso, você pode:

    • Fazer com que o ScriptA aguarde a flag audio_ready ser resetada para False antes 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.

  5. 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

  6. 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.

  7. User

    podias mostrar script da função de transcrição usando thred e quee

  8. 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 threading e queue para 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 fila audio_queue.
    • transcriber: Uma função que continuamente espera por novos arquivos na fila audio_queue e 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 threads transcriber_thread e audio_listener_thread, depois entra em um loop para manter o programa principal em execução. Note que as threads são marcadas como daemon=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!

  9. User

    mas tinhamos referido que o script B ia ser chamado para fazer a transcrição!?

  10. 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 multiprocessing que tem uma implementação de Queue própria para comunicação entre processos. Vamos adaptar o sistema para usar multiprocessing.Queue e 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 escuta
    

    ScriptB (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.py agora 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. O script1.py é responsável por colocar os caminhos de arquivos na fila e iniciar o scriptB.py como 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.

  11. 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()

  12. 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 do Manager para datas compartilhadas entre processos, algo que não é mais necessário se você está usando multiprocessing.Queue para a comunicação entre os scripts.

    Referente à chamada do scriptB.py, a função transcribe_audio no script1.py apenas simula a chamada para o scriptB.py usando os.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ódulo multiprocessing para iniciar o scriptB como um processo separado diretamente.

    Aqui está um exemplo de como o script1.py pode iniciar o scriptB.py corretamente 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.py seria 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.py enquanto controla seu início e comunicação a partir do script1.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.

  13. User

    em jeito de resumo podias adaptar o que fizeste atrás a: def process_transcription(self): global tex1 ... (o que punhas aqui)

  14. Assistant

    Para adaptar a função process_transcription no 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 uma Queue para passagem do arquivo de áudio (como dictate.wav do 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_queue deve 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.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.