🎶JARVIS DJ: Criando Playlists Inteligentes e Comandos Musicais com Python

Projeto CodeVerse Python – #42/2025

👋 Fala, galera dev!

Bem-vindos a mais um episódio da nossa saga CodeVerse Python 2025! No artigo anterior (#41), aprendemos e ensinamos nosso JARVIS a tocar músicas diretamente do YouTube por comando de voz, um passo importante para transformar e evoluir nosso assistente em um companheiro realmente que nos ajuda em nosso dia a dia, automazando de forma real nossos pedidos.

Mas, se o Tony Stark não repete uma armadura, por que nós repetiríamos o mesmo código? 😏 Hoje vamos evoluir esse recurso, dando ao JARVIS a capacidade de criar playlists inteligentes, lembrar preferências musicais e até tocar sons aleatórios de acordo com o seu humor ou desejo do momento.

É aqui que o nosso assistente começa a ganhar personalidade, aprendendo o que gostamos de ouvir e se tornando, pouco a pouco, um DJ pessoal no estilo Stark Industries. 🎧

🧠 Como o JARVIS entende o que você quer ouvir

Antes de irmos ao código, vale entender a lógica. O JARVIS vai escutar seu comando (“Jarvis, toque minha playlist de treino”), identificar palavras-chave e decidir o que fazer com base nelas. E para isso, vamos usar:

speech_recognition → para converter voz em texto;
pyttsx3 → para dar voz ao Jarvis;
json → para guardar suas preferências musicais (memória local);
webbrowser → para abrir o YouTube diretamente na busca da música ou playlist;
random → para tocar músicas aleatórias quando você pedir algo como “Jarvis, me surpreenda”.

Ou seja, estamos unindo tudo o que já aprendemos em artigos anteriores, fala, escuta, memória e integração web, em uma só funcionalidade.

🐍 Parte 1 – Criando o arquivo de memória de playlists

Antes de tudo, vamos permitir que o JARVIS lembre suas playlists. Assim, se você disser uma vez “Jarvis, salvar playlist de treino”, ele vai guardar e, da próxima vez, tocar automaticamente sem precisar perguntar.

import json

arquivo_playlists = "playlists_jarvis.json"

def salvar_playlist(nome, link):
  try:
      with open(arquivo_playlists, "r") as f:
          playlists = json.load(f)
  except FileNotFoundError:
      playlists = {}

  playlists[nome.lower()] = link

  with open(arquivo_playlists, "w") as f:
      json.dump(playlists, f)

def obter_playlist(nome):
  try:
      with open(arquivo_playlists, "r") as f:
          playlists = json.load(f)
      return playlists.get(nome.lower(), None)
  except FileNotFoundError:
      return None

📘 Como funciona: O código cria um arquivo playlists_jarvis.json, que é basicamente a “memória musical” do nosso assistente.

Quando você salva uma playlist, o Jarvis grava o nome e o link no formato nome: link.
Quando pede para tocar, ele procura o nome no arquivo e abre o link salvo.

Esse trecho cria uma “memória musical” simples para o Jarvis usando um arquivo JSON — pense nele como um caderno onde o assistente anota o nome da sua playlist e o link correspondente. Logo no começo, import json traz a ferramenta que permite transformar dados do Python em texto JSON e vice-versa. Em seguida, arquivo_playlists = "playlists_jarvis.json" define o nome do arquivo onde essas anotações serão guardadas; se ainda não existir, será criado quando salvarmos a primeira playlist.

A função salvar_playlist(nome, link) é quem faz a anotação. Primeiro ela tenta abrir o arquivo em modo de leitura e carregar o conteúdo com json.load. Se o arquivo não existir ainda, cai no except FileNotFoundError e começa com um dicionário vazio, como um caderno em branco. Depois, registra a playlist usando a chave em minúsculas (nome.lower()) para evitar diferenças entre “Treino”, “treino” ou “TREINO”. Por fim, reabre o arquivo em modo de escrita e salva o dicionário atualizado com json.dump. Isso garante persistência: mesmo que você feche o programa, as playlists continuam lá no disco.

Já a função obter_playlist(nome) é a parte da “consulta”. Ela tenta abrir e ler o mesmo arquivo JSON, transformando o conteúdo em um dicionário. Daí, procura a chave correspondente ao nome pedido (também em minúsculas) e retorna o link se encontrar; se não houver essa entrada, devolve None. Caso o arquivo inteiro não exista (porque nada foi salvo ainda), ela também retorna None, indicando educadamente que não há playlists registradas.

Em resumo, salvar_playlist escreve (ou atualiza) uma entrada “nome → link” no arquivo JSON, e obter_playlist lê esse arquivo para devolver o link associado ao nome informado. É uma solução leve, fácil de entender e suficiente para dar ao Jarvis a capacidade de lembrar suas playlists favoritas entre uma execução e outra.

🎧 Parte 2 – Fazendo o Jarvis tocar e aprender

Agora vem a parte divertida! Vamos integrar o reconhecimento de voz, a voz do Jarvis e a reprodução no navegador.

import speech_recognition as sr
import pyttsx3
import webbrowser
import random
import json

engine = pyttsx3.init()
r = sr.Recognizer()
arquivo_playlists = "playlists_jarvis.json"

def falar(texto):
  engine.say(texto)
  engine.runAndWait()

def salvar_playlist(nome, link):
  try:
      with open(arquivo_playlists, "r") as f:
          playlists = json.load(f)
  except FileNotFoundError:
      playlists = {}
  playlists[nome.lower()] = link
  with open(arquivo_playlists, "w") as f:
      json.dump(playlists, f)

def obter_playlist(nome):
  try:
      with open(arquivo_playlists, "r") as f:
          playlists = json.load(f)
      return playlists.get(nome.lower(), None)
  except FileNotFoundError:
      return None

def tocar_playlist(nome):
  link = obter_playlist(nome)
  if link:
      falar(f"Tocando sua playlist {nome}, senhor.")
      webbrowser.open(link)
  else:
      falar("Não encontrei essa playlist, senhor.")

with sr.Microphone() as source:
  falar("Estou ouvindo, senhor. O que deseja ouvir?")
  audio = r.listen(source)

try:
  comando = r.recognize_google(audio, language="pt-BR").lower()

  if "salvar playlist" in comando:
      falar("Qual o nome da playlist?")
      with sr.Microphone() as source:
          audio = r.listen(source)
      nome = r.recognize_google(audio, language="pt-BR")

      falar("Qual o link da playlist, senhor?")
      link = input("Cole aqui o link do YouTube: ")
      salvar_playlist(nome, link)
      falar(f"Playlist {nome} salva com sucesso.")

  elif "tocar playlist" in comando:
      nome = comando.replace("tocar playlist", "").strip()
      tocar_playlist(nome)

  elif "me surpreenda" in comando:
      opcoes = [
          "https://www.youtube.com/watch?v=LYU-8IFcDPw",
          "https://www.youtube.com/watch?v=5abamRO41fE",
          "https://www.youtube.com/watch?v=RUi54JTgL5s",
      ]
      musica = random.choice(opcoes)
      falar("Deixe comigo, senhor. Escolhi algo especial.")
      webbrowser.open(musica)

  else:
      falar("Desculpe, não entendi o comando musical, senhor.")

except:
  falar("Não consegui entender o que disse, senhor.")

🎵 Como o código funciona:

O Jarvis ouve o comando.
Se você disser “salvar playlist de treino”, ele pede o link e guarda.
Se disser “tocar playlist de treino”, ele busca no arquivo e abre no YouTube.
Se disser “me surpreenda”, ele escolhe uma música aleatória e toca.

Primeiro, ele importa as “peças” que vamos usar. speech_recognition é o ouvido do Jarvis: capta sua voz e transforma em texto. pyttsx3 é a boca: transforma texto em fala para o Jarvis responder. webbrowser abre o navegador no endereço que a gente mandar (no caso, links do YouTube). random serve para escolher algo aleatoriamente quando pedirmos “me surpreenda”. E json é o formato de arquivo onde o Jarvis guarda e lê as playlists salvas (uma memória simples em disco).

Logo em seguida, o código inicializa a voz (pyttsx3.init()) e o reconhecedor de fala (sr.Recognizer()). Também define o nome do arquivo onde as playlists ficam guardadas: playlists_jarvis.json. Pense nesse arquivo como um “caderninho” onde o Jarvis anota o nome da playlist e o link correspondente.

A função falar(texto) é direta: ela pega uma frase e faz o computador “falar” em voz alta. Toda vez que o Jarvis precisa responder algo, passamos a frase para essa função.

Depois vêm as funções de memória das playlists. salvar_playlist(nome, link) tenta abrir o arquivo playlists_jarvis.json. Se o arquivo ainda não existe, ele cria um dicionário vazio. Em seguida, registra (ou atualiza) a entrada nome -> link e salva de volta no arquivo. Isso permite que, no futuro, ao pedir “tocar playlist X”, o Jarvis saiba qual link abrir. Já obter_playlist(nome) faz o contrário: abre o arquivo (se existir), carrega as playlists e procura pelo nome pedido. Se encontrar, devolve o link; se não, retorna None.

A função tocar_playlist(nome) junta tudo isso: ela chama obter_playlist para descobrir o link daquela playlist. Se existir, o Jarvis avisa (“Tocando sua playlist…”) e abre o link no navegador com webbrowser.open(link). Se não existir, ele informa que não encontrou.

A partir daí, começa a interação por voz. O bloco with sr.Microphone() as source: liga o microfone, o Jarvis diz “Estou ouvindo…” e captura o que você falou. O áudio capturado vai para o reconhecedor, que tenta transformar fala em texto com recognize_google(..., language="pt-BR"). Esse texto é guardado na variável comando, já em letras minúsculas para facilitar as comparações.

O “mini-cérebro” está nos ifs. Se o comando contiver “salvar playlist”, o Jarvis pergunta o nome da playlist (por voz, e escuta pelo microfone) e depois pede o link (aqui, por simplicidade, você cola no terminal). Com nome e link em mãos, ele chama salvar_playlist e confirma que deu tudo certo. Se o comando for “tocar playlist …”, ele extrai o nome que veio depois da frase (ex.: “tocar playlist treino”), chama tocar_playlist(nome) e abre a playlist no navegador. Se você disser “me surpreenda”, o Jarvis escolhe aleatoriamente um link de uma lista pré-definida (aqui coloquei três exemplos) e abre no navegador — antes, ele avisa com uma fala estilosa.

Caso o que você disse não combine com nenhum desses caminhos (“salvar playlist”, “tocar playlist”, “me surpreenda”), o Jarvis responde que não entendeu o comando musical. E, se acontecer algum erro ao reconhecer a fala (por ruído, conexão do serviço de reconhecimento, etc.), o except final cuida de responder de forma educada (“Não consegui entender…”), em vez de deixar o programa quebrar.

Resumindo: o script escuta o que você diz, entende se você quer salvar uma nova playlist (nome + link), tocar uma playlist já salva pelo nome, ou te surpreender com uma música aleatória. Ele guarda tudo em um arquivo JSON simples (como um dicionário de “nome → link”), fala com você usando voz sintetizada e abre o YouTube automaticamente quando é hora de tocar. É uma base enxuta, fácil de expandir: você pode trocar as falas do Jarvis, aumentar a lista de surpresas, ou até usar um reconhecimento melhor de frases para entender comandos mais naturais.

🦸♂️ De volta ao laboratório do Stark

Imagine o Tony Stark trabalhando no laboratório, projetando uma nova armadura Mark 90, quando de repente decide ouvir algo para entrar no ritmo. Ele não tira os olhos do holograma, não digita nada — apenas fala:

“Jarvis, toque minha playlist de testes.”

Em segundos, a música começa a tocar. Essa é a essência do nosso projeto: automatizar a criatividade, dar liberdade ao desenvolvedor e fazer com que o código trabalhe por nós, não o contrário.

Assim como o Jarvis original, o nosso assistente começa a entender o contexto, reagir e se moldar à rotina do seu criador — e é isso que transforma um script em algo vivo.

🔮 Concluindo...

Hoje você aprendeu a dar ao JARVIS o poder de tocar músicas personalizadas, criar playlists e até te surpreender com uma seleção aleatória.

✅ Aprendemos a criar uma memória musical com JSON.
✅ Vimos como salvar e reproduzir playlists por comando de voz.
✅ E ainda adicionamos um toque de aleatoriedade com o comando “me surpreenda”.

Nos próximos artigos, vamos continuar evoluindo nosso assistente: 🎙️ ensinaremos o Jarvis a transcrever conversas completas em texto, 💬 criar um modo conversa contínua, e 🔒 adicionar um modo privado, onde ele para de ouvir suas falas.

👉 Curtiu esse artigo? Me siga no GitHub e no LinkedIn para acompanhar cada passo do Projeto CodeVersePython2025 e construir o seu próprio Jarvis.

Porque o futuro não é esperar a tecnologia chegar. ⚡ É a gente que cria ele hoje.