Gamertag


Mostrando postagens com marcador python. Mostrar todas as postagens
Mostrando postagens com marcador python. Mostrar todas as postagens

terça-feira, 3 de novembro de 2026

A Biblioteca #3 — o hash, a fila e o problema de uma biblioteca que não para de crescer

No post anterior eu terminei prometendo o texto sobre duplicatas. Sentei para escrever e travei na terceira linha, por um motivo que vou registrar aqui porque é o problema inteiro deste projeto resumido em uma frase: eu não consigo comparar a versão da Steam com a versão da Epic se eu não souber antes onde cada uma delas mora.

Onde a série estava

O post 1 resolveu a posse: o CSV saiu do LaunchBox, cada linha sabendo de onde veio. O post 2 resolveu o uso: a Steam devolve horas, as outras cinco não devolvem nada, e essa assimetria virou a tese da série.

Ficaram pendentes quatro colunas vazias. Duas eu resolvi. E foi ao atacar a terceira — GrupoDuplicata — que tudo parou.

Porque a pergunta "qual das três versões de Batman é a boa" pressupõe que as três estejam na mesma página. E para estarem na mesma página, elas precisam estar no mesmo corte. O corte vem antes de tudo. Não é organização prévia, é condição de existência do problema seguinte.

Por que não por loja, e por que a intuição estava certa

A primeira ideia que eu tive foi a mais óbvia: dividir por loja. Um post por loja, por mês, algo assim.

Aí eu olhei os números reais da planilha.

Origem Jogos Como chegaram
Epic549Resgate semanal gratuito
GOG408Prime Gaming e resgates
Steam320Compra, na maioria
Amazon277Assinatura Prime
Windows (sem loja identificada)74A resolver pelo caminho
EA10Resgate
Uplay11Resgate
Total1.606

Dividir por loja significa vinte e sete posts seguidos sobre jogos da Epic. Vinte e sete textos onde a única coisa em comum entre os jogos é o fato de terem sido resgatados de graça, na mesma plataforma, por motivos que não têm nada a ver uns com os outros.

A loja não é uma categoria do jogo. É uma categoria da sua relação com o jogo, e ela é a mais pobre de todas — porque foi decidida por um algoritmo de desconto, não por você.

A loja não diz nada sobre o jogo. Só diz por onde ele entrou em você.

Por que o alfabético também não serve

A segunda ideia foi a ordem alfabética, e eu gostei dela por um motivo honesto: parecia aleatória.

Não é. Ordenar por título agrupa exatamente o que eu queria evitar.

Todas as franquias caem juntas. Todos os Call of Duty, todos os Need for Speed, todos os Batman. E depois de remover os artigos — The, A, An, O, Os, As — ainda sobra outro agrupamento: as franquias com prefixo numérico e as séries que compartilham a primeira palavra. O alfabeto é um agrupador silencioso, e ele é pior que a loja porque é menos óbvio.

Um bloco alfabético de vinte jogos não é uma amostra da biblioteca. É um recorte de uma prateleira.

E por que não por data

A ordem cronológica seria a melhor de todas, e é a única que eu não tenho.

A data de aquisição não está no CSV, porque o LaunchBox nunca foi usado como launcher — ele foi usado como verificador de compra. Os jogos entraram nele quando eu abri a promoção, não quando eu comprei o jogo. A data que existe é a data em que eu catalogou, e ela não serve para nada neste problema.

Seria possível reconstruir isso da Steam pela API e do GOG pelo banco local. Mas 549 jogos da Epic continuariam sem data, e um corte que cobre dois terços da biblioteca é pior que um corte que cobre tudo.

Eu queria cortar por biografia. Tive que cortar por matemática.

O hash

A solução é calcular o MD5 do título normalizado de cada jogo e ordenar por esse valor.

Normalizar significa: minúsculas, sem acentos, sem pontuação, sem parênteses, sem artigos no começo. O MD5 é a mesma função que eu usei no post do RetroAchievements — aquela que decide se o seu arquivo existe ou não —, só que aplicada a texto em vez de bytes.

