Automatização de Bots no Telegram com Python: Scripts para Linux e Windows

@CanalQb no YouTube

Automatize bots com Python para Telegram no Linux e Windows

Olá! Neste post, apresento um script ideal que desenvolvi para automatizar a criação de serviços com Python no Linux (Ubuntu 18.04) e Windows 10.

Embora os comandos também funcionem em outros sistemas operacionais, podem haver pequenas variações por conta de permissões e caminhos. Caso tenha dificuldades, sinta-se à vontade para comentar abaixo!

Se ao menos uma linha deste post for útil, inscreva-se no canal do YouTube:

@CanalQb no YouTube

Objetivo do Script

Este projeto tem como base o uso do Python para automatizar tarefas e criar bots funcionais no Telegram. O script também é útil para executar qualquer automação em Python, mesmo fora do Telegram.

Utilizei como referência outros tutoriais que publiquei anteriormente:

• Importação de TXT para QRCode do Telegram
• Gerador de QRCode com Python

Pré-requisitos para execução

• Python 3.8.10 instalado (ou superior)
• Editor de código (como VS Code, Sublime ou PyCharm)
• Sistema Linux ou Windows

Módulos utilizados

Os módulos utilizados são padrão no Python 3.8.10:

• os
• shutil
• getpass
• time
• ctypes
• subprocess
• sys
• platform

Certifique-se de que o módulo ctypes esteja instalado. Em alguns ambientes ele pode estar ausente:

pip install ctypes

Trecho inicial do script

import os
import shutil
import getpass
import subprocess
import time
import ctypes
import sys
import platform

Função para obter o caminho do Python

Esta função detecta automaticamente o caminho do executável do Python no Windows:

def obter_caminho_python():
    caminho_python = None
    paths = os.environ.get("PATH", "").split(";")
    for path in paths:
        if "python" in path.lower() and "scripts" not in path.lower():
            caminho_python = path.strip()
            break
    return caminho_python

Função para executar comandos como administrador

Permite a execução de comandos em modo administrador no Windows:

def run_as_admin(commands):
    if ctypes.windll.shell32.IsUserAnAdmin():
        for command in commands:
            subprocess.run(command, shell=True)
    else:
        command_str = " && ".join(commands)
        ctypes.windll.shell32.ShellExecuteW(None, "runas", "cmd.exe", "/c " + command_str, None, 1)

Comando para limpar o terminal

clear = lambda: os.system('cls' if os.name == 'nt' else 'clear')

Identificação do sistema operacional

Detecta o tipo de sistema onde o script está sendo executado:

sistema_operacional = platform.system()

if sistema_operacional == "Windows":
    idsystem = 'w'
elif sistema_operacional == "Linux":
    idsystem = 'l'
else:
    idsystem = 'g'

A biblioteca platform identifica sistemas como:

• Windows
• Linux
• macOS (Darwin)
• Outros como FreeBSD, NetBSD, SunOS etc.

Recomendações complementares

Para segurança e performance, recomenda-se usar wallets como Trust Wallet ou MetaMask ao trabalhar com automações envolvendo criptoativos.

Aviso: Este conteúdo tem fins educacionais. Qualquer uso em projetos que envolvam finanças deve ser avaliado com responsabilidade. Faça sempre sua própria pesquisa antes de investir ou utilizar scripts de automação.

---

Entenda a estrutura de pastas necessária para o script funcionar corretamente

Para o funcionamento do script, você precisará ter uma pasta raiz que contém diversas subpastas. Algumas dessas subpastas são usadas pelo script para coletar dados automaticamente, outras para interação com o usuário, além de backups e pastas com scripts que não são mais utilizados.

Como o script filtra e exibe apenas as pastas desejadas para o usuário

O código abaixo obtém o diretório atual, lista as subpastas existentes e exclui aquelas que não deseja mostrar para o usuário, mantendo a interface limpa e funcional:

