| """openTARS 5.2: a única porta de entrada para o que muda de sistema (Linux, Windows, macOS). |
| |
| Este arquivo traz a interface e o que não depende do sistema (as pastas); o resto vai para o backend de cada sistema |
| (`linux.py`, `windows.py`, `macos.py`), escolhido na hora da chamada. No Linux é o código que o app já usava; no Windows e no |
| macOS só existe o que dá para fazer sem testar na máquina, e o que falta levanta `NaoSuportado` dizendo a fase do |
| `PLANO_5.2.md` em que entra, para nada falhar em silêncio. Só biblioteca padrão, sem Qt. |
| |
| O que continua preso ao Linux fora daqui, de propósito, até a fase do sistema: a descoberta de programas pelos `.desktop` |
| (`nucleo/aplicacoes.py`), as janelas do X (`nucleo/janelas.py`), a acessibilidade AT-SPI (`tars_acessibilidade.py`), o |
| ydotool do Wayland (`tars_wayland.py`), o atalho global do GNOME (`tars_atalho.py`) e o soquete de instância única em |
| `XDG_RUNTIME_DIR` (`tars_instancia.py`). |
| |
| Interface (devolvem o resultado ou levantam `NaoSuportado`/`OSError`): |
| sistema() "linux" | "windows" | "macos" |
| pastas() {"casa", "config", "dados", "cache"} (Path) |
| abrir(alvo) abre arquivo, pasta ou endereço no programa padrão |
| lixeira(caminho) manda para a lixeira (nunca apaga de vez) |
| notificar(titulo, texto) notificação do sistema (não espera) |
| ler_area_de_transferencia() texto copiado |
| escrever_area_de_transferencia(texto) |
| arquivo_autostart(nome) onde fica o início automático com a sessão |
| autostart(nome, titulo, comando, ligado) liga ou desliga o início automático; devolve se ficou ligado |
| tecla_comando() "ctrl", ou "command" no macOS (colar, copiar, salvar) |
| ler_selecao() o texto marcado agora em qualquer programa ("" se nada) |
| teclas_de_colar() as teclas de colar na janela ativa (Ctrl+Shift+V num terminal do Linux) |
| nome_do_sistema() "Windows 11 23H2", "macOS 15.2 Sequoia" (o Linux lê o /etc/os-release no prompt) |
| janelas(), janela_ativa(), focar_janela(id), fechar_janela(id), mover_janela(id, x, y, largura, altura, maximizar), |
| area_util() fora do Linux (no Linux o núcleo fala com o X direto: nucleo/janelas.py) |
| programas() [{nome, outros_nomes, comando, id}] fora do Linux (no Linux: os .desktop) |
| recursos() {função: existe neste sistema?} (para o diagnóstico) |
| arquivos_selecionados() os arquivos do gerenciador de arquivos no momento do atalho (ações em arquivos) |
| permissoes(), pedir_permissao(qual) só no macOS: {"acessibilidade", "tela"} concedidas?; pedir abre os Ajustes |
| lancador(nome) o comando instalado (opentars, opentars-gui), no PATH ou em ~/.local/bin |
| comando_instalar(*pacotes) "sudo dnf install ..." com os nomes desta distribuição (só no Linux) |
| dica_instalar(texto) troca "sudo apt install x" num texto pelo comando desta distribuição |
| descrever() sistema, versão, arquitetura, núcleos, RAM e Python (para os relatórios) |
| """ |
| import os |
| import platform |
| import re |
| import shutil |
| import sys |
| from pathlib import Path |
|
|
| NOME = "opentars" |
|
|
|
|
| class NaoSuportado(OSError): |
| """Esta função ainda não existe neste sistema; a mensagem diz em que fase da 5.2 ela entra.""" |
|
|
|
|
| def sistema(): |
| if sys.platform.startswith("win"): |
| return "windows" |
| return "macos" if sys.platform == "darwin" else "linux" |
|
|
|
|
| def esconder_consoles_dos_filhos(popen=None, tem_console=None): |
| """Windows sem console (pythonw: a janela e o serviço dos Probes): cada programa de console que o app roda (nvidia-smi, |
| ollama, powershell) abria uma janela preta por cima, e a janela do app parecia travada. Aqui o padrão vira |
| CREATE_NO_WINDOW; quem abre um console para a pessoa passa CREATE_NEW_CONSOLE, e aí o Windows ignora o outro.""" |
| import subprocess |
| popen = popen or subprocess.Popen |
| if tem_console is None: |
| import ctypes |
| tem_console = bool(ctypes.windll.kernel32.GetConsoleWindow()) |
| if tem_console or getattr(popen, "_sem_console", False): |
| return False |
| original = popen.__init__ |
|
|
| def __init__(self, *a, creationflags=0, **k): |
| if not creationflags & (0x10 | 0x08): |
| creationflags |= 0x08000000 |
| original(self, *a, creationflags=creationflags, **k) |
| popen.__init__ = __init__ |
| popen._sem_console = True |
| return True |
|
|
|
|
| def _backend(): |
| so = sistema() |
| if so == "windows": |
| from . import windows as backend |
| elif so == "macos": |
| from . import macos as backend |
| else: |
| from . import linux as backend |
| return backend |
|
|
|
|
| def pastas(): |
| casa = Path.home() |
| so = sistema() |
| if so == "windows": |
| roaming = Path(os.environ.get("APPDATA") or casa / "AppData" / "Roaming") |
| local = Path(os.environ.get("LOCALAPPDATA") or casa / "AppData" / "Local") |
| return {"casa": casa, "config": roaming / NOME, "dados": local / NOME, "cache": local / NOME / "cache"} |
| if so == "macos": |
| base = casa / "Library" |
| return {"casa": casa, "config": base / "Application Support" / NOME, "dados": base / "Application Support" / NOME, |
| "cache": base / "Caches" / NOME} |
| xdg = lambda var, padrao: Path(os.environ.get(var) or casa / padrao) |
| return {"casa": casa, "config": xdg("XDG_CONFIG_HOME", ".config") / NOME, "dados": xdg("XDG_DATA_HOME", ".local/share") / NOME, |
| "cache": xdg("XDG_CACHE_HOME", ".cache") / NOME} |
|
|
|
|
| def abrir(alvo): |
| return _backend().abrir(alvo) |
|
|
|
|
| def arquivos_selecionados(): |
| """Os arquivos selecionados no gerenciador de arquivos quando o atalho foi apertado (Windows e macOS: da cópia simulada |
| do ler_selecao; Linux: os que a pessoa copiou com Ctrl+C). [] se não eram arquivos.""" |
| return _backend().arquivos_selecionados() |
|
|
|
|
| def permissoes(): |
| return _backend().permissoes() if sistema() == "macos" else {} |
|
|
|
|
| def pedir_permissao(qual): |
| return _backend().pedir_permissao(qual) |
|
|
|
|
| def lancador(nome): |
| """O comando instalado (opentars, opentars-gui): no PATH ou em ~/.local/bin, onde os instaladores por usuário o põem |
| (o Arch e o macOS aberto pelo Finder não têm ~/.local/bin no PATH). None se não houver.""" |
| local = Path.home() / ".local" / "bin" / nome |
| return shutil.which(nome) or (str(local) if local.is_file() and os.access(local, os.X_OK) else None) |
|
|
|
|
| def comando_instalar(*pacotes): |
| """Os pacotes vêm com o nome do Debian; volta o comando com os nomes desta distribuição. Fora do Linux, None.""" |
| return _backend().comando_instalar(*pacotes) if sistema() == "linux" else None |
|
|
|
|
| _RE_APT = re.compile(r"sudo apt(?:-get)? install((?: [a-z0-9][\w.+:-]*)+)") |
|
|
|
|
| def dica_instalar(texto): |
| """Troca "sudo apt install x y" num aviso pelo comando desta distribuição (dnf, pacman, zypper), com os nomes de lá.""" |
| if sistema() != "linux" or (_backend().gerenciador() or "apt") == "apt": |
| return texto |
| return _RE_APT.sub(lambda m: comando_instalar(*m.group(1).split()), texto) |
|
|
|
|
| def lixeira(caminho): |
| return _backend().lixeira(caminho) |
|
|
|
|
| def notificar(titulo, texto): |
| return _backend().notificar(titulo, texto) |
|
|
|
|
| def ler_area_de_transferencia(): |
| return _backend().ler_area_de_transferencia() |
|
|
|
|
| def escrever_area_de_transferencia(texto): |
| return _backend().escrever_area_de_transferencia(texto) |
|
|
|
|
| def ler_selecao(): |
| return _backend().ler_selecao() |
|
|
|
|
| def teclas_de_colar(): |
| return _backend().teclas_de_colar() |
|
|
|
|
| def arquivo_autostart(nome): |
| return _backend().arquivo_autostart(nome) |
|
|
|
|
| def autostart(nome, titulo, comando, ligado=True): |
| return _backend().autostart(nome, titulo, comando, ligado) |
|
|
|
|
| def nome_do_sistema(): |
| """O nome que vai no bloco THIS COMPUTER fora do Linux, no formato dos dados da 5.2.""" |
| so = sistema() |
| if so == "macos": |
| versao = platform.mac_ver()[0] |
| nomes = {"26": "Tahoe", "15": "Sequoia", "14": "Sonoma", "13": "Ventura", "12": "Monterey", "11": "Big Sur"} |
| return " ".join(x for x in ("macOS", versao, nomes.get(versao.split(".")[0], "")) if x) |
| if so == "windows": |
| return " ".join(x for x in ("Windows", platform.release(), _versao_windows()) if x) |
| return "Linux" |
|
|
|
|
| def _versao_windows(): |
| """23H2, 24H2...: só o registro sabe (o platform dá o número do build).""" |
| try: |
| import winreg |
| with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows NT\CurrentVersion") as chave: |
| return winreg.QueryValueEx(chave, "DisplayVersion")[0] |
| except (ImportError, OSError): |
| return "" |
|
|
|
|
| def janelas(): |
| return _backend().janelas() |
|
|
|
|
| def janela_ativa(): |
| return _backend().janela_ativa() |
|
|
|
|
| def focar_janela(id_janela): |
| return _backend().focar_janela(id_janela) |
|
|
|
|
| def fechar_janela(id_janela): |
| return _backend().fechar_janela(id_janela) |
|
|
|
|
| def mover_janela(id_janela, x=None, y=None, largura=None, altura=None, maximizar=None): |
| return _backend().mover_janela(id_janela, x, y, largura, altura, maximizar) |
|
|
|
|
| def area_util(): |
| return _backend().area_util() |
|
|
|
|
| def programas(): |
| return _backend().programas() |
|
|
|
|
| def tecla_comando(): |
| return "command" if sistema() == "macos" else "ctrl" |
|
|
|
|
| FUNCOES = ("abrir", "lixeira", "notificar", "ler_area_de_transferencia", "escrever_area_de_transferencia", "autostart", |
| "ler_selecao", "teclas_de_colar") |
| FUNCOES_FORA_DO_LINUX = ("janelas", "programas") |
|
|
|
|
| def recursos(): |
| backend = _backend() |
| funcoes = FUNCOES + (FUNCOES_FORA_DO_LINUX if sistema() != "linux" else ()) |
| return {funcao: funcao in vars(backend) for funcao in funcoes} |
|
|
|
|
| def descrever(): |
| so = sistema() |
| versao = (platform.mac_ver()[0] if so == "macos" else " ".join(x for x in platform.win32_ver()[:2] if x) if so == "windows" |
| else platform.release()) |
| try: |
| import psutil |
| ram = round(psutil.virtual_memory().total / 1024 ** 3, 1) |
| except (ImportError, OSError, AttributeError): |
| ram = None |
| return {"sistema": so, "versao": versao, "plataforma": platform.platform(), "arquitetura": platform.machine(), |
| "processador": platform.processor() or None, "nucleos": os.cpu_count(), "ram_gb": ram, |
| "python": platform.python_version()} |
|
|
|
|
| def janelas_prontas(): |
| """Dá para listar as janelas agora sem esperar? No macOS o Quartz carrega em segundo plano na abertura (leva segundos); |
| até lá, o contexto do pedido segue sem a lista de janelas. Nos outros sistemas, sempre.""" |
| return sistema() != "macos" or _backend().frameworks_prontos() |
|
|
|
|
| if sistema() == "windows": |
| esconder_consoles_dos_filhos() |
| elif sistema() == "macos": |
| _backend() |
|
|