E o resultado é o que eu queria desde o começo: uma ordem que não significa nada. Nenhum agrupamento por franquia, por loja, por gênero, por época. Cada bloco de vinte vira uma amostra verdadeiramente aleatória da biblioteca.

Tem uma coisa nisso que me agrada mais do que devia. A mesma função que decidiu, em outubro, se o meu arquivo existia para o RetroAchievements agora decide em que post cada jogo vai cair. Não foi escolha estética — foi a ferramenta que resolveu, duas vezes, problemas que pareciam sem solução.

O hash não sabe qual jogo é bom. Ele sabe que dois arquivos diferentes são coisas diferentes. Numa biblioteca de mil e seiscentos, isso é a única coisa que eu preciso que ele saiba.

O efeito colateral que virou o método

Quando eu vi o primeiro bloco pronto, entendi que o hash não resolveu apenas o corte. Ele criou um mecanismo de descoberta.

Uma recomendação de algoritmo faz uma coisa específica: ela te devolve mais do que você já gosta. A Steam olha o que você jogou e sugere parecido. O resultado é convergência — você afunila, joga mais do mesmo, e a biblioteca fica cada vez mais homogênea em uso.

O hash faz o oposto. Ele te devolve o que você esqueceu. Não o que você gosta hoje — o que você quis no passado. Um jogo que você resgatou em 2019 porque achou interessante na época, quando você era uma pessoa ligeiramente diferente, e que nunca abriu.

E é por isso que ele serve para achar pérola: porque pérola não é um jogo bom. É um jogo que você quis e abandonou antes de começar.

Juntando os dois lados: um bloco de vinte jogos aleatórios tem, estatisticamente, de três a cinco jogos que você não lembra de ter. Em oitenta blocos, isso são duzentos e cinquenta jogos que voltam a existir. Nenhuma loja vai te recomendar esses, porque eles não geram receita. Só um inventário encontra o que não vende mais.

O problema que eu tinha deixado para depois: a biblioteca é viva

Aqui está a parte que qualquer sistema de organização de biblioteca ignora e que me obrigou a repensar o desenho inteiro.

Se eu cortar 1.606 jogos em 80 blocos hoje, em janeiro o número não será mais 1.606. A Epic dá de quatro a cinco jogos grátis por semana. O Prime entrega entre vinte e trinta por mês. E toda promoção boa demais para ignorar — como a de Halloween, sete itens por trinta e dois reais — coloca mais coisa dentro.

Isso significa talvez quatrocentos ou quinhentos jogos novos por ano. Vinte a vinte e cinco blocos a mais, só de crescimento.

Se os blocos fossem recalculados toda vez, todos os posts já escritos ficariam errados. Se os jogos novos fossem jogados para o bloco que o hash deles indica, eles cairiam em blocos já publicados, e eu teria que emendar posts do passado.

Nenhuma das duas funciona. A saída é separar em duas coisas que não são a mesma.

Congelar o acervo, abrir a cauda

Os 1.606 jogos que existem hoje — ou melhor, no dia 26 de outubro de 2026 — são o acervo. Eles recebem os blocos de 1 a 81 e esses números não mudam nunca mais. É arqueologia: a biblioteca como ela era, fotografada num dia.

Tudo que chegar depois entra na cauda, e os blocos da cauda começam no 82 e sobem. Não é ordem alfabética nem hash — é ordem de chegada. É diário.

E aqui está a parte que eu não esperava e que faz o projeto inteiro valer a pena: a série muda de natureza sozinha.

Os primeiros oitenta e um blocos são sobre quem eu fui — a biblioteca acumulada em quinze anos de resgate automático. Do octogésimo segundo em diante, cada bloco é sobre o que acabou de acontecer comigo naquela semana. É o mesmo formato, mas o tempo muda de direção.

Os sete itens da promoção de Halloween já nasceram na cauda. O post que eu escrevi sobre eles não é o post 3 nem o 4 — é o primeiro registro da cauda, escrito antes de eu saber que a cauda existia.

Os primeiros oitenta blocos olham para trás. Depois deles, a série começa a olhar para o lado.

