Crie um Script Python com Argumentos e Chamadas de Classes Dinâmicas

Neste post, vamos criar um script Python que aceita argumentos na linha de comando e chama diferentes classes de acordo com esses argumentos. Essa técnica é super útil para criar scripts versáteis e eficientes.

Exemplo Prático

Criaremos um script que atue com diferentes classes e estas com seus próprios argumentos. Em vez de escrever um script separado para cada classe, podemos usar argumentos para controlar o comportamento do script.

Exemplo:

import argparse
import asyncio
COMMANDS = {"cmd1": {"class": FirstClass}, "cmd2": {"class": SecondClass}}
def get_valid_commands():
    return COMMANDS.keys()
async def main():
    parser = argparse.ArgumentParser(prog="python main.py < nome do comando > [ options ]", description="Argumentos para o comando")
    parser.add_argument("--cmd", help="Nome do comando a ser executado", type=str, required=True)
try:
    args, _ = parser.parse_known_args()
    command = args.cmd
    if command == "cmd1":
        parser.add_argument("--arg1", help="Valor para o arg1", type=int, required=False)
        parser.add_argument("--arg2", help="Valor para o arg2", type=str, nargs="+", required=False)
    args = parser.parse_args()
    command_class = COMMANDS[command]["class"]
    kwargs = {}
    if command == "cmd1":
        if "arg1" in args and args.arg1 is not None:
            kwargs["arg1"] = args.arg1
        if "arg2" in args and args.arg2 is not None:
            kwargs["arg2"] = args.arg2
    app = command_class(**kwargs)
    await app()
except (AttributeError, ValueError) as error:
    print(
        f"'Falha ao executar o comando': {command}: {str(error)}"
    )
if name == "main":
    asyncio.run(main())

Explicação do Código

1. Importando Módulos:
   • argparse: Para analisar os argumentos da linha de comando.
   • asyncio: Para lidar com operações assíncronas (se necessário).
2. Definindo Comandos:
   • COMMANDS: Um dicionário que mapeia comandos para suas respectivas classes.
3. Analisando Argumentos:
   • argparse.ArgumentParser: Cria um analisador de argumentos.
   • parser.add_argument: Define os argumentos que o script aceita.
   • args = parser.parse_args(): Analisa os argumentos fornecidos na linha de comando.
4. Chamando Classes Dinamicamente:
   • command_class = COMMANDS[command]["class"]: Obtém a classe correspondente ao comando fornecido.
   • app = command_class(**kwargs): Cria uma instância da classe, passando os argumentos adicionais como kwargs.
   • await app(): Executa o método __call__ da classe (se definido).
5. Tratamento de Erros:
   • Um bloco try-except para capturar erros e registrar mensagens de erro.

Como Executar

python main.py --cmd cmd --arg1 30 --arg2 123 456

Observações

• Adapte o código: Substitua os nomes de classes, módulos e constantes pelos seus próprios.
• Documente o código: Adicione comentários para explicar o que cada parte do código faz.
• Teste o script: Execute o script com diferentes argumentos para garantir que ele funciona como esperado.

Conclusão

Com este guia, você pode criar scripts Python flexíveis e poderosos que aceitam argumentos e chamam classes dinamicamente. Isso permite que você crie scripts mais organizados, eficientes e fáceis de manter.

Espero que este post tenha sido útil!

Fontes de referência

Diversas na internet.