O Python chegou a Eorzea! 🐍

Nesse projeto, resolvi unir o estudo com o lazer: desenvolvi um script de web scraping utilizando BeautifulSoup e Python para extração de dados de armas do MMORPG Final Fantasy XIV, um dos meus jogos favoritos. Os dados estão disponíveis no Eorzea Database.

Durante meus estudos de Engenharia de Dados, sempre tive dúvidas sobre temas de projetos, ainda mais relacionados a extração de dados. Portanto, pensei que seria interessante utilizar dados de fontes que eu conheço bem e que podem me trazer insights para minha própria rotina no jogo.

Para esse pipeline escolhi a base de armas, o item mais cobiçado de qualquer jogo de RPG. Extraí informações essenciais que podem ser utilizadas para ranquear as armas por diversos critérios, como dano, raridade, etc.

Informações extraídas:

• Nome da arma;
• Nível da arma;
• Nível mínimo para uso;
• Classe(s) que pode(m) usar;
• Tipo da arma (espada, cajado, lança...)
• Atributos principais (Strength, Vitality, Mind...);
• Dano físico / Auto-ataque / Delay;
• Raridade (com base na cor do contorno do ícone);
• Fonte do item (ex: vendido por NPC, obtido por coffer, comprado com tomestones...).

Um dos desafios que enfrentei durante o desenvolvimento desse projeto foi relacionado a volumetria de dados. O Eorzea Database possui 5872 itens, separados em 118 páginas. Utilizando apenas laços de repetição, meu pipeline estava com problemas de performance, chegando a demorar mais de 30 minutos para extrair todos os dados.

Outro ponto a se mencionar é que o robots.txt do Eorzea Database não determina nenhum bloqueio, o que me permite rodar o script sem delays. Apesar disso, evito rodar o scraping com frequência para não sobrecarregar o servidor do Lodestone.

Diante disso, pesquisei por alternativas e encontrei algumas soluções que aumentaram drasticamente a performance do meu script:

• Utilização de cache com persistência em disco para evitar re-scraping desnecessário;


Configuração de cache Copy
1 try:
2 requests_cache.install_cache(
3 '../ffxiv_cache', # Cria um diretório chamado 'ffxiv_cache'.
4 backend='filesystem', # Armazena o cache no disco.
5 expire_after=NEVER_EXPIRE, # Cache setado para não expirar.
6 allowable_methods=['GET'], # Métodos permitidos no cache.
7 include_get_headers=True # Considera os cabeçalhos da requisição no cache.
8 )
9 print("Cache configurado.")
10 except Exception as e:
11 print(f"Erro: {str(e)}")
12
14 try:
15 with requests_cache.CachedSession() as session:
16 session.headers.update(headers)
17 print("Sessão configurada.")
18 except Exception as e:
19 print(f"Erro: {str(e)}")
Code copied to clipboard!



• Paralelização para processar os loops mais rapidamente;


processar_armas.py Copy
1 # Utilizando a classe Parallel da biblioteca joblib do Python para
2 # processar a extração dos dados usando 8 núcleos da CPU, preparando cada
3 # execução (sem executar imediatamente)
4
5 def processar_armas(urls_itens):
6
7 urls_itens = list(set(urls_itens))
8 resultados = Parallel(n_jobs=8)(delayed(extrair_infos_arma)(url) for url in urls_itens)
9 return [r for r in resultados if r is not None]
10
11 # Utilizando a classe ThreadPoolExecutor da biblioteca concurrent.futures
12 # para criar um pool de 10 threads, onde o executor.submit irá enviar
13 # a função processar_pagina, com cada URL, para uma thread livre.
14
15 # Por exemplo, se houverem 100 URLs, 10 serão processadas imediatamente
16 # (1 por thread), e as demais aguardarão em uma fila.
17
18 with ThreadPoolExecutor(max_workers=10) as executor:
19 futures = [executor.submit(processar_pagina, url) for url in urls_paginas]
20
21 # Aqui, os resultados são coletados assim que a execução termina
22 # (método as_completed).
23 for future in tqdm(as_completed(futures), total=len(futures)):
24 resultado = future.result()
25 if resultado:
26 dados_completos.extend(resultado)
27
28
29 df = pd.DataFrame(dados_completos)
30 print(f"Finalizado! {len(df)} itens obtidos.")
Code copied to clipboard!