A Fila, que não é uma aba

Sobre a ideia de separar em abas — jogos com conquista numa, sem conquista na outra — eu mudei de opinião, e o motivo é mecânico.

Aba é amputação. Filtro é lente.

No momento em que eu movo 900 jogos para uma aba "sem conquistas", eu perco a única coisa que este projeto tem de mais valioso: a comparação entre o que é mensurável e o que não é. A assimetria entre as lojas — que é a tese do post 2 — deixa de ser visível quando eu separo. Separar é aceitar que são duas coisas diferentes, e o ponto é justamente que são a mesma biblioteca com tratamentos desiguais.

Tem também o problema braçal: cada vez que um status de conquista muda, o jogo precisa mudar de aba. Manual, em 1.606 linhas, é erro garantido.

O que eu vou fazer é o inverso. Uma planilha mestra, editada só por mim, e duas abas geradas por script a partir dela. Elas não são digitadas — são calculadas. Se der errado, eu apago e rodo de novo.

A primeira é a Fila: os candidatos a virar o jogo da semana. Entram só os que têm conquista disponível, estão parados ou nunca abertos, e não foram marcados como "nunca". A ordenação é por custo de fechar — quanto mais perto do fim, mais alto. Isso é diminuição de backlog com o menor esforço possível, que é o único tipo de backlog que se resolve na vida adulta.

A segunda é a Pérolas: vinte jogos por mês, sorteados por hash sobre o acervo, filtrados por "nunca aberto e você quis jogar". Roda todo mês e nunca repete o mesmo conjunto. É a minha resposta à pergunta de como achar pérola em 1.606 jogos: não procurando. Amostrando, todo mês, para sempre.

O script

Três coisas ele faz: calcula o hash, distribui os blocos com o congelamento, e escreve a planilha com as duas abas derivadas.

import csv, re, hashlib, unicodedata, sys
from datetime import datetime

ARQ_ENTRADA = "biblioteca_launchbox_2026-10-26.csv"
ARQ_MESTRE  = "biblioteca_mestra.csv"
ARQ_XLSX    = "biblioteca.xlsx"

DATA_CORTE = datetime(2026, 10, 26).date()
TAM_BLOCO  = 20

ARTIGOS = {"the","a","an","o","os","as","um","uma",
           "le","la","les","el","los","der","die","das"}

def normalizar(t):
    t = unicodedata.normalize("NFKD", (t or "").lower())
    t = "".join(c for c in t if not unicodedata.combining(c))
    t = re.sub(r"[™®©]", " ", t)
    t = re.sub(r"\s*[\(\[].*?[\)\]]", " ", t)
    t = re.sub(r"[^a-z0-9 ]", " ", t)
    p = [x for x in t.split() if x]
    while p and p[0] in ARTIGOS:
        p.pop(0)
    return " ".join(p)

def chave(titulo):
    return hashlib.md5(normalizar(titulo).encode("utf-8")).hexdigest()

def data_entrada(linha):
    for campo in ("DataEntrada", "DataAquisicao", "Added", "DateAdded"):
        v = (linha.get(campo) or "").strip()
        if not v:
            continue
        for fmt in ("%Y-%m-%d", "%d/%m/%Y", "%Y-%m-%dT%H:%M:%S"):
            try:
                return datetime.strptime(v[:19], fmt).date()
            except ValueError:
                pass
    return None

def numero(v):
    try:
        return float(str(v).replace("%", "").replace(",", "."))
    except (TypeError, ValueError):
        return None

with open(ARQ_ENTRADA, encoding="utf-8-sig") as fh:
    linhas = list(csv.DictReader(fh, delimiter=";"))

if not linhas:
    sys.exit("CSV vazio ou separador errado.")

for l in linhas:
    l["_data"]  = data_entrada(l)
    l["_chave"] = chave(l.get("Titulo"))
    l.setdefault("Status", "")
    l.setdefault("TemConquistas", "")
    l.setdefault("PctConquistas", "")
    l.setdefault("Intencao", "")

