Versão Final do Lives do Cellbit

[victorblino]

Plano de Refatoração para Versão Final

Objetivo

Criar uma versão final mais limpa, organizada e fácil de manter usando:

• Orientação a Objetos
• responsabilidades bem separadas
• menos código confuso e menos variáveis globais
• entrada de aplicação clara e testável

---

1. Diagnóstico inicial

Atualmente, o bot está distribuído em:

• bot.py — lógica principal, configuração e webhooks
• functions/botFunctions.py — utilitários misturados
• functions/twitchFunctions.py — lógica de Twitch e EventSub
• functions/twitterFunctions.py — lógica de Twitter
• utils/variables.py — configuração e estado global

Problemas observados:

• estados globais espalhados (online, currentGame, gamesPlayed, etc.)
• inicialização com efeitos colaterais em importação de módulos
• funções com responsabilidades mistas (e.g., tweet + download + comparação)
• código síncrono e assíncrono misturados sem padrão claro
• pouca separação entre configuração, serviço, estado e handlers

---

2. Arquitetura proposta

2.1. Camadas sugeridas

1. Config / Settings

   • Carrega variáveis de ambiente
   • Valida configurações essenciais
   • Disponibiliza valores como app_id, app_secret, twitter_token, webhook_url

2. Domain / State

   • Representa o estado da transmissão
   • Ex.: StreamState, ChannelStatus, GameHistory
   • Substitui variáveis globais por atributos de instância

3. Service / Client

   • TwitchClient / EventSubService
   • TwitterClient / TwitterService
   • ImageService / AssetService

4. Handlers

   • Métodos de eventos: on_stream_online, on_stream_offline, on_channel_update
   • Não fazem a inicialização; apenas recebem serviços e estado

5. Application / BotManager

   • Responsável pela montagem dos componentes
   • Executa main() ou run()
   • Inicia EventSub e mantém o loop

2.2. Classes principais sugeridas

• Config ou BotConfig
• BotState ou StreamState
• TwitchService
• TwitterService
• GameImageService
• EventSubManager
• BotApplication

---

3. Plano de etapas detalhado

Etapa 1 — Organização do projeto

1. Criar arquivos/classes separadas:

   • config.py ou utils/config.py
   • services/twitch_service.py
   • services/twitter_service.py
   • services/image_service.py
   • handlers/stream_handlers.py
   • bot.py somente como ponto de entrada

2. Mover leitura de .env e variáveis de ambiente para uma classe Config.

3. Mover constantes e listas fixas para um local único (ex.: constants.py).

Etapa 2 — Definir estado e domínio

1. Criar StreamState:

   • online: bool
   • current_game: str | None
   • current_title: str | None
   • stream_id: str | None
   • games_played: list[str]

2. Criar GameHistory ou GameTracker se precisar de regras extras.

3. Evitar usar variáveis globais em módulos. Todas as funções devem receber instâncias.

Etapa 3 — Criar serviços responsáveis

1. TwitterService

   • post_status(text: str)
   • post_status_with_image(text: str, image_path: str)
   • tratamento de exceções específico

2. TwitchService

   • autenticar Twitch
   • buscar usuário e stream
   • obter título e categoria atual
   • buscar box art de jogo

3. EventSubManager

   • inscrever e iniciar webhooks
   • conectar callbacks de eventos

4. GameImageService

   • baixar imagem do jogo
   • comparar imagens padrão
   • fornecer fallback quando falhar

Etapa 4 — Implementar handlers limpos

1. StreamHandlers deve receber Config, StreamState, TwitterService, TwitchService, GameImageService.

2. Cada handler deve:

   • validar dados de evento
   • atualizar StreamState
   • chamar o serviço apropriado
   • logar apenas resultados ou erros

3. Exemplo de fluxo:

   • on_stream_online(data)
     • atualiza estado
     • chama twitter_service.post_status(...)
   • on_channel_update(data)
     • detecta mudança de jogo / título
     • baixa imagem somente se necessário
     • atualiza histórico de jogos

Etapa 5 — Refatoração incremental

1. Fazer uma primeira versão de Config e StreamState.
2. Substituir uso de globais no bot.py e em todos os módulos.
3. Refatorar twitterFunctions.py para ser TwitterService.
4. Refatorar twitchFunctions.py para TwitchService + EventSubManager.
5. Refatorar utilitários em botFunctions.py para métodos de serviço ou funções puras.
6. Garantir que cada módulo tenha um único propósito.

Etapa 6 — Testes e validação

1. Escrever testes unitários para:

   • TwitterService (mock de API)
   • GameImageService
   • StreamState / GameHistory
   • handlers: reação a channel_update, stream_offline, stream_online

2. Testar manualmente com um ambiente local ou sandbox Twitch/Twitter.

3. Validar que bot.py não executa nada ao importar o módulo; apenas executa via if __name__ == '__main__':.

Etapa 7 — Polimento final

1. Atualizar README.md com instruções de uso, variáveis de ambiente e deploy.

2. Incluir Procfile / requirements.txt corretos e possivelmente runtime.txt se usar Heroku.

3. Adicionar logs estruturados em vez de print() quando possível.

4. Revisar nomes de variáveis para clareza, por exemplo:

   • current_game em vez de currentGame
   • stream_title em vez de currentTitle
   • game_blacklist

5. Remover código comentado e imports não usados.

---

4. Melhorias específicas para versão final

• Evitar try/except genéricos sem tratamento (except:)
• Retirar chamadas diretas de API no nível do módulo
• Evitar inserir time.sleep() ou threading.Event() fora da aplicação principal
• Garantir que cada classe seja pequena e com responsabilidade única
• Usar tipagem typing e docstrings simples
• Aplicar boas práticas de código Python e PEP 8

---

5. Exemplo de fluxo de implementação

1. config.py -> BotConfig
2. state.py -> StreamState
3. services/twitter_service.py, services/twitch_service.py, services/image_service.py
4. handlers/stream_handlers.py
5. bot.py -> BotApplication(run)
6. Testes em tests/ ou src/tests/

---

6. Resultado esperado

Ao final, a aplicação deve ter:

• código fácil de entender
• dependências e inicialização claras
• classes com funções bem definidas
• estado gerenciado em objetos, não em globais
• event handlers simples e testáveis
• um ponto de entrada único e seguro