primocode 9.0.0 → 9.2.0

package/studio/pessoa.py

@@ -36,10 +36,30 @@ Uso:
 
 import argparse
 import json
+import shutil
+import os
 import subprocess
 import sys
 
 
+def achar_ffmpeg():
+    """Onde está o ffmpeg — pelo PATH, e nos lugares onde ele costuma cair.
+
+    O PATH de um processo aberto pela interface gráfica não é o PATH do
+    terminal: no macOS um app aberto pelo ícone não enxerga /opt/homebrew/bin,
+    onde o Homebrew instala. Procurar nos lugares conhecidos evita um "não
+    achei" para quem tem o programa instalado.
+    """
+    achado = shutil.which("ffmpeg")
+    if achado:
+        return achado
+    for c in ("/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/usr/bin/ffmpeg",
+              r"C:\Program Files\ffmpeg\bin\ffmpeg.exe"):
+        if os.path.exists(c):
+            return c
+    return None
+
+
 def faltando():
     """O que precisa estar instalado, e não está."""
     falta = []
@@ -76,8 +96,20 @@ def recortar(entrada, saida, suavizar=7, encolher=2, limiar=0.6):
 
     # VP9 num .webm é o formato de vídeo com transparência que o Chromium do
     # Remotion abre — e é o Chromium dele que vai desenhar isto.