diretorio_atual = os.getcwd()
pastas = [nome for nome in os.listdir(diretorio_atual) if os.path.isdir(os.path.join(diretorio_atual, nome))]
pastas_excluidas = ["QR", "Mortos", "serviceslinux", "serviceswindows"]
pastas_filtradas = [pasta for pasta in pastas if pasta not in pastas_excluidas]

Assim, o script oculta pastas indesejadas e apresenta somente as demais subpastas da raiz.

Exibição das pastas disponíveis para seleção via terminal

Após limpar a tela, o script apresenta as pastas filtradas para que o usuário escolha a que deseja visualizar:

clear()
print("\n\t\tPastas disponíveis:")
lista_pastas = " | ".join(f"{i+1}. {pasta}" for i, pasta in enumerate(pastas_filtradas))
print("\n\t\t", lista_pastas, "\n")
print("\t\t", "-" * 40)
opcao = input("\t\tDigite o número da pasta que deseja visualizar os arquivos: ")

Esta etapa facilita a navegação, exibindo claramente as opções disponíveis.

Filtragem e listagem dos arquivos Python na pasta selecionada

O script confere se a opção digitada é válida, seleciona a pasta correspondente e lista somente os arquivos com extensão .py:

if opcao.isdigit() and 0 < int(opcao) <= len(pastas_filtradas):
    pasta_selecionada = pastas_filtradas[int(opcao)-1]
    caminho_pasta_selecionada = os.path.join(diretorio_atual, pasta_selecionada)
    arquivos = os.listdir(caminho_pasta_selecionada)
    arquivos_py = [arquivo for arquivo in arquivos if arquivo.endswith(".py")]

    print(f"\n\t\t Arquivos na pasta '{pasta_selecionada}':")
    for arquivo in arquivos_py:
        print("\t\t", arquivo)
else:
    print("Opção inválida. Certifique-se de selecionar um número válido.")

Esta filtragem torna o processo mais eficiente, exibindo apenas os arquivos relevantes para análise ou execução.

Visualização prática via terminal de exemplos de execução

A imagem abaixo mostra a saída do script pelo terminal PuTTY no Linux e pelo CMD no Windows, evidenciando que as pastas excluídas não aparecem na listagem:

Note que somente as pastas permitidas são listadas para interação.

Consulta e seleção de arquivos com extensão .session na pasta QR

O script também consulta a pasta oculta QR e lista os arquivos com a extensão .session para que o usuário escolha qual arquivo usar:

diretorio_atual = os.getcwd()
pasta_qr = os.path.join(diretorio_atual, "QR")
if not os.path.exists(pasta_qr) or not os.path.isdir(pasta_qr):
    print("A pasta QR não existe.")
    exit()

arquivos_session = [arquivo for arquivo in os.listdir(pasta_qr) if arquivo.lower().endswith("session")]

print("\n\t\tArquivos session disponíveis gerados em QR:\n")
for i, arquivo in enumerate(arquivos_session):
    print(f"\t\t{i+1}. {arquivo}")
print("\n\t\t", "-" * 40)
opcao = input("\t\tDigite o número do arquivo session que deseja usar: ")

Esse processo auxilia na seleção do arquivo correto para uso nos scripts automatizados.

Imagens ilustrativas da pasta QR e arquivos session listados

Todos os arquivos da pasta bot/QR

Lendo apenas os arquivos .session da pasta bot/QR

Definição do arquivo session selecionado e verificação do sistema operacional

Após a seleção, o script define o caminho do arquivo escolhido e verifica se o arquivo é compatível com o sistema operacional atual, encerrando o processo em caso de incompatibilidade:

if opcao.isdigit() and 0 < int(opcao) <= len(arquivos_session):
    arquivo_selecionado = arquivos_session[int(opcao)-1]
    caminho_arquivo_selecionado = os.path.join(pasta_qr, arquivo_selecionado)

