primocode 10.14.1 → 10.15.0

package/voz/primo_voz/painel.py

@@ -0,0 +1,459 @@
+"""painel.py — o que o HUD mostra, sem desenhar nada.
+
+`Painel.aplicar(msg)` recebe uma linha do protocolo (JSON já lido) e atualiza o
+quadro; hud.py (Mac, PyObjC) e `renderizar_tui` (qualquer terminal) só
+DESENHAM este quadro. Assim a regra mora num lugar e se testa sem tela.
+
+Mensagens aceitas (todas opcionais, uma por linha):
+    {"estado": "ouvindo|pensando|falando|executando|dormindo|interrompido|esperando", "nivel": 0..1}
+    {"transcricao": "texto", "parcial": true}
+    {"resposta": "texto do painel"}
+    {"info": {"projeto": "...", "branch": "...", "tokens": "12k", "plano": "..."}}
+    {"painel": "esconder" | "mostrar" | "alternar"}
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+from typing import Dict, List, Optional
+
+ROTULOS = {
+    "esperando": "PRONTO", "dormindo": "EM ESPERA", "ouvindo": "OUVINDO", "pensando": "PENSANDO",
+    "falando": "FALANDO", "executando": "EXECUTANDO", "interrompido": "INTERROMPIDO",
+}
+
+
+class Painel:
+    def __init__(self) -> None:
+        self.estado = "esperando"
+        self.nivel = 0.0
+        self.transcricao = ""
+        self.parcial = False
+        self.resposta = ""
+        self.nome = "Primo"
+        self.visivel = True
+        # só o que dá para pegar do computador da pessoa (ver coletar_tudo)
+        self.info: Dict[str, str] = {"tocando": "", "app": "", "wifi": "", "clima": "", "evento": ""}
+        self.sistema: Dict[str, Optional[float]] = {"cpu": None, "mem": None, "disco": None, "bat": None}
+
+    def aplicar(self, msg: dict) -> None:
+        if "estado" in msg and msg["estado"]:
+            self.estado = str(msg["estado"])
+        if "nivel" in msg and msg["nivel"] is not None:
+            self.nivel = max(0.0, min(1.0, float(msg["nivel"])))
+        if "transcricao" in msg:
+            self.transcricao = str(msg["transcricao"] or "")
+            self.parcial = bool(msg.get("parcial"))
+            if not self.parcial and self.transcricao:
+                self.resposta = ""        # pedido novo: a resposta velha sai
+        if "resposta" in msg:
+            self.resposta = str(msg["resposta"] or "")
+        if msg.get("nome"):
+            self.nome = str(msg["nome"])
+        if isinstance(msg.get("info"), dict):
+            for k, v in msg["info"].items():
+                if k in self.info:
+                    self.info[k] = str(v)
+        p = msg.get("painel")
+        if p == "esconder":
+            self.visivel = False
+        elif p == "mostrar":
+            self.visivel = True
+        elif p == "alternar":
+            self.visivel = not self.visivel
+        if msg.get("esconder"):
+            self.visivel = False
+        if msg.get("mostrar"):
+            self.visivel = True
+
+    @property
+    def rotulo(self) -> str:
+        return ROTULOS.get(self.estado, self.estado.upper())
+
+    @property
+    def cor(self) -> str:
+        """ciano = a conversa (ouvir, falar); âmbar = o trabalho (pensar, executar)."""
+        return "ambar" if self.estado in ("pensando", "executando", "interrompido") else "ciano"
+
+
+# ── o que o computador está fazendo (sem dependência) ────────────────────
+
+def _rodar(cmd: List[str], t: float = 3.0) -> str:
+    try:
+        return subprocess.run(cmd, capture_output=True, text=True, timeout=t).stdout
+    except Exception:
+        return ""
+
+
+def coletar_sistema() -> Dict[str, Optional[float]]:
+    """cpu, mem e bateria em 0..1 (None = não deu para medir)."""
+    cpu = mem = bat = None
+    try:
+        n = os.cpu_count() or 1
+        cpu = min(1.0, os.getloadavg()[0] / n)
+    except Exception:
+        pass
+    try:
+        import psutil  # opcional
+        cpu = psutil.cpu_percent(interval=None) / 100.0
+        mem = psutil.virtual_memory().percent / 100.0
+        b = psutil.sensors_battery()
+        bat = b.percent / 100.0 if b else None
+        return {"cpu": cpu, "mem": mem, "bat": bat}
+    except Exception:
+        pass
+    if shutil.which("vm_stat"):
+        s = _rodar(["vm_stat"])
+        pag = {k: int(v) for k, v in re.findall(r"Pages ([a-z ]+):\s+(\d+)", s)}
+        usadas = pag.get("active", 0) + pag.get("wired down", 0) + pag.get("occupied by compressor", 0)
+        total = usadas + pag.get("free", 0) + pag.get("inactive", 0) + pag.get("speculative", 0)
+        mem = usadas / total if total else None
+    if shutil.which("pmset"):
+        m = re.search(r"(\d+)%", _rodar(["pmset", "-g", "batt"]))
+        bat = int(m.group(1)) / 100.0 if m else None
+    return {"cpu": cpu, "mem": mem, "bat": bat}
+
+
+def _osa(script: str, t: float = 2.5) -> str:
+    return _rodar(["osascript", "-e", script], t).strip()
+
+
+def tocando() -> str:
+    """Faixa — artista do Spotify ou do Music (só se o app já estiver aberto).
+    "♪ " tocando, "⏸ " pausado. Quem toca ganha de quem só está pausado."""
+    if sys.platform != "darwin":
+        return ""
+    pausado = ""
+    for app in ("Spotify", "Music"):
+        r = _osa(f'if application "{app}" is running then tell application "{app}" to return '
+                 '(player state as string) & "|" & name of current track & " — " & artist of current track', 2.0)
+        estado, _, faixa = r.partition("|")
+        if not faixa:
+            continue
+        if estado == "playing":
+            return faixa
+        pausado = pausado or "⏸ " + faixa
+    return pausado
+
+
+def app_em_foco() -> str:
+    if sys.platform != "darwin":
+        return ""
+    return _osa('tell application "System Events" to name of first application process whose frontmost is true')
+
+
+def wifi() -> str:
+    if sys.platform != "darwin":
+        return ""
+    for dev in ("en0", "en1"):
+        r = _rodar(["networksetup", "-getairportnetwork", dev], 2.0)
+        m = re.search(r"Network:\s*(.+)", r)
+        if m:
+            return m.group(1).strip()
+    return ""
+
+
+def clima(cache: dict) -> str:
+    """wttr.in (grátis, sem chave), no máximo a cada 20 min. Offline = vazio."""
+    if time.time() - cache.get("t", 0) < 1200:
+        return cache.get("v", "")
+    cache["t"] = time.time()
+    try:
+        import urllib.request
+        with urllib.request.urlopen(urllib.request.Request(
+                "https://wttr.in/?format=%t+%C&lang=pt", headers={"User-Agent": "curl/8"}), timeout=4) as r:
+            v = r.read().decode("utf-8", "replace").strip()
+        cache["v"] = v if v and len(v) < 40 and "Unknown" not in v else ""
+    except Exception:
+        cache["v"] = cache.get("v", "")
+    return cache["v"]
+
+
+def proximo_evento() -> str:
+    """Próximo evento do Calendário. Só com PRIMOCODE_VOZ_CALENDARIO=1: o macOS pede permissão."""
+    if sys.platform != "darwin" or os.environ.get("PRIMOCODE_VOZ_CALENDARIO") != "1":
+        return ""
+    return _osa('tell application "Calendar" to summary of (first event of calendar 1 '
+                'whose start date > (current date))', 6)
+
+
+def disco() -> Optional[float]:
+    try:
+        u = shutil.disk_usage("/")
+        return u.used / u.total
+    except Exception:
+        return None
+
+
+def coletar_tudo(cache: dict) -> dict:
+    """Tudo o que o painel mostra do computador. Lento (osascript): rode em thread."""
+    sis = coletar_sistema()
+    sis["disco"] = disco()
+    return {"sistema": sis, "info": {"tocando": tocando(), "app": app_em_foco(), "wifi": wifi(),
+                                     "clima": clima(cache), "evento": proximo_evento()}}
+
+
+# ── o painel no terminal (fora do Mac, ou sem PyObjC) ────────────────────
+
+def _barra(v: Optional[float], n: int = 10) -> str:
+    if v is None:
+        return "·" * n
+    cheio = int(round(max(0.0, min(1.0, v)) * n))
+    return "█" * cheio + "░" * (n - cheio)
+
+
+def renderizar_tui(p: Painel, largura: int = 56) -> str:
+    """Um quadro de texto puro: cabe em qualquer terminal."""
+    larg = max(40, largura)
+    u = larg - 4
+    anel = {"ouvindo": "(( ◉ ))", "pensando": "(( ◌ ))", "falando": "((( ◉ )))", "executando": "(( ▸ ))",
+            "dormindo": "(  ·  )", "interrompido": "(( ✕ ))"}.get(p.estado, "(  ◉  )")
+
+    def corta(t: str, n: int) -> str:
+        t = " ".join(str(t).split())
+        return t if len(t) <= n else t[: n - 1] + "…"
+
+    def linha(t: str) -> str:
+        return "│ " + corta(t, u).ljust(u) + " │"
+
+    agora = time.strftime("%H:%M  %d/%m")
+    s = p.sistema
+    linhas = [
+        "┌" + "─" * (larg - 2) + "┐",
+        linha(f"{anel:<9} {p.nome.upper()} · {p.rotulo}".ljust(u - len(agora)) + agora),
+        linha("você  › " + p.transcricao),
+        linha(f"{p.nome.lower()[:5]:<5} › " + p.resposta),
+        linha(f"cpu {_barra(s.get('cpu'), 8)} mem {_barra(s.get('mem'), 8)} disco {_barra(s.get('disco'), 8)}"),
+        linha(f"bat {_barra(s.get('bat'), 8)}  wifi {p.info.get('wifi') or '-'}  {p.info.get('clima') or ''}"),
+        linha("♪ " + (p.info.get("tocando") or "—") + ("   ▢ " + p.info["app"] if p.info.get("app") else "")),
+        "└" + "─" * (larg - 2) + "┘",
+    ]
+    return "\n".join(linhas)
+
+
+def tui_laco(entrada, saida=None, largura: int = 56) -> None:
+    """Lê o protocolo e redesenha o quadro no lugar. Para o `/voice painel` fora do Mac."""
+    import sys
+    saida = saida or sys.stdout
+    p = Painel()
+    ultimo = 0.0
+    cache: dict = {}
+    cache_t = [0.0]
+    for linha in entrada:
+        try:
+            import json
+            p.aplicar(json.loads(linha))
+        except ValueError:
+            continue
+        if time.time() - ultimo > 0.2:
+            if time.time() - cache_t[0] > 5:
+                r = coletar_tudo(cache)
+                p.sistema, p.info = r["sistema"], {**p.info, **r["info"]}
+                cache_t[0] = time.time()
+            saida.write("\x1b[H\x1b[J" + renderizar_tui(p, largura) + "\n")
+            saida.flush()
+            ultimo = time.time()
+
+
+# ── amostras ao vivo para o HUD de tela cheia ────────────────────────────
+
+class Amostrador:
+    """CPU por núcleo e tráfego de rede, por diferença entre duas leituras."""
+
+    def __init__(self) -> None:
+        self._cpu = None
+        self._rede = None
+        self._lib = None
+
+    def _ticks(self):
+        import ctypes
+        from ctypes import POINTER, byref, c_int, c_uint
+        if self._lib is None:
+            self._lib = ctypes.CDLL("/usr/lib/libSystem.B.dylib")
+            self._lib.mach_host_self.restype = c_uint
+        n, info, cnt = c_uint(), POINTER(c_int)(), c_uint()
+        if self._lib.host_processor_info(self._lib.mach_host_self(), 2, byref(n), byref(info), byref(cnt)) != 0:
+            return None
+        ticks = [tuple(info[i * 4 + k] & 0xFFFFFFFF for k in range(4)) for i in range(n.value)]
+        try:
+            self._lib.vm_deallocate.argtypes = [c_uint, ctypes.c_void_p, ctypes.c_size_t]
+            self._lib.vm_deallocate(c_uint.in_dll(self._lib, "mach_task_self_").value,
+                                    ctypes.cast(info, ctypes.c_void_p), cnt.value * 4)
+        except Exception:
+            pass
+        return ticks
+
+    def cores(self) -> List[float]:
+        if sys.platform != "darwin":
+            return []
+        try:
+            atual = self._ticks()
+        except Exception:
+            return []
+        antes, self._cpu = self._cpu, atual
+        if not atual or not antes or len(antes) != len(atual):
+            return [0.0] * len(atual or [])
+        saida = []
+        for a, b in zip(antes, atual):
+            d = [(y - x) & 0xFFFFFFFF for x, y in zip(a, b)]
+            total = sum(d)
+            saida.append(0.0 if not total else 1.0 - d[2] / total)
+        return saida
+
+    def rede(self) -> Dict[str, float]:
+        """bytes/s de entrada e saída (soma das interfaces en*)."""
+        s = _rodar(["netstat", "-ib"], 2.0)
+        linhas = s.splitlines()
+        if not linhas:
+            return {"up": 0.0, "down": 0.0}
+        cab = linhas[0].split()
+        try:
+            ii, oi = cab.index("Ibytes"), cab.index("Obytes")
+        except ValueError:
+            return {"up": 0.0, "down": 0.0}
+        vistos, ent, sai = set(), 0, 0
+        for l in linhas[1:]:
+            c = l.split()
+            if len(c) > max(ii, oi) and c[0].startswith("en") and c[0] not in vistos and "<Link" in l:
+                vistos.add(c[0])
+                try:
+                    ent += int(c[ii])
+                    sai += int(c[oi])
+                except ValueError:
+                    pass
+        agora = time.time()
+        antes, self._rede = self._rede, (agora, ent, sai)
+        if not antes or agora <= antes[0]:
+            return {"up": 0.0, "down": 0.0}
+        dt = agora - antes[0]
+        return {"down": max(0, ent - antes[1]) / dt, "up": max(0, sai - antes[2]) / dt}
+
+
+def carregando() -> bool:
+    return "AC Power" in _rodar(["pmset", "-g", "batt"], 2.0) if sys.platform == "darwin" else False
+
+
+def capa_da_faixa() -> str:
+    """URL da capa no Spotify (o Music não expõe URL)."""
+    if sys.platform != "darwin":
+        return ""
+    return _osa('if application "Spotify" is running then tell application "Spotify" to return artwork url of current track', 2.0)
+
+
+# ── extras do HUD de tela cheia: apps do Dock, rede, tempo, mídia ────────
+
+def apps_do_dock() -> List[str]:
+    """Os apps fixos no Dock da pessoa (nomes), via defaults + plutil."""
+    if sys.platform != "darwin":
+        return []
+    import plistlib
+    r = subprocess.run(["defaults", "export", "com.apple.dock", "-"], capture_output=True, timeout=3)
+    try:
+        j = plistlib.loads(r.stdout)
+    except Exception:
+        return []
+    nomes = []
+    for it in j.get("persistent-apps", []):
+        d = it.get("tile-data", {})
+        n = d.get("file-label")
+        if n and n not in ("Launchpad", "Mission Control", "Apps"):
+            nomes.append(n)
+    return nomes
+
+
+def ip_local() -> str:
+    try:
+        import socket
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("10.255.255.255", 1))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return ""
+
+
+def uptime_s() -> int:
+    m = re.search(r"sec = (\d+)", _rodar(["sysctl", "-n", "kern.boottime"], 2.0))
+    return int(time.time() - int(m.group(1))) if m else 0
+
+
+def _json_url(url: str, t: float = 5.0):
+    import json as _j
+    import urllib.request
+    with urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": "primocode"}), timeout=t) as r:
+        return _j.loads(r.read().decode("utf-8", "replace"))
+
+
+def local_e_clima3(cache: dict) -> dict:
+    """IP público, cidade e previsão de 3 dias. ipapi.co + open-meteo: grátis, sem chave. Cache de 30 min."""
+    if time.time() - cache.get("t3", 0) < 1800 and "v3" in cache:
+        return cache["v3"]
+    cache["t3"] = time.time()
+    v = cache.get("v3", {})
+    try:
+        g = _json_url("https://ipapi.co/json/")
+        lat, lon = float(g["latitude"]), float(g["longitude"])
+        v = {"ip_publico": g.get("ip", ""), "cidade": g.get("city", ""), "lat": lat, "lon": lon}
+        f = _json_url(f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}"
+                      "&daily=weather_code,temperature_2m_max,temperature_2m_min&timezone=auto&forecast_days=3")
+        d = f["daily"]
+        v["previsao"] = [{"dia": d["time"][i], "max": round(d["temperature_2m_max"][i]), "min": round(d["temperature_2m_min"][i]),
+                          "cod": d["weather_code"][i]} for i in range(len(d["time"]))]
+    except Exception:
+        pass
+    cache["v3"] = v
+    return v
+
+
+def midia() -> dict:
+    """Spotify (ou Music): estado, posição e duração em segundos."""
+    if sys.platform != "darwin":
+        return {}
+    for app in ("Spotify", "Music"):
+        div = "1000" if app == "Spotify" else "1"
+        r = _osa(f'if application "{app}" is running then tell application "{app}" to return (player state as string) & "|" '
+                 f'& (player position as string) & "|" & ((duration of current track) as string)', 2.0)
+        p = r.split("|")
+        if len(p) == 3:
+            try:
+                return {"app": app, "estado": p[0], "pos": float(p[1].replace(",", ".")),
+                        "dur": float(p[2].replace(",", ".")) / float(div)}
+            except ValueError:
+                continue
+    return {}
+
+
+def controle_midia(acao: str) -> None:
+    cmd = {"anterior": "previous track", "tocar": "playpause", "proxima": "next track"}.get(acao)
+    if not cmd or sys.platform != "darwin":
+        return
+    for app in ("Spotify", "Music"):
+        if _osa(f'application "{app}" is running') == "true":
+            _osa(f'tell application "{app}" to {cmd}')
+            return
+
+
+def executar_acao(m: dict) -> None:
+    """Ações dos botões do HUD. Tudo real; sem Mac, não faz nada."""
+    a, arg = m.get("acao"), str(m.get("arg") or "")
+    if sys.platform != "darwin":
+        return
+    if a == "app" and arg:
+        subprocess.Popen(["open", "-a", arg])
+    elif a == "midia":
+        controle_midia(arg)
+    elif a == "volume":
+        d = 10 if arg == "mais" else -10
+        _osa(f"set volume output volume ((output volume of (get volume settings)) + ({d}))")
+    elif a == "travar":
+        subprocess.Popen(["pmset", "displaysleepnow"])
+    elif a == "foco":
+        subprocess.Popen(["open", "x-apple.systempreferences:com.apple.Focus-Settings.extension"])
+    elif a == "print":
+        pasta = os.path.expanduser("~/Desktop")
+        subprocess.Popen(["screencapture", "-x", os.path.join(pasta, "primo-" + time.strftime("%Y%m%d-%H%M%S") + ".png")])

package/voz/primo_voz/painel_tui.py

@@ -0,0 +1,26 @@
+"""painel_tui.py — o painel do Primo no terminal, para quem não está no Mac (ou sem PyObjC)."""
+from __future__ import annotations
+
+import sys
+import time
+
+from primo_voz import painel as pn
+
+
+def main() -> int:
+    p = pn.Painel()
+    cache: dict = {}
+    am = pn.Amostrador()
+    while True:
+        r = pn.coletar_tudo(cache)
+        p.sistema, p.info = r["sistema"], {**p.info, **r["info"]}
+        sys.stdout.write("\x1b[H\x1b[J" + pn.renderizar_tui(p) + "\n")
+        sys.stdout.flush()
+        time.sleep(2)
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        sys.exit(0)

package/voz/primo_voz/sons.py

@@ -0,0 +1,96 @@
+"""sons.py — os efeitos sonoros de interface do Primo, sintetizados (sem arquivo de terceiros).
+
+Curtos (60-300 ms), de volume baixo, notas de uma escala pentatônica com
+decaimento suave — nada de bipe de alarme. São gerados uma vez em
+~/.primocode/voz-sons/*.wav e tocados com o tocador do sistema. Regra: nunca em
+cima da fala (quem chama passa `falando=True`) e desligável (voz.json "sons":
+false, ou PRIMOCODE_SEM_SONS=1).
+"""
+from __future__ import annotations
+
+import math
+import os
+import shutil
+import struct
+import subprocess
+import sys
+import wave
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+TAXA = 22050
+VOLUME = 0.22     # 0..1 do arquivo; o tocador ainda baixa mais
+
+# nome → lista de (frequência Hz, início s, duração s, ganho)
+RECEITAS: Dict[str, List[Tuple[float, float, float, float]]] = {
+    "boot":        [(261.6, 0.00, 0.30, 0.5), (392.0, 0.18, 0.30, 0.55), (523.3, 0.36, 0.30, 0.6),
+                    (784.0, 0.54, 0.30, 0.7), (1046.5, 0.72, 0.60, 0.9)],
+    "acordou":     [(523.3, 0.00, 0.12, 0.8), (784.0, 0.09, 0.22, 1.0)],
+    "ouvindo":     [(880.0, 0.00, 0.07, 0.6)],
+    "entendeu":    [(659.3, 0.00, 0.07, 0.7), (880.0, 0.06, 0.12, 0.8)],
+    "pensando":    [(392.0, 0.00, 0.18, 0.35)],
+    "pronto":      [(784.0, 0.00, 0.10, 0.7), (1046.5, 0.08, 0.26, 0.9)],
+    "erro":        [(311.1, 0.00, 0.14, 0.9), (233.1, 0.12, 0.26, 0.9)],
+    "painel_abre": [(587.3, 0.00, 0.06, 0.6), (880.0, 0.05, 0.10, 0.7)],
+    "painel_fecha": [(880.0, 0.00, 0.06, 0.6), (587.3, 0.05, 0.10, 0.7)],
+}
+
+
+def sintetizar(nome: str) -> List[int]:
+    notas = RECEITAS[nome]
+    total = max(i + d for _, i, d, _ in notas) + 0.05
+    n = int(total * TAXA)
+    amostras = [0.0] * n
+    for f, ini, dur, g in notas:
+        a = int(ini * TAXA)
+        for k in range(int(dur * TAXA)):
+            if a + k >= n:
+                break
+            t = k / TAXA
+            ataque = min(1.0, t / 0.006)
+            queda = math.exp(-t * (5.0 / dur))
+            v = math.sin(math.tau * f * t) + 0.25 * math.sin(math.tau * 2 * f * t)
+            amostras[a + k] += v * ataque * queda * g
+    pico = max(1e-9, max(abs(x) for x in amostras))
+    return [int(32767 * VOLUME * x / max(pico, 1.0)) for x in amostras]
+
+
+def pasta() -> Path:
+    return Path(os.environ.get("PRIMOCODE_SONS_DIR") or (Path.home() / ".primocode" / "voz-sons"))
+
+
+def arquivo(nome: str) -> Path:
+    p = pasta() / f"{nome}.wav"
+    if not p.exists():
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with wave.open(str(p), "wb") as w:
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(TAXA)
+            w.writeframes(b"".join(struct.pack("<h", x) for x in sintetizar(nome)))
+    return p
+
+
+class Sons:
+    def __init__(self, ligado: bool = True) -> None:
+        self.ligado = ligado and os.environ.get("PRIMOCODE_SEM_SONS") != "1"
+        self.cmd = None
+        if self.ligado:
+            if sys.platform == "darwin":
+                self.cmd = ["afplay", "-v", "0.5"]
+            else:
+                for c in (["paplay"], ["aplay", "-q"], ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet"]):
+                    if shutil.which(c[0]):
+                        self.cmd = c
+                        break
+            self.ligado = bool(self.cmd)
+
+    def tocar(self, nome: str, falando: bool = False) -> bool:
+        """Toca e volta na hora. Em cima da fala (falando=True) não toca."""
+        if not self.ligado or falando or nome not in RECEITAS:
+            return False
+        try:
+            subprocess.Popen(self.cmd + [str(arquivo(nome))], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return True
+        except Exception:
+            return False