primocode 10.15.1 → 10.16.0

package/voz/primo_voz/__main__.py

@@ -43,7 +43,7 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import conversa, escuta, fala, identidade, painel, transcrever  # noqa: E402
+from primo_voz import conversa, escuta, fala, fala_pt, identidade, painel, transcrever  # noqa: E402
 from primo_voz import tela as dados_tela  # noqa: E402
 from primo_voz.luz import Luz  # noqa: E402
 from primo_voz.sons import Sons  # noqa: E402
@@ -220,14 +220,17 @@ class Voz:
         self.voz = voz_escolhida
         self.cfg = identidade.ler()
         self.nome = self.cfg["nome"]
-        # nome = só responde se começar pelo nome · sempre = sem palavra · tecla = só ao clicar no painel
-        self.modo = os.environ.get("PRIMOCODE_ATIVACAO", "nome")
+        # Sem palavra de ativação: o microfone só abre no clique do Primo (ptt) e fecha no clique ou ao fim da conversa.
+        self._mic = None
+        self._mic_aberto = False
         self.local = transcrever.disponivel()
         if self.local:
             transcrever.aquecer()
         self.edge = fala.Edge()
         self.voz_id = self.cfg.get("voz") if self.cfg.get("voz") in fala.VOZES else "francisca"
         self._t_acabou = None
+        self._pend = ""
+        self._pend_ate = 0.0
         threading.Thread(target=self._pre_aquecer_frases, daemon=True).start()
         self.gravador = escuta.Gravador()
         self.gravador.vad = escuta.criar_vad()
@@ -244,7 +247,6 @@ class Voz:
         self._falando = False
         self._parar_fala = threading.Event()
         self._acordado_ate = 0.0       # janela de conversa: sem repetir o nome
-        self._ptt_ate = 0.0
         self._ultima_conf = 0.0
         self._ultimo_ok = ""
         self.bolinha.enviar({"nome": self.nome})
@@ -263,9 +265,46 @@ class Voz:
             self.sons.tocar(estado, falando=self._falando)
 
     def _acao_do_painel(self, acao: str) -> None:
-        if acao == "ptt":                      # clique nos anéis = falar agora
-            self._ptt_ate = time.time() + 10
-            self.sons.tocar("acordou", falando=self._falando)
+        if acao == "ptt":                      # clique no Primo: abre o modo voz; clicar de novo fecha
+            if self._mic_aberto:
+                self._fechar_mic()
+            else:
+                self._abrir_mic()
+
+    def _abrir_mic(self) -> bool:
+        if self._mic_aberto or not self._vivo:
+            return self._mic_aberto
+        mic = escuta.Microfone(self._ao_receber)
+        try:
+            mic.abrir()
+        except Exception as e:
+            falar_para_o_node({"tipo": "erro", "texto": f"não consegui abrir o microfone: {e}"})
+            self._erro("Não consegui abrir o microfone.")
+            return False
+        self._mic, self._mic_aberto = mic, True
+        self._esvaziar_blocos()
+        self.gravador.comecar()
+        self._acordado_ate = time.time() + 25
+        self._estado("ouvindo")
+        self.sons.tocar("acordou", falando=self._falando)
+        return True
+
+    def _fechar_mic(self) -> None:
+        """Desliga o microfone e volta a dormir: nada é gravado nem transcrito até o próximo clique."""
+        mic, self._mic, self._mic_aberto = self._mic, None, False
+        if mic:
+            mic.fechar()
+        self._acordado_ate = 0.0
+        self._pend = ""
+        self.gravador.espera = escuta.ESPERA_COMECAR
+        self._esvaziar_blocos()
+        if not self._falando:
+            self._estado("dormindo")
+
+    def _conversa_acabou(self) -> bool:
+        """O mesmo critério de antes para voltar a dormir: a janela de conversa passou e ninguém está pensando/falando."""
+        return (self._mic_aberto and not self._falando and not self._pend
+                and self.maquina.estado == "ouvindo" and time.time() > self._acordado_ate)
 
     def _erro(self, texto: str) -> None:
         self.luz.erro()