if arquivo_selecionado.lower().startswith("l"):
    if idsystem == "w":
        print("\n\t\tO arquivo de sessão é para Linux, você está no ambiente errado\n")
        exit()

if arquivo_selecionado.lower().startswith("w"):
    if idsystem == "l":
        print("\n\t\tO arquivo de sessão é para Windows, você está no ambiente errado\n")
        exit()

print(f"\n\t\t{arquivo_selecionado} será espelho para os arquivos da pasta {pasta_selecionada}\n")

Essa validação evita erros na execução e garante a compatibilidade entre sistema e arquivos.

Copiando arquivos session para os arquivos da pasta selecionada

O código a seguir realiza a cópia do arquivo .session selecionado para cada arquivo presente na pasta escolhida inicialmente, renomeando os arquivos conforme o nome base de cada arquivo:

for arquivo in arquivos:
    nome_arquivo, extensao_arquivo = os.path.splitext(arquivo)
    novo_nome_arquivo = nome_arquivo + ".session"
    caminho_destino = os.path.join(diretorio_atual, novo_nome_arquivo)
    shutil.copy(caminho_arquivo_selecionado, caminho_destino)

print("\t\tGerado Sessions com sucesso!")

Assim, o processo é automatizado para gerar sessões específicas baseadas em arquivos existentes, facilitando a execução dos scripts.

Conclusão

Com este guia, você pode entender e adaptar seu script Python para gerenciar pastas e arquivos de forma prática e eficiente, possibilitando automações mais robustas e controle maior sobre seus scripts.

---

Quer mais dicas e tutoriais? Siga o canal no YouTube para conteúdos atualizados.

Basicamente, esta é a estrutura do service que crio para que o serviço do Linux consiga ler todos os arquivos dentro da pasta escolhida, utilizando um único service e chamando o Python uma única vez. Veja as variáveis importantes destacadas em vermelho:

• caminho_pasta_selecionada – por exemplo, neste post usei a pasta dozehoras, então esta variável contém o caminho completo desta pasta;
• usuario – seu usuário do sistema, pode ser seu perfil padrão ou root;
• tempo_reinicio – o tempo configurado para reinício do serviço, conforme sua escolha anterior.

Continuando, veja o código Python que manipula o service:

# Obtendo o diretório atual
diretorio_atual = os.getcwd()

# Nome do serviço baseado na pasta selecionada
nome_servico = pasta_selecionada + ".service"

# Parando e desativando o serviço
comando_parar_servico = f"systemctl stop {nome_servico}"
comando_desativar_servico = f"systemctl disable {nome_servico}"
subprocess.run(comando_parar_servico, shell=True, capture_output=True, text=True)
subprocess.run(comando_desativar_servico, shell=True)

Esta rotina acessa a raiz do projeto, cria o nome do serviço concatenando a variável pasta_selecionada com ".service" e guarda no nome_servico. Depois, ele para e desativa o serviço ativo, caso exista — sem tratativa explícita para erro, mas não interfere no processo.

Em seguida, o arquivo .service criado pelo script é copiado para a pasta /etc/systemd/system. Atenção: alguns sistemas Linux podem ter caminhos diferentes para esta pasta, então é importante verificar esta etapa.

# Caminho completo para o arquivo de serviço
caminho_servico_origem = os.path.join(pasta_services, nome_servico)

# Verificando se o arquivo de serviço existe
if not os.path.exists(caminho_servico_origem) or not os.path.isfile(caminho_servico_origem):
    print(f"\n\t\tO arquivo de serviço '{nome_servico}' não existe na pasta 'serviceslinux'.")
    exit()

# Caminho para o diretório de destino
destino_services = "/etc/systemd/system"

# Verificando se o diretório de destino existe
if not os.path.exists(destino_services) or not os.path.isdir(destino_services):
    print("\n\t\tO diretório '/etc/systemd/system' não existe.")
    exit()