+    # O ffmpeg pelo nome cru estoura FileNotFoundError, e o que chega ao
+    # usuário é o traceback do Python — que não diz o que instalar. Pior: aqui
+    # o vídeo já foi ABERTO e a segmentação está prestes a começar, então a
+    # falha aparece depois da espera, não antes dela.
+    binario = achar_ffmpeg()
+    if not binario:
+        captura.release()
+        return {"ok": False,
+                "error": "o recorte de pessoa precisa do ffmpeg, e não achei nenhum nesta máquina.",
+                "comoResolver": "macOS: brew install ffmpeg · Linux: sudo apt install ffmpeg · "
+                                "Windows: winget install ffmpeg"}
+
     escritor = subprocess.Popen(
-        ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+        [binario, "-hide_banner", "-loglevel", "error", "-y",
          "-f", "rawvideo", "-pix_fmt", "bgra",
          "-s", f"{largura}x{altura}", "-r", str(fps), "-i", "-",
          "-c:v", "libvpx-vp9", "-pix_fmt", "yuva420p", "-b:v", "3M",

package/voz/primo_voz/__main__.py

@@ -50,7 +50,7 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import escuta, orbe  # noqa: E402
+from primo_voz import desperta, escuta, orbe  # noqa: E402
 
 
 def falar_para_o_node(obj: dict) -> None:
@@ -65,14 +65,75 @@ def avisar(texto: str) -> None:
     sys.stderr.flush()
 
 
+# O PowerShell que toca MP3 no Windows. MediaPlayer é assíncrono: Play()
+# devolve na hora, então é preciso esperar a duração — e esperar com teto, ou
+# um Open que falha deixaria a thread da fala pendurada para sempre.
+def motivo_da_narracao(r) -> str:
+    """O que o narrar.py disse que houve — em vez do código de saída.
+
+    Ele responde JSON em stdout, com "error" e "comoResolver". Quando esse
+    JSON não vem (o processo morreu antes de escrever), sobra o stderr, que
+    ainda diz mais que "returned non-zero exit status 1".
+    """
+    try:
+        d = json.loads((r.stdout or b"").decode("utf-8", "replace"))
+        if isinstance(d, dict) and d.get("error"):
+            comoResolver = d.get("comoResolver") or ""
+            return "não deu para gerar a voz: " + str(d["error"]) + (
+                " — " + str(comoResolver) if comoResolver else "")
+    except Exception:
+        pass
+    erro = (r.stderr or b"").decode("utf-8", "replace").strip()
+    ultima = erro.splitlines()[-1] if erro else ""
+    return "não deu para gerar a voz" + (f": {ultima[:300]}" if ultima else
+                                         f" (o narrar.py saiu com {r.returncode})")
+
+
+PS_TOCAR_MP3 = (
+    "Add-Type -AssemblyName PresentationCore; "
+    "$p = New-Object System.Windows.Media.MediaPlayer; "
+    "$p.Open([uri]'{arquivo}'); "
+    "$n = 0; "
+    "while (-not $p.NaturalDuration.HasTimeSpan -and $n -lt 100) "
+    "{{ Start-Sleep -Milliseconds 50; $n++ }}; "
+    "if (-not $p.NaturalDuration.HasTimeSpan) {{ exit 1 }}; "
+    "$p.Play(); "
+    "Start-Sleep -Seconds $p.NaturalDuration.TimeSpan.TotalSeconds; "
+    "$p.Close()"
+)
+
+
 class Voz:
     """A costura: microfone → transcrição → Node → voz → microfone."""
 
-    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio"):
+    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio",
+                 esperando: bool = False):
         self.servidor = servidor
         self.token = token
         self.voz = voz_escolhida
 
+        # ── MODO DE ESPERA ───────────────────────────────────────────
+        #
+        # Ligado, ele fica dormindo com a orbe escondida até ouvir o nome, e
+        # volta a dormir depois de atender. Desligado (o padrão antigo), ele
+        # já entra ouvindo — que é o certo para quem digitou /voice e vai
+        # falar agora.
+        #
+        # A espera exige o reconhecedor local. Sem ele instalado, não cai
+        # para "mandar tudo para o servidor": cai para o modo de sempre, e
+        # DIZ por quê. Silenciosamente transformar uma coisa na outra seria
+        # abrir o microfone da pessoa para a internet sem ela saber.
+        #
+        self.esperando = bool(esperando)
+        self.desperta = None
+        if self.esperando:
+            self.desperta = desperta.Desperta(ao_despertar=lambda: None)
+            if not self.desperta.pronto:
+                avisar(f"modo de espera indisponível: {self.desperta.motivo} — "
+                       "abrindo no modo normal, já ouvindo.")
+                self.esperando = False
+                self.desperta = None
+
         self.orb = orbe.Orbe(ao_fechar=self.parar)
         self.gravador = escuta.Gravador()
         self.corte = escuta.Corte()
@@ -84,6 +145,19 @@ class Voz:
         self._parar_fala = threading.Event()
         self._do_node = queue.Queue()
 
+    def _esvaziar_blocos(self) -> None:
+        """Joga fora o áudio que está na fila.
+
+        Depois de despertar, os blocos do próprio "ei primo" ainda estão
+        enfileirados — e sem isto eles entram na gravação do PEDIDO, que chega
+        ao agente com o nome colado na frente.
+        """
+        while True:
+            try:
+                self._blocos.get_nowait()
+            except queue.Empty:
+                return
+
     # ── microfone ────────────────────────────────────────────────────────
     def _ao_receber(self, bloco) -> None:
         if not self._vivo:
@@ -115,6 +189,31 @@ class Voz:
             return
 
         while self._vivo:
+            # ── O SONO ───────────────────────────────────────────────
+            # No modo de espera a orbe some e o microfone fica ouvindo SÓ o
+            # nome, aqui dentro, sem nada sair da máquina (ver desperta.py).
+            # Sem isso, o modo de espera seria o microfone da pessoa aberto
+            # para a internet o dia inteiro.
+            if self.esperando and self.desperta is not None:
+                self.orb.esconder()
+                self.desperta.zerar()
+                acordou = False
+                while self._vivo and not acordou:
+                    try:
+                        bloco = self._blocos.get(timeout=0.3)
+                    except queue.Empty:
+                        continue
+                    acordou = self.desperta.alimentar(bloco)
+                if not self._vivo:
+                    break
+                # Chamou: a orbe aparece e ele passa a ouvir o PEDIDO.
+                self.orb.mostrar()
+                self.orb.mudar(estado="ouvindo", nivel=0)
+                # Sem esvaziar a fila, os blocos do próprio "ei primo" entram
+                # na gravação do pedido — e o pedido chega com o nome colado
+                # na frente.
+                self._esvaziar_blocos()
+
             self.orb.mudar(estado="esperando", nivel=0)
             self.gravador.comecar()
 
@@ -227,13 +326,17 @@ class Voz:
 
         mp3 = Path(tempfile.gettempdir()) / f"primo-voz-{int(time.time() * 1000)}.mp3"
         narrar = AQUI.parent.parent / "studio" / "narrar.py"
-        try:
-            subprocess.run(
-                [sys.executable, str(narrar), "falar", "--texto", limpo,
-                 "--saida", str(mp3), "--voz", self.voz],
-                capture_output=True, timeout=180, check=True)
-        except Exception as e:
-            avisar(f"não deu para gerar a voz: {e}")
+        # O narrar.py IMPRIME um JSON dizendo o que faltou e como resolver
+        # ("instale o edge-tts com… "). Com check=True isso virava uma
+        # CalledProcessError cujo texto é "Command '[...]' returned non-zero
+        # exit status 1" — e era ISSO que chegava ao usuário, com o conselho
+        # útil jogado fora dentro do capture_output. Agora a saída é lida.
+        r = subprocess.run(
+            [sys.executable, str(narrar), "falar", "--texto", limpo,
+             "--saida", str(mp3), "--voz", self.voz],
+            capture_output=True, timeout=180)
+        if r.returncode != 0 or not mp3.exists():
+            avisar(motivo_da_narracao(r))
             return
 
         self._falando = True
@@ -260,8 +363,15 @@ class Voz:
         if sys.platform == "darwin":
             tentativas.append(["afplay", str(arquivo)])
         elif sys.platform == "win32":
-            tentativas.append(["powershell", "-c",
-                               f"(New-Object Media.SoundPlayer '{arquivo}').PlaySync()"])
+            # Media.SoundPlayer NÃO toca MP3 — ele só lê WAV, e o que o
+            # narrar.py entrega é MP3. Era a primeira tentativa da fila, e
+            # levantava exceção sempre; como o laço abaixo aceitava qualquer
+            # processo que tivesse CONSEGUIDO INICIAR, ele dava por tocado e
+            # voltava. Resultado: o modo voz era MUDO no Windows, sem nenhum
+            # aviso — a orb piscava "falando" e não saía som nenhum.
+            # MediaPlayer decodifica MP3; a espera é limitada para não travar
+            # a thread se o Open falhar.
+            tentativas.append(["powershell", "-NoProfile", "-Command", PS_TOCAR_MP3.format(arquivo=arquivo)])
         tentativas += [
             ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", str(arquivo)],
             ["mpg123", "-q", str(arquivo)],
@@ -271,7 +381,7 @@ class Voz:
         for cmd in tentativas:
             try:
                 p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            except FileNotFoundError:
+            except (FileNotFoundError, OSError):
                 continue
             while p.poll() is None:
                 if self._parar_fala.is_set() or not self._vivo:
@@ -279,10 +389,19 @@ class Voz:
                         p.terminate()
                     except Exception:
                         pass
-                    return
+                    return          # calado de propósito: falaram por cima
                 time.sleep(0.05)
-            return
-        avisar("não achei um tocador de áudio (ffplay, mpg123, mpv ou afplay).")
+            if p.returncode == 0:
+                return
+            # INICIAR não é TOCAR. O tocador existia e falhou (formato que ele
+            # não lê, dispositivo de áudio ocupado): a fila continua. Sair aqui
+            # era o que transformava "o primeiro tocador não serve" em silêncio
+            # absoluto, com quatro alternativas por tentar logo abaixo.
+            continue
+        avisar("não achei um tocador de áudio que funcione neste computador."
+               + (" Instale o ffmpeg: winget install ffmpeg" if sys.platform == "win32"
+                  else " Instale o ffmpeg: brew install ffmpeg" if sys.platform == "darwin"
+                  else " Instale o ffmpeg: sudo apt install ffmpeg"))
 
     # ── ciclo de vida ────────────────────────────────────────────────────
     def parar(self) -> None:
@@ -304,6 +423,9 @@ def main() -> int:
     servidor = os.environ.get("PRIMOCODE_SERVER", "").strip()
     token = os.environ.get("PRIMOCODE_TOKEN", "").strip()
     voz = os.environ.get("PRIMOCODE_VOZ", "antonio").strip() or "antonio"
+    # O modo de espera vem por variável, como o resto: quem abre este programa
+    # é o /voice do Node, não uma pessoa numa linha de comando.
+    esperando = os.environ.get("PRIMOCODE_VOZ_ESPERA", "") == "1"
 
     if not servidor:
         avisar("falta PRIMOCODE_SERVER — este programa é aberto pelo /voice do PrimoCode.")
@@ -317,7 +439,7 @@ def main() -> int:
                f"{sys.executable} -m pip install sounddevice numpy")
         return 3
 
-    Voz(servidor, token, voz).rodar()
+    Voz(servidor, token, voz, esperando=esperando).rodar()
     return 0
 
 

package/voz/primo_voz/desperta.py

@@ -0,0 +1,195 @@
+"""desperta.py — ouvir o nome, e só o nome, sem mandar áudio para lugar nenhum.
+
+── POR QUE OFFLINE, E POR QUE ISSO NÃO É DETALHE ───────────────────────────
+No modo de espera o microfone fica ABERTO o tempo todo. Existem dois jeitos de
+saber se alguém disse "ei, primo":
+
+  1. Mandar tudo o que o microfone ouve para um servidor transcrever.
+  2. Reconhecer a palavra aqui dentro, sem nada sair da máquina.
+
+O primeiro funciona e é mais simples de escrever. Também significa que TODA
+conversa perto do computador — a ligação, a reunião, a briga em casa — sobe
+para um servidor, o dia inteiro, para que uma vez por hora alguém diga o nome
+do programa. Isso não é uma troca aceitável, e não é decisão que um programa
+toma pelo dono da máquina.
+
+Então é o segundo. O Vosk roda local, o modelo mora no disco da pessoa, e
+NADA sai daqui enquanto o nome não for dito. Depois do nome, sim: a frase vai
+para a transcrição, como no modo normal — mas aí foi a pessoa que chamou.
+
+── A GRAMÁTICA RESTRITA ────────────────────────────────────────────────────
+O reconhecedor é criado sabendo APENAS as palavras de despertar. Não é
+otimização: é o que impede ele de "ouvir" o nome no meio de uma frase
+qualquer. Um reconhecedor livre transcreve tudo e depois se procura a palavra
+no texto — e aí "prima", "primeiro" e "exprimo" acordam o assistente. Com a
+gramática restrita ele só pode devolver uma das palavras da lista ou "[unk]".
+
+Herdado do Jarvis (src/jarvis/core/wake.py), que resolveu isto primeiro; o
+modelo aqui é o de PORTUGUÊS, porque "primo" é palavra portuguesa — ao
+contrário de "Jarvis", que é nome inglês e por isso lá usava o modelo de
+inglês.
+"""
+from __future__ import annotations
+
+import json
+import os
+import threading
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Callable, Optional
+
+TAXA = 16000
+
+# Onde o modelo mora. Fora do pacote npm de propósito: são 31 MB, e um pacote
+# que engorda 31 MB para todo mundo por causa de um modo que nem todos usam é
+# um pacote que demora a instalar para todo mundo.
+PASTA_MODELO = Path.home() / ".primocode" / "modelos"
+NOME_MODELO = "vosk-model-small-pt-0.3"
+URL_MODELO = f"https://alphacephei.com/vosk/models/{NOME_MODELO}.zip"
+
+# O que ACORDA. Variantes porque o reconhecedor pequeno erra a vogal átona, e
+# porque as pessoas falam de jeitos diferentes ("ei primo", "oi primo", "ô
+# primo"). O "primo" sozinho entra: dentro da gramática restrita ele não
+# dispara em conversa comum, porque o reconhecedor não transcreve conversa
+# comum — só consegue devolver estas palavras.
+VOCABULARIO = ("primo", "ei", "oi", "olá", "ô")
+DESPERTA = ("primo",)
+
+
+def caminho_do_modelo() -> Path:
+    return PASTA_MODELO / NOME_MODELO
+
+
+def tem_modelo() -> bool:
+    caminho = caminho_do_modelo()
+    return caminho.is_dir() and any(caminho.iterdir())
+
+
+def baixar_modelo(aoFalar: Optional[Callable[[str], None]] = None) -> dict:
+    """Traz o modelo, uma vez. ~31 MB.
+
+    Baixa para um arquivo temporário e só então move para o lugar: interromper
+    no meio deixaria uma pasta pela metade que `tem_modelo()` daria por boa, e
+    o erro apareceria depois, como "falha ao carregar o Vosk".
+    """
+    fala = aoFalar or (lambda _t: None)
+    if tem_modelo():
+        return {"ok": True, "jaTinha": True}
+    try:
+        PASTA_MODELO.mkdir(parents=True, exist_ok=True)
+        temporario = PASTA_MODELO / (NOME_MODELO + ".zip.parcial")
+        fala("baixando o reconhecedor de voz (uma vez, ~31 MB)")
+        with urllib.request.urlopen(URL_MODELO, timeout=120) as resposta, open(temporario, "wb") as saida:
+            while True:
+                pedaco = resposta.read(1 << 16)
+                if not pedaco:
+                    break
+                saida.write(pedaco)
+        fala("descompactando")
+        with zipfile.ZipFile(temporario) as z:
+            z.extractall(PASTA_MODELO)
+        temporario.unlink(missing_ok=True)
+        if not tem_modelo():
+            return {"ok": False, "error": "o modelo baixou mas não apareceu onde devia"}
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e),
+                "comoResolver": f"baixe {URL_MODELO} à mão e descompacte em {PASTA_MODELO}"}
+
+
+def contem_nome(texto: str) -> bool:
+    """O texto que o reconhecedor devolveu contém o nome?
+
+    Comparação por PALAVRA INTEIRA. Com `in` de substring, "prima" e
+    "primeiro" acordariam o assistente — e a gramática restrita não protege
+    disso sozinha, porque ela devolve as palavras da lista e o resto vira
+    "[unk]", que pode vir colado.
+    """
+    palavras = set(str(texto or "").lower().replace("[unk]", " ").split())
+    return any(n in palavras for n in DESPERTA)
+
+
+class Desperta:
+    """Escuta o nome. Nada sai da máquina até ele ser dito."""
+
+    def __init__(self, ao_despertar: Callable[[], None]) -> None:
+        self.ao_despertar = ao_despertar
+        self._rec = None
+        self._modelo = None
+        self.pronto = False
+        self.ligado = True
+        self.motivo = ""
+        # O reconhecedor do Vosk NÃO é seguro entre threads: a do áudio chama
+        # process() dez vezes por segundo enquanto o laço principal pode
+        # chamar reset() ao despertar. Sem trava, o estado interno corrompe e
+        # ele passa a levantar "Failed to process waveform" — sintoma que não
+        # fala de thread nenhuma, e por isso custa caro de achar.
+        self._trava = threading.Lock()
+        self._carregar()
+
+    def _carregar(self) -> None:
+        if not tem_modelo():
+            self.motivo = "o reconhecedor de voz não está baixado"
+            return
+        try:
+            import vosk
+            vosk.SetLogLevel(-1)
+            self._modelo = vosk.Model(str(caminho_do_modelo()))
+            self._rec = self._novo()
+            self.pronto = True
+        except ImportError:
+            self.motivo = "falta o vosk (pip install vosk)"
+        except Exception as e:
+            self.motivo = f"não consegui carregar o reconhecedor: {e}"
+
+    def _novo(self):
+        import vosk
+        gramatica = json.dumps(sorted({*VOCABULARIO, "[unk]"}))
+        return vosk.KaldiRecognizer(self._modelo, TAXA, gramatica)
+
+    def alimentar(self, bloco) -> bool:
+        """Um bloco de áudio. Devolve True se o nome foi dito."""
+        if not self.pronto or self._rec is None or not self.ligado:
+            return False
+        with self._trava:
+            try:
+                if self._rec.AcceptWaveform(bloco.tobytes()):
+                    texto = json.loads(self._rec.Result()).get("text", "")
+                else:
+                    texto = json.loads(self._rec.PartialResult()).get("partial", "")
+            except Exception:
+                # Reconhecedor travado: recria e segue. Desligar o modo de
+                # espera por causa de um bloco ruim seria perder o recurso
+                # inteiro por um soluço de áudio.
+                try:
+                    self._rec = self._novo()
+                except Exception:
+                    self.pronto = False
+                    self.motivo = "o reconhecedor parou e não voltou"
+                return False
+
+            achou = bool(texto and contem_nome(texto))
+            if achou:
+                self._rec.Reset()
+
+        if achou:
+            try:
+                self.ao_despertar()
+            except Exception:
+                pass
+        return achou
+
+    def zerar(self) -> None:
+        """Esquece o que ouviu até agora.
+
+        Chamado ao voltar do atendimento: sem isso, o resto da frase que a
+        pessoa falou DEPOIS do nome ainda está no reconhecedor, e ele desperta
+        de novo no instante seguinte.
+        """
+        with self._trava:
+            if self._rec is not None:
+                try:
+                    self._rec.Reset()
+                except Exception:
+                    pass

