hello
- User
hello
- Assistant
Hello! How can I assist you today?
- User
import pickle import tkinter as tk from tkinter import simpledialog from tkinter import messagebox from tkinter import filedialog from tkinter import Listbox from tkinter import ttk # ttk for improved styling import os import time import sounddevice as sd import noisereduce as nr import librosa import soundfile as sf import noisereduce as nr from pydub import AudioSegment from scipy.spatial.distance import euclidean from fastdtw import fastdtw
from pydub import AudioSegment import numpy as np
import colorama from colorama import Fore, Back, Style
colorama.init(autoreset=True) # Inicializa o colorama para resetar a cor após cada print
import sqlite3
from playsound import playsound
#1- Função 'record_audio' não alterar def record_audio(duration, fs, file_path): print(f"Gravando o comando por {duration} segundos…") audio = sd.rec(int(duration * fs), samplerate=fs, channels=1, dtype='float32') sd.wait() # Aguarda a gravação terminar sf.write(file_path, audio, fs) print(f"Gravação salva como: {file_path}")
# Retorna ao invés de solicitar a entrada do usuário return file_path#2- Função 'preprocess_audio' não alterar def preprocess_audio(filename, output_prefix): # Carregar o arquivo de áudio raw_audio, sample_rate = librosa.load(filename, sr=None)
# Reduzir ruído após normalização reduced_noise_audio = nr.reduce_noise(y=raw_audio, sr=sample_rate) # Salvando o áudio reduzido de ruído em um arquivo wav sf.write(f"{output_prefix}_resultado_ruido.wav", reduced_noise_audio, sample_rate) # Reamostrar áudio para uma taxa de amostragem padrão de 22050 Hz (se necessário) target_sr = 16000 # Atualize para a taxa de amostragem específica que seu reconhecedor de fala espera if sample_rate != target_sr: audio_resampled = librosa.resample(reduced_noise_audio, orig_sr=sample_rate, target_sr=target_sr) # Salvando áudio reamostrado se a taxa de amostragem for alterada sf.write(f"{output_prefix}_resultado_reamostragem.wav", audio_resampled, target_sr) else: audio_resampled = reduced_noise_audio return audio_resampled, target_sr#3- Função 'extract_mfcc' não alterar def extract_mfcc(audio, sample_rate): # Extrair MFCCs mfccs = librosa.feature.mfcc(y=audio, sr=sample_rate, n_mfcc=13) return mfccs.T # Transposta para alinhar frames como linhas
#4- Função 'connect_db' não alterar def connect_db(): conn = sqlite3.connect('commands.db') cursor = conn.cursor() cursor.execute(''' CREATE TABLE IF NOT EXISTS commands ( id INTEGER PRIMARY KEY AUTOINCREMENT, filename TEXT NOT NULL, transcription TEXT NOT NULL ) ''') conn.commit() return conn
#5- Função 'insert_command' não alterar
Função para inserir um novo comando no banco de dados
def insert_command(conn, filename, transcription): cursor = conn.cursor() cursor.execute('INSERT INTO commands (filename, transcription) VALUES (?, ?)', (filename, transcription)) conn.commit() return cursor.lastrowid
#6- Função 'list_commands' não alterar
Função para listar todos os comandos do banco de dados
def list_commands(conn): cursor = conn.cursor() cursor.execute('SELECT * FROM commands') return cursor.fetchall()
#7- Função 'tk_record_audio' não alterar def tk_record_audio(conn): # Aqui você pode pedir ao usuário para digitar a transcrição ou selecionar de uma lista existente transcription = simpledialog.askstring("Nome Comando", "Digite o nome do comando(transcrição):") if transcription: # Gera um nome de arquivo único file_name = f"command_{int(time.time())}.wav" file_path = os.path.join('C:\meu\comandos voz', file_name)
# Grava o áudio duration = 3 # Duração da gravação em segundos fs = 16000 # Frequência de amostragem record_audio(duration, fs, file_path) # Insira a transcrição e caminho do arquivo no banco de dados insert_command(conn, file_path, transcription) messagebox.showinfo("Sucesso", "O comando de voz foi gravado e salvo com sucesso.") return file_path # Deve retornar o caminho do arquivo para usar em process_sound else: messagebox.showwarning("Aviso", "A transcrição não foi fornecida.") return None # Retorna None se não houver transcrição#8- Função 'add_sound' não alterar
Esta função permite adicionar um novo som ao banco de dados, com a opção de gravar ou escolher um arquivo e com possibilidade de processamento de áudio
#2.1 - Botão para inserir som na BD: def add_sound(conn):
# Create a new window for the add sound dialog dialog_window = tk.Toplevel() dialog_window.title("Adicionar Som") dialog_window.geometry("300x100") # You can adjust the size as needed # Function to be called when 'Upload' button is pressed def upload_sound(): file_path = filedialog.askopenfilename(title="Selecionar Arquivo de Áudio", filetypes=[("Arquivos de Áudio", ".wav")]) if file_path: preprocess_audio(file_path, os.path.splitext(os.path.basename(file_path))[0]) transcription = simpledialog.askstring("Transcrição", "Digite a transcrição para o comando de voz do arquivo selecionado:", parent=dialog_window) if transcription: insert_command(conn, file_path, transcription) messagebox.showinfo("Sucesso", "O arquivo de voz foi adicionado com sucesso.", parent=dialog_window) dialog_window.destroy() else: messagebox.showwarning("Aviso", "Transcrição não fornecida.", parent=dialog_window) else: messagebox.showwarning("Aviso", "Nenhum arquivo foi selecionado.", parent=dialog_window) # Function to be called when 'Record' button is pressed def record_sound(): tk_record_audio(conn) dialog_window.destroy() # Create and position the two buttons within the dialog btn_upload = tk.Button(dialog_window, text="Upload", command=upload_sound) btn_upload.pack(side=tk.LEFT, padx=10, pady=20) btn_record = tk.Button(dialog_window, text="Gravar", command=record_sound) btn_record.pack(side=tk.RIGHT, padx=10, pady=20)#9- Função 'delete_sound_by_id' não alterar
Function to delete a sound by its database ID
def delete_sound_by_id(conn, cmd_id): if messagebox.askokcancel("Confirmar Exclusão", "Tem certeza que deseja excluir este comando?"): cursor = conn.cursor() cursor.execute('DELETE FROM commands WHERE id = ?', (cmd_id,)) conn.commit()
#10- Função 'delete_selected_sound' não alterar
Function to delete a selected sound from the GUI
def delete_selected_sound(conn):
Lista os comandos existentes para que o usuário escolha um para excluir
existing_commands = list_commands(conn) if not existing_commands: messagebox.showinfo("Info", "Não existem comandos para excluir.") return
Um dicionário para corresponder transcrição com ID do banco de dados
transcription_id_map = {cmd[2]: cmd[0] for cmd in existing_commands}
Assegura que o usuário pode selecionar uma transcrição para excluir a partir de uma lista
transcription_to_delete = simpledialog.askstring("Apagar Comando", "Escolha o comando para excluir:\n" + '\n'.join(transcription_id_map.keys())) if transcription_to_delete and transcription_to_delete in transcription_id_map: # Confirmação antes de excluir if messagebox.askokcancel("Confirmar Exclusão", "Tem certeza que deseja excluir este comando?"): # Executa a exclusão cursor = conn.cursor() cursor.execute('DELETE FROM commands WHERE id = ?', (transcription_id_map[transcription_to_delete],)) conn.commit() messagebox.showinfo("Info", "Comando excluído com sucesso.") else: messagebox.showinfo("Info", "Comando não encontrado ou exclusão cancelada.")
#11- Função 'show_records' não alterar def show_records(conn): commands_list = list_commands(conn) records = "\n".join(f"ID: {cmd[0]}, Transcription: {cmd[2]}" for cmd in commands_list) messagebox.showinfo("Registros da BD", records)
#12- Função 'test_sound_distance' a alterar local #(Mover para fora da função 'test_sound_distance') #12.1- Subfunção 'load_sound_list' a mover para escopo global #(Remover de dentro de 'test_sound_distance')
#13- Função 'add_mfcc_column_to_db' não alterar def add_mfcc_column_to_db(conn): cursor = conn.cursor() cursor.execute('''ALTER TABLE commands ADD COLUMN mfcc BLOB''') conn.commit()
#14- Função 'compute_and_store_mfccs' não alterar def compute_and_store_mfccs(conn): cursor = conn.cursor() cursor.execute('SELECT id, filename FROM commands WHERE mfcc IS NULL') commands_to_process = cursor.fetchall()
for cmd_id, file_path in commands_to_process: # Preprocess the audio file and extract the MFCC audio, sr = preprocess_audio(file_path, os.path.splitext(os.path.basename(file_path))[0]) mfccs = extract_mfcc(audio, sr) # Serialize the MFCCs for storage mfccs_bytes = sqlite3.Binary(pickle.dumps(mfccs, protocol=pickle.HIGHEST_PROTOCOL)) # Update the record with the computed MFCCs cursor.execute('UPDATE commands SET mfcc = ? WHERE id = ?', (mfccs_bytes, cmd_id)) conn.commit()#15- Função 'augment_audio' não alterar def augment_audio(file_path, conn): audio, sr = librosa.load(file_path, sr=None)
# Apply noise noise_factor = 0.02 audio_with_noise = audio + noise_factor * np.random.randn(len(audio)) # Apply pitch shifting pitch_factor = 2 # Number of steps to shift audio_with_pitch_shifted = librosa.effects.pitch_shift(audio, sr, pitch_factor) # Save augmented audios noise_file_path = file_path.replace('.wav', '_noise.wav') pitch_file_path = file_path.replace('.wav', '_pitch.wav') sf.write(noise_file_path, audio_with_noise, sr) sf.write(pitch_file_path, audio_with_pitch_shifted, sr) # Add noise and pitch-shifted versions to the database transcription = file_path.split('/')[-1].replace('.wav', '') insert_command(conn, noise_file_path, transcription + '_noise') insert_command(conn, pitch_file_path, transcription + '_pitch')#16- Função 'batch_augment' não alterar
def batch_augment(conn): cursor = conn.cursor() cursor.execute('SELECT filename FROM commands') existing_files = cursor.fetchall()
# Apply augmentation to each file for file_path, in existing_files: augment_audio(file_path, conn)#17- Função 'play_audio' não alterar
Função para reproduzir um arquivo de áudio
def play_audio(file_path): try: # Usa playsound para reproduzir o arquivo de áudio playsound(file_path) except Exception as e: messagebox.showerror("Erro", f"Não foi possível reproduzir o áudio: {e}")
#18- Função 'show_records_with_options' não alterar
Função que mostra os registros da BD com a opção de ouvir ou apagar
def show_records_with_options(conn): new_window = tk.Toplevel() new_window.title("Registros da BD com Opções")
listbox = Listbox(new_window) listbox.pack(fill="both", expand=True) commands_list = list_commands(conn) for index, (cmd_id, file_path, transcription) in enumerate(commands_list): listbox.insert(tk.END, f"{transcription} (ID: {cmd_id})") def play_selected_audio(): # Pega o index do item selecionado selected = listbox.curselection() if not selected: messagebox.showwarning("Aviso", "Selecione um registro para ouvir.") return index = selected[0] cmd_id, file_path, transcription = commands_list[index] play_audio(file_path) # Chama a função de reprodução de áudio def delete_selected_audio(): # Pega o index do item selecionado selected = listbox.curselection() if not selected: messagebox.showwarning("Aviso", "Selecione um registro para apagar.") return index = selected[0] cmd_id, file_path, transcription = commands_list[index] delete_sound_by_id(conn, cmd_id) # Chama a função de delete # Remove o item da listbox e da lista local listbox.delete(selected[0]) del commands_list[index] btn_play = tk.Button(new_window, text="Ouvir", command=play_selected_audio) btn_play.pack(side=tk.LEFT, padx=(10, 0)) btn_delete = tk.Button(new_window, text="Apagar", command=delete_selected_audio) btn_delete.pack(side=tk.RIGHT, padx=(0, 10))ESCOPO GLOBAL
Supondo que conn seja a sua conexão com a base de dados e
esteja disponível no escopo global.
global conn def load_sound_list(): # Certifique-se de que db_commands_listbox foi criada e está acessível global db_commands_listbox # Limpa a lista antes de adicionar novos itens db_commands_listbox.delete(0, tk.END)
# Obtém os dados da base de dados chamando a função list_commands commands = list_commands(conn) for command in commands: # Supondo que a função list_commands retorne os dados na ordem: (id, file_path, transcription) cmd_id, file_path, transcription = command # Insere os dados na db_commands_listbox db_commands_listbox.insert(tk.END, f"{transcription} (ID: {cmd_id})")Esta função deve ser chamada depois que db_commands_listbox for criada
e a sua conexão com a base de dados (conn) deve estar aberta.
ESCOPO GLOBAL
Definição da variável global
global db_commands_listbox
Função para criar o Listbox e atribuir ao db_commands_listbox no escopo global
def create_command_listbox(parent): global db_commands_listbox # Criar db_commands_listbox aqui db_commands_listbox = tk.Listbox(parent) db_commands_listbox.pack(fill="both", expand=True) # Suponha que a função load_sound_list preenche o db_commands_listbox e está definida corretamente load_sound_list() # Carregar a lista de sons
#19- Função 'filter_command_list' a mover para escopo global #(Remover de dentro de 'test_sound_distance' e colocar no nível superior do script) def filter_command_list(event=None): #global filtered_commands print("--filtro---") search_term = filter_var.get().lower() print(f"Termo de pesquisa: '{search_term}'") # Isso mostrará o termo de pesquisa no console #print(f"Filtragem pela palavra: {search_term}") # Adicionei para depuração db_commands_listbox.delete(0, tk.END) filtered_commands = [] # Vamos coletar os comandos filtrados aqui for cmd_id, file_path, transcription in list_commands(conn): if search_term in transcription.lower(): filtered_commands.append((cmd_id, transcription)) # Guardamos os comandos filtrados db_commands_listbox.insert(tk.END, f"{transcription} (ID: {cmd_id})") print(f"Comandos filtrados: {filtered_commands}") # Adicionei para depuração #20- Variável 'filter_var' a alterar local #(Definir no escopo global, fora de qualquer função) #filter_var = tk.StringVar() #20.1- Subcomponente 'filter_entry' a alterar local #(Definir no escopo global, fora de qualquer função)
#21- Ligação dos eventos 'trace' e 'bind' a alterar local #(Mover para fora de qualquer função, geralmente próximo à definição de 'filter_entry') #21.1- Ligação de 'filter_var.trace' com 'filter_command_list' #21.2- Ligação de 'filter_entry.bind' com 'filter_command_list'
#escopo global #Certifique-se de que as demais funções e variáveis globais referenciadas no main, como filter_command_list, load_sound_list e tk_record_audio, estejam definidas no escopo global fora de qualquer outra função, para que sejam acessíveis dentro do main. #será necessário adaptar e garantir que as variáveis listbox, conn, e closest_sounds estejam acessíveis no escopo global, para que possam ser usadas dentro dessas funções refatoradas.
Subfunção para atualizar a listbox com as distâncias dos comandos
def update_listbox_with_distances(test_sound_path, closest_sounds):
listbox.delete(0, tk.END) listbox.insert(tk.END, "------ Comando utilizado para comparação ------") listbox.insert(tk.END, test_sound_path) # Caminho para o arquivo carregado/gravado listbox.insert(tk.END, "-----------------------------------------------") for ((cmd_id, file_path, transcription), distance) in closest_sounds: listbox.insert(tk.END, f"{transcription} (ID: {cmd_id}, Distância: {distance:.2f})")Função para lidar com a lógica de salvar comando na base de dados
def save_command(test_sound_path, transcription): if test_sound_path and transcription: insert_command(conn, test_sound_path, transcription) messagebox.showinfo("Salvar Comando", "Comando salvo na base de dados com sucesso!") else: messagebox.showwarning("Salvar Comando", "Não foi possível obter o caminho do arquivo ou a transcrição.")
Função para reproduzir o áudio selecionado
def play_selected_audio(): selected = listbox.curselection() if selected: index = selected[0] _, file_path, _ = closest_sounds[index][0] play_audio(file_path)
Função para carregar um áudio do sistema de arquivos
def upload_sound(): test_sound_path = filedialog.askopenfilename(title="Selecionar Arquivo de Áudio", filetypes=[("Arquivos de Áudio", "*.wav")]) if test_sound_path: process_sound(test_sound_path)
Função para gravar um novo áudio
def record_sound(): file_path = tk_record_audio(conn) if file_path: process_sound(file_path)
Função principal 'test_sound_distance' que cria a janela de diálogo
def test_sound_distance(conn, root): global db_commands_listbox, listbox # Cria janela de diálogo e configura painéis esquerdo e direito dialog_window = tk.Toplevel(root) dialog_window.title("Testar Distância dos Sons") dialog_window.geometry("800x600")
left_panel = ttk.Frame(dialog_window, width=400, height=600) left_panel.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) right_panel = ttk.Frame(dialog_window, width=400, height=600) right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True) # Componentes de interface do Painel esquerdo # Cria listbox e botões na janela de diálogo listbox = tk.Listbox(left_panel) listbox.pack(fill="both", expand=True) btn_upload = tk.Button(left_panel, text="Upload", command=upload_sound) btn_upload.pack(pady=5) # Componentes de interface do Painel Direito # Lista de comandos da base de dados (db_commands_listbox) db_commands_listbox = tk.Listbox(right_panel) db_commands_listbox.pack(fill="both", expand=True, pady=10) # Carregar e exibir a lista de sons quando a janela for aberta. load_sound_list() #caixa de filtro psquisa filter_var = tk.StringVar() filter_entry = ttk.Entry(right_panel, textvariable=filter_var) filter_entry.pack(fill="x", pady=5) # Vincula os eventos para o input de filtro. filter_entry.bind('<KeyRelease>', filter_command_list) btn_record = tk.Button(left_panel, text="Gravar", command=record_sound) btn_record.pack(pady=5) btn_play = tk.Button(left_panel, text="Ouvir", command=play_selected_audio) btn_play.pack(pady=5) save_button = ttk.Button(left_panel, text="Salvar Comando", command=lambda: save_command()) save_button.pack(side=tk.BOTTOM, pady=5) # Garantir que a janela de diálogo seja modal dialog_window.transient(root) dialog_window.grab_set() # Aguarda o fechamento da janela de diálogo root.wait_window(dialog_window)ESCOPO GLOBAL
Variáveis globais que serão usadas em process_sound e outras funções
closest_sounds = []
Subfunção para atualizar a listbox com as distâncias dos comandos
Presumindo que listbox esteja definida globalmente ou seja passada como argumento
def update_listbox_with_distances(test_sound_path, closest_sounds): # … [código da função] …
listbox.delete(0, tk.END) # Limpa a listbox antes da atualização.# Insere o cabeçalho e o caminho do áudio testado no topo da listbox. listbox.insert(tk.END, "------ Comando utilizado para comparação ------") listbox.insert(tk.END, test_sound_path) # Caminho para o arquivo carregado/gravado. listbox.insert(tk.END, "-----------------------------------------------") # Insere as cinco menores distâncias na listbox. for (cmd_info, distance) in closest_sounds: cmd_id, file_path, transcription = cmd_info listbox.insert(tk.END, f"{transcription} (ID: {cmd_id}): Distância = {distance:.2f}")Função global para calcular e mostrar as distâncias do som carregado em relação aos sons da base de dados
Presumindo que listbox e closest_sounds estejam definidos globalmente ou sejam passados como argumentos
def process_sound(test_sound_path): global closest_sounds # Usa a variável global para armazenar as distâncias closest_sounds = [] # Reseta a lista de distâncias mais próximas a cada chamada
# Pré-processa o áudio do arquivo de teste e extrai os MFCCs test_audio, test_sr = preprocess_audio(test_sound_path, os.path.splitext(os.path.basename(test_sound_path))[0]) test_mfccs = extract_mfcc(test_audio, test_sr) # Calcula as distâncias para todos os sons na base de dados commands_list = list_commands(conn) distance_results = {} # Calcula a distância entre o comando testado e cada comando na base de dados for cmd_id, file_path, transcription in commands_list: if file_path != test_sound_path: # Ignora o próprio som de teste audio, sr = preprocess_audio(file_path, os.path.splitext(os.path.basename(file_path))[0]) mfccs = extract_mfcc(audio, sr) distance, path = fastdtw(test_mfccs, mfccs, dist=euclidean) distance_results[(cmd_id, file_path, transcription)] = distance # Encontra os 5 sons mais próximos closest_sounds = sorted(distance_results.items(), key=lambda item: item[1])[:5] # Atualiza a listbox com as distâncias calculadas e o caminho do som carregado/gravado update_listbox_with_distances(test_sound_path, closest_sounds)""" A função process_sound tem a tarefa de:
- Pré-processar o áudio do arquivo de teste usando preprocess_audio.
- Extrair os Mel Frequency Cepstral Coefficients (MFCCs) do áudio pré-processado com a função extract_mfcc.
- Computar a distância do MFCC do som de teste para cada som na base de dados usando a função fastdtw para calcular a distância Dynamic Time Warping (DTW) junto com a distância euclidiana (euclidean).
- Ordenar os resultados e selecionar os cinco sons mais próximos.
- Atualizar a listbox com as distâncias e o caminho do arquivo de teste usando a função update_listbox_with_distances.
Função para salvar um comando na base de dados
Presumindo uma variável global ou local chamada listbox para acessar a seleção atual """
def save_command(): # Obtém o índice da entrada selecionada na listbox selected_index = listbox.curselection() if not selected_index: messagebox.showwarning("Aviso", "Selecione um comando da lista para salvar.") return
test_sound_path = listbox.get(selected_index[0]) # Verifica se o item selecionado é realmente um caminho para um áudio if "------ Comando utilizado para comparação ------" in test_sound_path or "-----------------------------------------------" in test_sound_path: messagebox.showerror("Erro", "Por favor, selecione um comando de áudio válido.") return transcription = simpledialog.askstring("Transcrição", "Digite a transcrição do comando:") if test_sound_path and transcription: # Insere o comando na base de dados. Presume-se que conn seja acessível globalmente insert_command(conn, test_sound_path, transcription) messagebox.showinfo("Salvar Comando", "Comando salvo na base de dados com sucesso!") else: messagebox.showwarning("Salvar Comando", "Não foi possível obter o caminho do arquivo ou a transcrição.")#22- Função 'main' a alterar conteúdo #(Incluir a inicialização e chamada de 'load_sound_list' após a inicialização da interface) def main(): # Conexão com o banco de dados SQLite global conn conn = connect_db()
# Cria a janela principal com tkinter root = tk.Tk() root.title("Voice Command Recorder") # Definição dos botões na janela principal btn_record = tk.Button(root, text="Gravar Novo Comando", command=lambda: tk_record_audio(conn)) btn_record.pack(pady=10) btn_add_sound = tk.Button(root, text="Adicionar Som", command=lambda: add_sound(conn)) btn_add_sound.pack(pady=10) btn_delete_sound = tk.Button(root, text="Apagar Som", command=lambda: delete_selected_sound(conn)) btn_delete_sound.pack(pady=10) btn_show_records_with_options = tk.Button(root, text="Listar Ouvir Apagar", command=lambda: show_records_with_options(conn)) btn_show_records_with_options.pack(pady=10) btn_test_distance = tk.Button(root, text="Testar Distância", command=lambda: test_sound_distance(conn, root)) btn_test_distance.pack(pady=10) btn_augmentation = tk.Button(root, text="Audio Augmentation", command=lambda: batch_augment(conn)) btn_augmentation.pack(pady=10) #TK1 - Painel direito (para uso na janela principal e não na janela de diálogo) right_panel = ttk.Frame(root, width=200, height=600) right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True) #TK5 - Lista de comandos da base de dados (db_commands_listbox) global db_commands_listbox db_commands_listbox = tk.Listbox(right_panel) db_commands_listbox.pack(fill="both", expand=True, pady=10) #20 - Variável 'filter_var' definida no escopo global global filter_var filter_var = tk.StringVar() #20.1 - Subcomponente 'filter_entry' definido no escopo global filter_entry = ttk.Entry(right_panel, textvariable=filter_var) filter_entry.pack(fill="x", pady=5) #21 - Vinculação dos eventos à função de filtragem filter_var.trace('w', filter_command_list) filter_entry.bind('<KeyRelease>', filter_command_list) # Chamar 'load_sound_list' para carregar a lista de sons da base de dados na inicialização load_sound_list() # Inicia o loop da interface gráfica root.mainloop() # Fechar a conexão com o banco de dados ao encerrar o programa conn.close()if name == 'main': main()
eu tenho estado a fazer um projeto contigo vou-te mostrar o código e há uns erros e uns acrescentos que eu queria fazer que me ajudasse a fazer, estou a trabalhar no botão de testar distâncias em que aparece dois painéis um do lado esquerdo e outro do lado direito neste momento estou a implementar coisas com o painel do lado direito . Painel direito 2 caixas texto Caixa de lista de comandos Caixa pesquisa/filtro funcionalidade 5 5Possibilidade para filtrar a lista, À medida que escrevo a palavra na caixa de listagem, vai mostrando a lista de palavras/comandos que atendem esse critério. Isto não funciona Já tentámos fazer o debug, mas não se conseguiu pôr a funcionar. ao escrever um caratere na caixa Aparecem no cmd todos os comandos da lista mas não é realizado aquilo que é supostamente ser feito.
Vou deixar esta funcionalidade para realizar mais tarde, a não ser que tenhas uma sugestão que aches que seja fácil de pôr a funcionar. Vou concentrar-me na realização da tarefa 6. 6Ao escolher -duplo clique em item da lista-um som/comando da listata Mostra, no Painel esquerdo, as 5 menores distâncias em relação a esse som/comando, Da mesma forma que é feito quando se carrega no botão Upload/Gravar e se escolhe um som/comando eu queria que me mostrasse código para esta funcionalidade funcionar e aonde o devo colocar - Assistant
Vamos resolver os dois problemas que você mencionou: a funcionalidade de filtragem no painel direito e mostrar as 5 menores distâncias no painel esquerdo ao realizar um duplo clique em um item da lista no painel direito.
Primeiro, vamos nos concentrar em corrigir a funcionalidade de filtragem.
O código já define uma função
filter_command_listque deve ser chamada quando o texto na caixa de pesquisa muda. No entanto, parece que há um problema com a forma como essa função é vinculada. A variávelfilter_vare a caixa de entradafilter_entryprecisam ser declaradas corretamente e vinculadas à função.Corrija o seguinte codigo no escopo global, logo após a declaração da função
filter_command_list:# Variável para a caixa de filtragem (deve ser global) filter_var = tk.StringVar() # Vincular as mudanças na variável à função de filtragem (considere mover para perto de onde você constrói a GUI) filter_var.trace("w", lambda name, index, mode, sv=filter_var: filter_command_list())E correção na função de inicialização da caixa de entrada de filtro:
# Corrigir definição de filter_entry para que use 'filter_var' corretamente filter_entry = ttk.Entry(right_panel, textvariable=filter_var) filter_entry.pack(fill="x", pady=5)Depois de corrigir a funcionalidade de filtragem, vamos adicionar o recurso de escutar o evento de duplo clique na lista de comandos para mostrar as 5 menores distâncias. Primeiro, vamos definir uma função para lidar com o duplo clique na lista do painel direito.
Adicione esta função no escopo global:
def on_listbox_double_click(event): # Recupera o índice do item selecionado no Listbox index = db_commands_listbox.curselection() if not index: return # Recupera o caminho do arquivo de áudio associado ao comando selecionado selected_cmd_id, selected_file_path, selected_transcription = list_commands(conn)[index[0]] # Supondo que você já tem uma função chamada process_sound que pode aceitar um caminho de arquivo # e exibir as 5 menores distâncias. process_sound(selected_file_path)Esta função deve ser vinculada ao evento de duplo clique do Listbox
db_commands_listboxque é criado no painel direito. Adicione o seguinte código perto de onde você cria o Listbox do painel direito:# Vincula o evento de duplo clique ao Listbox db_commands_listbox.bind('<Double-1>', on_listbox_double_click)Agora, ao clicar duas vezes em um item da lista, a função
on_listbox_double_clickserá chamada, e ela usará a funçãoprocess_soundpara calcular e exibir as 5 menores distâncias relacionadas com o comando escolhido.Certifique-se de que a função
process_soundesteja devidamente implementada e atualize o Listbox no painel esquerdo com os resultados das distâncias calculadas. Essas etapas devem ajudar a avançar seu projeto e implementar as funcionalidades desejadas. - User
aonde meto isyo: E correção na função de inicialização da caixa de entrada de filtro:
Corrigir definição de filter_entry para que use ‘filter_var’ corretamente
filter_entry = ttk.Entry(right_panel, textvariable=filter_var) filter_entry.pack(fill=“x”, pady=5)
- Assistant
A correção para a caixa de entrada de filtro, onde você define
filter_entry, deve estar no escopo global, mas dentro da função principal de sua aplicação (main). Ela deve ser colocada depois de criar a janela principal com Tkinter e aright_panel, que é onde os componentes da interface gráfica estão sendo criados.Aqui está como seu código deve parecer após as definições e construção dos componentes da interface gráfica:
def main(): # ... (seu código anterior) # Cria a janela principal com tkinter root = tk.Tk() root.title("Voice Command Recorder") # ... (seu código de criação de outros componentes) # TK1 - Painel direito (para uso na janela principal e não na janela de diálogo) right_panel = ttk.Frame(root, width=200, height=600) right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True) # Caixa de entrada de filtro global filter_var filter_var = tk.StringVar() # Corrigir definição de filter_entry para que use ‘filter_var’ corretamente filter_entry = ttk.Entry(right_panel, textvariable=filter_var) filter_entry.pack(fill="x", pady=5) # Vincular as mudanças na variável à função de filtragem filter_var.trace("w", lambda name, index, mode, sv=filter_var: filter_command_list()) filter_entry.bind('<KeyRelease>', filter_command_list) # ... (seu código de criação de outros componentes e carregamento inicial de dados) # Inicia o loop da interface gráfica root.mainloop() # ... (seu código para fechar a conexão com o banco de dados) if __name__ == '__main__': main()Atenção para não duplicar o código. Se você já declarou
filter_varefilter_entryem algum lugar no código, não precisará declará-los novamente. Basta garantir que estão no lugar correto e que suas propriedades estejam configuradas adequadamente como indicado. - User
e ainda tenho o erro repara no debug def filter_command_list(event=None): #global filtered_commands #print("--filtro---") search_term = filter_var.get().lower() print(f"Termo de pesquisa: '{search_term}'") # Isso mostrará o termo de pesquisa no console para qualquer caractere que eu introduza na caixa aparece sempre A mesma coisa. Comandos filtrados: [(3, 'command'), (5, 'true'), (8, 'tricks'), (11, 'hello'), (12, 'hello'), (13, 'todo'), (14, 'model'), (15, 'table'), (16, 'window'), (19, 'hello'), (20, 'my'), (21, 'your'), (22, 'first'), (23, 'face'), (24, 'mister'), (25, 'list'), (26, 'my'), (27, 'save'), (29, 'minha'), (33, 'mm'), (34, 'outra'), (35, 'todo')] --filtro--- Termo de pesquisa: '' Comandos filtrados: [(3, 'command'), (5, 'true'), (8, 'tricks'), (11, 'hello'), (12, 'hello'), (13, 'todo'), (14, 'model'), (15, 'table'), (16, 'window'), (19, 'hello'), (20, 'my'), (21, 'your'), (22, 'first'), (23, 'face'), (24, 'mister'), (25, 'list'), (26, 'my'), (27, 'save'), (29, 'minha'), (33, 'mm'), (34, 'outra'), (35, 'todo')] --filtro--- Termo de pesquisa: '' Comandos filtrados: [(3, 'command'), (5, 'true'), (8, 'tricks'), (11, 'hello'), (12, 'hello'), (13, 'todo'), (14, 'model'), (15, 'table'), (16, 'window'), (19, 'hello'), (20, 'my'), (21, 'your'), (22, 'first'), (23, 'face'), (24, 'mister'), (25, 'list'), (26, 'my'), (27, 'save'), (29, 'minha'), (33, 'mm'), (34, 'outra'), (35, 'todo')]
- Assistant
Parece que a função
filter_command_listestá sendo chamada, mas a filtragem não está funcionando corretamente. Uma possível causa para esse comportamento é que a lista de comandos filtrados está sendo preenchida incorretamente. Vou revisar a função de filtragem e fornecer um exemplo corrigido abaixo para garantir que ela funcione conforme esperado.Antes de tudo, vamos ajustar a função
filter_command_listpara garantir que ele limpe oListboxde comandos antes de preencher com os itens filtrados e verificar se a filtragem está sendo realizada corretamente:def filter_command_list(event=None): search_term = filter_var.get().lower() print(f"Termo de pesquisa: '{search_term}'") # Isso mostrará o termo de pesquisa no console # Primeiro, limpe o 'Listbox' para preenchê-lo com os resultados filtrados db_commands_listbox.delete(0, tk.END) # Obtêm os comandos da base de dados commands = list_commands(conn) for cmd_id, file_path, transcription in commands: if search_term in transcription.lower(): # Se o termo de pesquisa estiver contido na transcrição, adicione ao 'Listbox' db_commands_listbox.insert(tk.END, f"{transcription} (ID: {cmd_id})")Certifique-se de que o evento está sendo vinculado corretamente à variável
filter_vare àEntryno painel direito. Esses trechos de código devem estar na funçãomain, onde você define a interface gráfica:# Declaração da variável 'filter_var' que será usada para filtrar a lista de comandos filter_var = tk.StringVar() filter_var.trace_add('write', filter_command_list) # Atualiza o método de vinculação # Adicionado o trace_add aqui para que a função de filtragem seja chamada sempre que o texto mudar filter_var.trace_add("write", filter_command_list) # Troque "w" por "write" para a nova versão do Tkinter # Criação da caixa de entrada de filtro no painel direito filter_entry = ttk.Entry(right_panel, textvariable=filter_var) filter_entry.pack(fill="x", pady=5)Note que o
trace_addé o método correto para vincular uma função de callback a uma variável em versões mais recentes do Tkinter. Se você estiver usando a versão 8.5 ou anterior, usetraceem vez detrace_add.Após essas mudanças, a funcionalidade de filtragem deve funcionar conforme esperado, atualizando o
db_commands_listboxcom os comandos filtrados à medida que você digita na caixa de pesquisa.Lembre-se de testar o funcionamento da filtragem após realizar essas mudanças e ajustar conforme necessário para garantir que o comportamento desejado seja alcançado.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.
Identical first prompt
- gpt-4-0314Compare side by side →
- gpt-4-0314Compare side by side →
- gpt-3.5-turbo-0301Compare side by side →
- gpt-3.5-turbo-0301Compare side by side →
- gpt-4-0314Compare side by side →
- gpt-4-0314Compare side by side →
- gpt-3.5-turbo-0301Compare side by side →
- gpt-4-0314Compare side by side →
- gpt-4-0314Compare side by side →
- gpt-4-0314Compare side by side →
- gpt-3.5-turbo-0301Compare side by side →
claude-instant-1Compare side by side →