# Caminho completo para o arquivo de serviço de destino
caminho_servico_destino = os.path.join(destino_services, nome_servico)

# Copiando o arquivo de serviço para o diretório de destino
shutil.copy(caminho_servico_origem, caminho_servico_destino)

Após copiar o arquivo para a pasta de serviços do Linux, o script executa os comandos padrão para recarregar o daemon, ativar e iniciar o serviço, além de exibir seu status para validação:

# Executando o comando systemctl daemon-reload
comando_daemon_reload = "systemctl daemon-reload"
subprocess.run(comando_daemon_reload, shell=True)

# Ativando e iniciando o serviço
comando_ativar_servico = f"systemctl enable {nome_servico}"
comando_iniciar_servico = f"systemctl start {nome_servico}"
comando_status_servico = f"systemctl status {nome_servico} | cat"

subprocess.run(comando_ativar_servico, shell=True)
subprocess.run(comando_iniciar_servico, shell=True)
subprocess.run(comando_status_servico, shell=True)

print(f"\n\t\tO serviço '{nome_servico}' foi copiado para '/etc/systemd/system', ativado e iniciado com sucesso.")

O comando daemon-reload recarrega as configurações do Linux para incluir seus novos serviços. Depois disso, o serviço é ativado para iniciar automaticamente no sistema e iniciado imediatamente, com o status exibido para conferência.

Comandos úteis para gerenciamento de serviços no Linux em até 60 caracteres

• Verificar se o arquivo de serviço existe: ls /etc/systemd/system/dozehoras.service
• Verificar status do serviço: systemctl status dozehoras
• Comando journalctl para limpar todos os logs
• Documentação do Journalctl
• Como identificar motivo de serviço inativo
• Recursos do systemd service

Como criar e proteger serviços no Windows via arquivo BAT para execução

O Windows exige a criação de um arquivo batch (.bat) para que o service possa chamar o script. É recomendável proteger a pasta onde o arquivo BAT será salvo para evitar edições indevidas. Afinal, uma invasão com intenções maliciosas dificilmente se limitará a alterar apenas um arquivo BAT.

Exemplo básico de estrutura Python para criar o arquivo BAT:

elif arquivo_selecionado.lower().startswith("w"):
    if idsystem == "w":
        # Código para Windows
        print(f"\n\t\tVocê selecionou o arquivo: {arquivo_selecionado} para todos os arquivos da pasta {pasta_selecionada} no Windows.")

        # Nome do serviço baseado na pasta selecionada
        nome_servico = "0." + pasta_selecionada + "_Service"

        # Criar arquivo .bat para Windows
        nome_arquivo_bat = pasta_selecionada + ".bat"
        caminho_arquivo_bat = os.path.join(diretorio_atual, "serviceswindows", nome_arquivo_bat)

        with open(caminho_arquivo_bat, "w") as arquivo_bat:
            arquivo_bat.write("@echo off\n")
            arquivo_bat.write("setlocal enabledelayedexpansion\n\n")
            arquivo_bat.write(f"set \"python_path={obter_caminho_python()}\\python.exe\"\n")
            arquivo_bat.write(f"set \"script_folder={pasta_selecionada}\"\n\n")
            arquivo_bat.write("for %%f in (\"%script_folder%\\*.py\") do (\n")
            arquivo_bat.write("\t%python_path% \"%%f\"\n")
            arquivo_bat.write(")\n\n")
            arquivo_bat.write("endlocal\n")

Note que a função obter_caminho_python() deve ser implementada para garantir que o caminho do Python seja válido na máquina Windows, garantindo assim a execução correta.

Ao executar o arquivo BAT, todos os scripts Python dentro da pasta selecionada são chamados um a um, da mesma forma que no Linux com systemd.

Essa estrutura possibilita uma manutenção centralizada e padronizada para rodar vários scripts, facilitando a automação e a segurança no ambiente Windows.