package/voz/primo_voz/escuta.py

@@ -20,10 +20,11 @@ mas CONTINUAR gravando exige bem menos. Sem isso, a sílaba fraca no fim ("…pr
 mim") cai abaixo do limiar e a frase é cortada antes de acabar.
 
 ── O QUE SAIU DO JARVIS ────────────────────────────────────────────────────
-A wake word. Lá ela existia porque o assistente ficava ligado o dia inteiro
-esperando ser chamado. Aqui a pessoa abriu o modo voz de propósito: ele já
-está ouvindo, e não há nome para dizer. Some com isso o Vosk e os 40 MB de
-modelo que ele baixava.
+A wake word saiu DAQUI, não do produto. Este módulo cuida de uma coisa só:
+achar o começo e o fim de uma frase. Quem reconhece o nome é o desperta.py, e
+ele só entra no modo de espera — quando a pessoa pediu para ele ficar ouvindo
+em segundo plano. Quem digita /voice e vai falar agora não diz nome nenhum: a
+orbe já está ouvindo.
 """
 from __future__ import annotations
 

package/voz/primo_voz/orbe.py

@@ -39,6 +39,7 @@ from __future__ import annotations
 
 import math
 import queue
+import sys
 import threading
 import tkinter as tk
 from typing import Callable, Optional
@@ -63,6 +64,7 @@ class Orbe:
         self.raiz = tk.Tk()
         self.raiz.title("Primo Code Voice")
         self.estado = "esperando"
+        self.visivel = True
         self.nivel = 0.0          # 0..1, o quanto a pessoa está falando
         self._fase = 0.0
         self._fila = queue.Queue()
@@ -130,6 +132,12 @@ class Orbe:
         while True:
             try:
                 estado, nivel = self._fila.get_nowait()
+                if estado == '__esconder__':
+                    self._aplicar_visibilidade(False)
+                    continue
+                if estado == '__mostrar__':
+                    self._aplicar_visibilidade(True)
+                    continue
             except queue.Empty:
                 break
             if estado:
@@ -197,6 +205,40 @@ class Orbe:
         principal, então o que chega vai para uma fila e é lido no desenho."""
         self._fila.put((estado, nivel))
 
+    def esconder(self) -> None:
+        """Some da tela sem morrer.
+
+        O modo de espera fica MINUTOS ou horas sem nada acontecer, e uma orbe
+        parada no meio do monitor todo esse tempo é um estorvo — ela cobre o
+        que a pessoa está fazendo. Então ela some e volta quando chamada.
+
+        Destruir e recriar a janela a cada despertar seria o caminho óbvio, e é
+        o errado: recriar uma Tk leva centenas de milissegundos, pisca, e em
+        alguns sistemas rouba o foco da janela onde a pessoa estava digitando.
+        `withdraw` tira da tela e guarda tudo de pé.
+        """
+        self._fila.put(("__esconder__", None))
+
+    def mostrar(self) -> None:
+        """Volta para a tela, no centro, por cima de tudo."""
+        self._fila.put(("__mostrar__", None))
+
+    def _aplicar_visibilidade(self, visivel: bool) -> None:
+        # Só na thread da interface: tkinter não perdoa chamada de fora.
+        try:
+            if visivel:
+                self.veu.deiconify()
+                self.raiz.deiconify()
+                self.raiz.lift()
+                if sys.platform != "linux":
+                    self.raiz.attributes("-topmost", True)
+            else:
+                self.raiz.withdraw()
+                self.veu.withdraw()
+        except Exception:
+            pass          # janela já fechando: nada a fazer
+        self.visivel = visivel
+
     def fechar(self) -> None:
         if not self._vivo:
             return