@@ -275,7 +314,7 @@ class Voz:
     # ── o ouvido ─────────────────────────────────────────────────────────
 
     def _ao_receber(self, bloco) -> None:
-        if not self._vivo:
+        if not self._vivo or not self._mic_aberto:
             return
         nivel = escuta.rms(bloco)
         if not self._falando and self.bolinha.ultimo:      # o volume REAL do mic vai para as barras da tela
@@ -341,17 +380,9 @@ class Voz:
         threading.Thread(target=trabalho, daemon=True).start()
 
     def _ouvir(self) -> None:
-        mic = escuta.Microfone(self._ao_receber)
-        try:
-            mic.abrir()
-        except Exception as e:
-            falar_para_o_node({"tipo": "erro", "texto": f"não consegui abrir o microfone: {e}"})
-            self.parar()
-            return
+        # O microfone NÃO abre aqui: só no clique (_acao_do_painel). Sem clique, nada grava nem transcreve.
         falar_para_o_node({"tipo": "pronto"})
-        self._estado("ouvindo" if self.modo == "sempre" else "dormindo")
-        self.sons.tocar("acordou")
-        self._saudar()
+        self._estado("dormindo")
         while self._vivo:
             self.gravador.comecar()
             acabou = False
@@ -360,6 +391,8 @@ class Voz:
                 try:
                     bloco = self._blocos.get(timeout=0.3)
                 except queue.Empty:
+                    if self._conversa_acabou():
+                        self._fechar_mic()
                     continue
                 acabou = self.gravador.alimentar(bloco)
                 if self.gravador._falando and not self._falando:
@@ -372,6 +405,11 @@ class Voz:
             if not self._vivo:
                 break
             if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
+                if self._pend and time.time() >= self._pend_ate:      # ninguém continuou: agora sim vira pedido
+                    pend, self._pend = self._pend, ""
+                    self.gravador.espera = escuta.ESPERA_COMECAR
+                    self.lat(f"frase completa após a pausa extra: {pend!r}")
+                    self._tratar(pend)
                 continue
             wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
             if not wav:
@@ -379,28 +417,60 @@ class Voz:
             self._t_acabou = time.time()
             texto = transcrever.limpar(self._transcrever(wav))
             self.lat(f"transcrição {time.time() - self._t_acabou:.2f}s (a frase fechou após {escuta.RABO_VAD if self.gravador.vad else escuta.RABO_SILENCIO:.1f}s de silêncio) -> {texto!r}")
+            self._juntar_e_tratar(texto)
+        self._fechar_mic()
+
+    # "espera": a pessoa segura a vez. Palavras que, sozinhas no fim, prometem continuação.
+    _SEGURA = re.compile(r"(?:^|[\s,.])(?:espera|espere|pera ai|perai|aguarda|aguarde|calma|deixa eu pensar)[\s.!?,]*$", re.I)
+    _CONTINUA = re.compile(r"\b(?:e|ou|mas|ent[aã]o|que|tipo|porque|pois|a[ií]|pra|para|de|do|da|no|na|com|como|se|quando|ent[aã]o|tamb[eé]m|a|o|um|uma|meu|minha)\W*$", re.I)
+
+    def _incompleta(self, texto: str) -> bool:
+        t = texto.strip()
+        if not t:
+            return False
+        if t[-1] in ".?!":
+            return False
+        if t[-1] in ",;:…-" or self._CONTINUA.search(t):
+            return True
+        return len(t.split()) >= 5    # sem pontuação de fim numa frase já longa: provavelmente vem mais; comando curto não espera
+
+    def _juntar_e_tratar(self, texto: str) -> None:
+        """Fim de fala ADAPTATIVO: 1,1 s de silêncio já fechou; se a frase soa incompleta ("e…", "então…", sem ponto)
+        ou a pessoa disse "espera", ele segura mais um pouco e junta com o que vier. Nunca corta no meio."""
+        if self._pend:
+            texto = (self._pend + " " + texto).strip()
+            self._pend = ""
+        if not texto:
+            self.gravador.espera = escuta.ESPERA_COMECAR
             self._tratar(texto)