# acervo = fotografado hoje | cauda = chegou depois
acervo = [l for l in linhas if l["_data"] is None or l["_data"] <= DATA_CORTE]
cauda  = [l for l in linhas if l["_data"] is not None and l["_data"] > DATA_CORTE]

# hash, com desempate deterministico para variantes do mesmo jogo
ORDEM = lambda l: (l["_chave"], (l.get("Loja") or ""), (l.get("Titulo") or ""))
acervo.sort(key=ORDEM)
cauda.sort(key=ORDEM)

def numerar(grupo, inicio):
    for i, l in enumerate(grupo):
        l["Bloco"] = str(inicio + i // TAM_BLOCO)

numerar(acervo, 1)
ultimo = 1 + (len(acervo) - 1) // TAM_BLOCO if acervo else 0
numerar(cauda, ultimo + 1)

# ---------- aba Fila: candidatos ao jogo da semana ----------
fila = []
for l in acervo + cauda:
    if (l.get("TemConquistas") or "").strip().lower() != "sim":
        continue
    st = (l.get("Status") or "").strip().lower()
    if st not in ("nunca aberto", "parado"):
        continue
    if (l.get("Intencao") or "").strip().lower() == "nunca":
        continue
    pct = numero(l.get("PctConquistas")) or 0.0
    l["CustoFechar"] = round(100 - pct, 1) if st == "parado" else 150.0
    fila.append(l)

fila.sort(key=lambda l: (l["CustoFechar"], int(l["Bloco"])))

# ---------- aba Perolas: 20 por mes, rotativas ----------
MES = datetime.now().strftime("%Y-%m")
perolas = [
    l for l in acervo
    if (l.get("Status") or "").strip().lower() == "nunca aberto"
    and (l.get("Intencao") or "").strip().lower() in ("", "jogar", "talvez")
    and ((l.get("TemConquistas") or "").strip().lower() == "sim"
         or (l.get("Genero") or "").strip())
]
perolas.sort(key=lambda l: chave(l.get("Titulo") + MES))
perolas = perolas[:20]

# ---------- grava ----------
campos = [c for c in linhas[0].keys() if not c.startswith("_")]
if "Bloco" not in campos:
    campos.append("Bloco")
if "CustoFechar" not in campos:
    campos.append("CustoFechar")

with open(ARQ_MESTRE, "w", newline="", encoding="utf-8-sig") as fh:
    w = csv.DictWriter(fh, fieldnames=campos, delimiter=";", extrasaction="ignore")
    w.writeheader()
    w.writerows(linhas)

try:
    from openpyxl import Workbook
    from openpyxl.utils import get_column_letter
except ImportError:
    print("openpyxl ausente: pip install openpyxl")
    print("CSV mestre gravado em", ARQ_MESTRE)
    raise SystemExit

wb = Workbook()
ws = wb.active
ws.title = "Mestra"

def escrever(aba, dados, colunas):
    aba.append(colunas)
    for l in dados:
        aba.append([l.get(c, "") for c in colunas])
    for i, c in enumerate(colunas, start=1):
        aba.column_dimensions[get_column_letter(i)].width = max(12, min(38, len(c) + 6))
    aba.freeze_panes = "A2"
    aba.auto_filter.ref = aba.dimensions

escrever(ws, acervo + cauda, campos)

colunas_fila = ["Bloco", "Titulo", "Plataforma", "Loja", "Status",
                "PctConquistas", "CustoFechar", "TempoJogado"]
escrever(wb.create_sheet("Fila"), fila, colunas_fila)

colunas_perolas = ["Bloco", "Titulo", "Plataforma", "Loja", "Genero", "Intencao"]
escrever(wb.create_sheet("Perolas"), perolas, colunas_perolas)

wb.save(ARQ_XLSX)

print("acervo ......", len(acervo))
print("cauda .......", len(cauda))
print("blocos ......", ultimo, "de acervo +", ultimo + (len(cauda) - 1) // TAM_BLOCO if cauda else 0)
print("fila ........", len(fila))
print("perolas .....", len(perolas), "(" + MES + ")")
print("gravado .....", ARQ_XLSX)

Três detalhes do código que existem por um motivo específico.

O desempate (chave, loja, titulo) não é preciosismo. Como eu removo parênteses na normalização, "Batman: Arkham Asylum (GOTY)" e "Batman Arkham Asylum" geram o mesmo hash. Sem desempate, a ordem entre eles varia a cada execução e os blocos mudam sem nada mudar. Com desempate, a ordem é fixa.

E isso tem uma consequência boa para o próximo post: variantes do mesmo jogo caem no mesmo bloco, automaticamente. A normalização que eu fiz para ordenar acabou virando o detector de duplicata. O corte e a duplicata, que pareciam problemas separados, se resolvem com a mesma função.

O segundo detalhe é o l["_data"]: se o CSV não tiver data de aquisição, tudo é acervo e a cauda nasce vazia. É o comportamento certo — nenhuma data significa biblioteca toda anterior. E a partir do primeiro jogo novo que você adicionar com data, a cauda começa a funcionar sozinha.

O terceiro é que a Fila e as Pérolas não são digitadas em nenhum momento. Elas são reconstruídas a cada execução. Errou na mestra, consertou, rodou de novo. Nenhum dado derivado sobrevive à execução seguinte, e é assim que tem que ser.

O que isso muda na escrita

Uma coisa que eu não previ e que vale registrar antes de fechar.

Eu passei três posts tentando organizar a biblioteca para poder escrever sobre ela. O que o hash fez foi tirar de mim a decisão do que vem primeiro — e é uma decisão que eu estava tomando mal, porque eu ia sempre escolher os jogos que eu lembro, que são os jogos que eu gosto, que são os jogos que já tiveram espaço aqui.

Um sistema que eu controlo só me dá o que eu já sei. Um sistema que eu não controlo me dá o que eu esqueci.

E é por isso que eu escolhi o hash e não uma planilha ordenada por preferência. Não é sobre eficiência. É sobre permitir que o acervo fale primeiro.

Uma biblioteca organizada por preferência só repete o que eu já penso. Uma biblioteca organizada por acaso pode me surpreender — e é a única coisa que uma coleção de mil e seiscentos jogos tem a oferecer que quatro jogos bem escolhidos não teriam.

quarta-feira, 9 de abril de 2025

Erro ao instalar CTranslate2 no WindowsErro “No matching distribution found for ctranslate2...” no Windows

Erro ao instalar CTranslate2 no Windows

Erro ao instalar CTranslate2 no Windows

Erro de instalação do CTranslate2 no terminal

Se você tentou instalar o CTranslate2 no Windows usando o comando:

pip install ctranslate2

...e se deparou com o erro:

No matching distribution found for ctranslate2<5,>=4.0

Saiba que esse erro acontece porque atualmente o pacote ctranslate2 não possui builds oficiais para Windows via PyPI.

🔍 O que é o CTranslate2?

É uma biblioteca de inferência de tradução neural otimizada, usada com ferramentas como OpenNMT e Argos Translate (em modos avançados).

❌ Por que o erro acontece?

  • Não há roda (wheel) compatível com Windows disponível
  • Requer compilação nativa ou uso de Linux (WSL ou Docker)
  • Dependências C++ específicas dificultam builds no Windows puro

✅ Alternativas possíveis

  • Use o Argos Translate puro (sem CTranslate2), com desempenho menor porém funcional
  • Utilize WSL (Windows Subsystem for Linux) para rodar a instalação em ambiente Linux
  • Experimente uma imagem Docker pronta para CTranslate2
  • Aguarde builds oficiais ou procure forks com suporte à sua plataforma

⚠️ Evite soluções inseguras

Evite instalar wheels de fontes não confiáveis ou forçar compatibilidades. Use ambientes controlados (como WSL) sempre que possível.


“Nem toda ferramenta poderosa está pronta para todos os sistemas — às vezes o caminho passa por outro terminal.”

Erro ao instalar argostranslate==1.9.6 no Windows: “Could not find a version that satisfies the requirement”

Erro ao instalar argostranslate==1.9.6 no Windows

Erro ao instalar argostranslate==1.9.6 no Windows

Erro no terminal ao instalar Argos Translate

Se você tentou instalar a versão 1.9.6 da biblioteca Argos Translate com o comando:

pip install argostranslate==1.9.6

...e recebeu a mensagem:

Could not find a version that satisfies the requirement argostranslate==1.9.6

Não se preocupe — esse erro é mais comum do que parece e geralmente está ligado a disponibilidade da versão no PyPI ou incompatibilidade com sua versão do Python.

🔎 Causas comuns

  • Versão 1.9.6 não está mais publicada no PyPI
  • Python muito novo ou muito antigo (ex: Python 3.12)
  • Ambiente virtual mal configurado

✅ Como resolver

  1. Verifique versões disponíveis com:
    pip install argostranslate== e aperte Tab (em ambientes interativos)
  2. Ou use:
    pip install argostranslate para pegar a versão mais recente disponível
  3. Certifique-se de estar usando:
    Python 3.9 ou 3.10 para máxima compatibilidade

💡 Dica extra

Você pode instalar versões anteriores manualmente com:

pip install argostranslate==1.8.0

...caso versões mais recentes estejam com bugs ou incompatíveis com sua aplicação.


“Quando a versão certa não aparece, talvez seja hora de mudar o ambiente — ou baixar uma anterior.”

terça-feira, 8 de abril de 2025

Como adicionar o Python ao PATH no Windows

Como adicionar o Python ao PATH no Windows

Como adicionar o Python ao PATH no Windows

Variáveis de ambiente com Python no PATH

Ao instalar o Python no Windows, é comum esquecer de marcar a opção Add Python to PATH. Isso impede que você use o comando python diretamente no terminal. Mas é fácil corrigir isso manualmente.

📍 O que é o PATH?

O PATH é uma variável de ambiente do sistema que indica quais diretórios devem ser procurados ao executar comandos no terminal.

🔎 Como verificar se o Python já está no PATH

Abra o Prompt de Comando (cmd) e digite:

python --version

Se aparecer “comando não encontrado”, você precisa adicionar o Python ao PATH.

🛠️ Como adicionar manualmente

  1. Abra o menu Iniciar e procure por: Editar variáveis de ambiente do sistema
  2. Clique em Variáveis de ambiente
  3. Na seção Variáveis do sistema, selecione Path e clique em Editar
  4. Adicione os caminhos (ajuste conforme sua instalação):
    C:\Python311\
    C:\Python311\Scripts\
  5. Clique em OK e reinicie o terminal

✅ Teste final

Abra o terminal e digite novamente:

python --version

Agora o comando deve funcionar corretamente.


“No mundo da programação, o caminho certo começa com o PATH certo.”

Passo a passo para instalação do pyUGT (versão Python do Universal Game Translator)

Como instalar o pyUGT no Windows

Como instalar o pyUGT no Windows

Terminal com pyUGT rodando no Windows

O pyUGT é uma versão leve e em Python do Universal Game Translator, ideal para usuários mais técnicos ou que desejam controle total sobre OCR e tradução local.

📦 Requisitos

  • Python 3.8 ou superior instalado
  • PIP configurado corretamente
  • Git (opcional, mas recomendado para clonar o repositório)
  • Tesseract OCR instalado

🧱 Etapas de instalação

  1. Instale o Python e adicione ao PATH
  2. Abra o terminal (cmd ou PowerShell)
  3. Clone o repositório:
    git clone https://github.com/ianmclinden/pyUGT
  4. Entre na pasta:
    cd pyUGT
  5. Instale as dependências:
    pip install -r requirements.txt
  6. Rode o tradutor:
    python pyUGT.py

⚙️ Pós-instalação

  • Configure a região da tela para captura de texto
  • Escolha idioma de entrada e de saída
  • Teste com textos simples primeiro

💡 Dica

Use Argos Translate como tradutor offline e o Tesseract como OCR local para uma solução 100% gratuita.


“Tradução em tempo real com código aberto é liberdade digital para quem joga — e para quem cria.”