-        mic.fechar()
+            return
+        if self._SEGURA.search(texto):
+            resto = self._SEGURA.sub("", texto).strip(" ,")
+            self._pend, self._pend_ate = resto or " ", time.time() + 10
+            self.gravador.espera = 10.0
+            self.lat("a pessoa pediu para esperar: segurando até 10 s")
+            self.bolinha.enviar({"transcricao": (resto + " …") if resto else "…", "parcial": True})
+            self._estado("ouvindo")
+            return
+        if self._incompleta(texto):
+            self._pend, self._pend_ate = texto, time.time() + 1.6
+            self._acordado_ate = max(self._acordado_ate, time.time() + 30)
+            self.gravador.espera = 1.6
+            self.lat(f"frase incompleta, esperando mais 1,6 s: {texto!r}")
+            self.bolinha.enviar({"transcricao": texto + " …", "parcial": True})
+            self._estado("ouvindo")
+            return
+        self.gravador.espera = escuta.ESPERA_COMECAR
+        self._tratar(texto)
 
     def _tratar(self, texto: str) -> None:
-        """O que foi dito: ativação, apresentação, comando local ou pedido ao terminal."""
+        """O que foi dito (o microfone só está aberto se a pessoa clicou): apresentação, comando local ou pedido ao terminal."""
         if not texto:
             self._estado(self.maquina.estado if self.maquina.estado != "pensando" else "ouvindo")
             return
         agora = time.time()
-        acordado = (self.modo == "sempre" or agora < self._acordado_ate or agora < self._ptt_ate)
-        chamou, resto = conversa.ativacao(texto, self.nome)
-        if not acordado and not chamou:
-            self._estado("dormindo")          # não era comigo: não vira pedido
-            return
-        texto = resto if chamou else texto
         self._acordado_ate = agora + 25
-        self.bolinha.enviar({"transcricao": texto or f"({self.nome}?)", "parcial": False})
-        if not texto:                          # só chamou pelo nome
-            self.sons.tocar("entendeu")
-            self._dizer(identidade.variar(["Oi! Fala.", "Pois não?", "Tô aqui."], self._ultimo_ok))
-            self.maquina.mandar("ativar")
-            return
+        self.bolinha.enviar({"transcricao": texto, "parcial": False})
         novo = identidade.aprender(texto)
         if novo:
             self.cfg = identidade.salvar(**novo)
@@ -443,10 +513,6 @@ class Voz:
         self._estado("pensando")
         falar_para_o_node({"tipo": "ouvi", "texto": texto})
 
-    def _saudar(self) -> None:
-        if self.cfg.get("pessoa") or True:
-            self._dizer(identidade.saudacao(time.localtime().tm_hour, self.cfg.get("pessoa", ""), self.nome))
-
     def _dizer(self, texto: str) -> None:
         """Fala uma frase curta já pronta (sem passar pelo resumo)."""
         self._ultimo_ok = texto
@@ -502,22 +568,22 @@ class Voz:
                         except queue.Full:
                             continue
 
-    def _cache_de(self, frase: str) -> "Path | None":
+    def _cache_de(self, frase: str, hora: bool = False) -> "Path | None":
         """Onde fica a versão em cache de uma frase curta (None se for longa demais para valer a pena)."""
         if len(frase) > 90 or self.cfg.get("tts", "edge") == "elevenlabs":
             return None
         import hashlib
         pasta = Path.home() / ".primocode" / "voz-cache"
         pasta.mkdir(parents=True, exist_ok=True)
-        if re.match(r"^São \d+ (?:e \d\d|horas em ponto)\.$", frase):
+        if hora:
             return pasta / ("hora-" + self.voz_id + "-" + hashlib.sha1(frase.encode("utf-8")).hexdigest()[:10] + ".mp3")
         return pasta / (self.voz_id + "-" + hashlib.sha1(frase.encode("utf-8")).hexdigest()[:16] + ".mp3")
 
     def _cache_horas(self) -> None:
         agora = time.time()
         for dm in (0, 1, 2):
-            f = fala.hora_falada(time.localtime(agora + 60 * dm))
-            c = self._cache_de(f)
+            f = " ".join(fala_pt.normalizar(fala.hora_falada(time.localtime(agora + 60 * dm))).split())
+            c = self._cache_de(f, hora=True)
             if c is not None and not c.exists():
                 self.edge.sintetizar(f, self.voz_id, c)
 
@@ -525,7 +591,7 @@ class Voz:
         """As frases que o Primo mais diz entram no cache em segundo plano: a confirmação sai na hora."""
         self.edge.aquecer()
         self._cache_horas()
-        for f in ("Já vejo.", "Deixa eu ver.", "Um instante.", "Pode deixar.", "Feito.", "Aumentei.", "Abaixei.", "Pulei.", "Voltei.",
+        for f in ("Feito.", "Aumentei.", "Abaixei.", "Pulei.", "Voltei.",
                   "Oi! Fala.", "Pois não?", "Tô aqui.", "Não consegui uma resposta agora."):
             c = self._cache_de(f)
             if c is not None and not c.exists():
@@ -541,13 +607,16 @@ class Voz:
             time.sleep(20)
 
     def _sintetizar(self, frase: str) -> "Path | None":
-        limpo = " ".join(str(frase).split())[:600]
+        limpo = " ".join(fala_pt.normalizar(frase).split())[:900]      # números, unidades, siglas: por extenso, como se fala
         if not limpo:
             return None
         t0 = time.time()
+        self.lat(f"vai falar: {limpo[:140]!r}")
         mp3 = Path(tempfile.gettempdir()) / f"primo-voz-{int(time.time() * 1000)}.mp3"
         # 0. frase curta já dita antes (ou pré-aquecida): sai do cache, sem rede
         guardada = self._cache_de(limpo)
+        if guardada is not None and not guardada.exists():
+            guardada = self._cache_de(limpo, hora=True) if self._cache_de(limpo, hora=True).exists() else guardada
         if guardada is not None and guardada.exists():
             shutil.copyfile(guardada, mp3)
             self.lat(f"voz do cache ({self.voz_id}): {time.time() - t0:.3f}s")
@@ -611,8 +680,9 @@ class Voz:
             return
         self._falando = False
         self.maquina.mandar("fim_fala")
-        self._estado("ouvindo" if self.modo == "sempre" or time.time() < self._acordado_ate else "dormindo")
-        self._acordado_ate = max(self._acordado_ate, time.time() + 20)
+        self._estado("ouvindo" if self._mic_aberto else "dormindo")
+        if self._mic_aberto:
+            self._acordado_ate = max(self._acordado_ate, time.time() + 90)    # conversa em andamento: 90 s até voltar a dormir
         self.sons.tocar("pronto")
         self.corte.nivel_dele = 0.0
         self._esvaziar_blocos()      # o que o microfone pegou era a voz dele
@@ -682,7 +752,10 @@ class Voz:
             tipo = msg.get("tipo")
             if tipo == "falar":
                 texto = str(msg.get("texto") or "")
-                if msg.get("bruto"):
+                if msg.get("painel"):                       # o cérebro já mandou o texto FALADO e o ESCRITO separados
+                    self.bolinha.enviar({"resposta": str(msg["painel"])[:1500]})
+                    self._acordado_ate = time.time() + 90
+                elif msg.get("bruto"):
                     # a voz resume; o texto inteiro (código, listas) vai ao painel
                     fala, tela = conversa.resumo(texto)
                     self.bolinha.enviar({"resposta": tela[:700]})
@@ -705,7 +778,7 @@ class Voz:
                     self._erro("Deu ruim. O detalhe está no terminal.")
                     est = "ouvindo"
                 self.maquina.mandar("sem_fala")
-                self._estado("ouvindo" if est == "esperando" and time.time() < self._acordado_ate else
+                self._estado("ouvindo" if est == "esperando" and self._mic_aberto else
                              ("dormindo" if est == "esperando" else est))
                 if est == "esperando":
                     self.sons.tocar("pronto", falando=self._falando)