Python é uma linguagem de programação poderosa que permite aos desenvolvedores criar uma variedade de aplicações, desde scripts básicos até sistemas de software complexos. Uma das tarefas de programação mais comuns é criar interfaces de linha de comando (CLIs), que permitem aos usuários interagir com programas por meio de um terminal ou linha de comando. As CLIs são essenciais para scripting, automação e instâncias em que uma interface gráfica do usuário é impraticável.
O tratamento de parâmetros de linha de comando é uma parte importante do design de CLIs. Esses argumentos permitem que os usuários influenciem o comportamento de um programa fornecendo parâmetros de entrada enquanto ele é executado. Sem a capacidade de avaliar esses fatores, os programas seriam menos versáteis e mais difíceis de ajustar para tarefas específicas.
O Python fornece vários módulos para análise de argumentos de linha de comando, mas o módulo argparse se destaca por sua simplicidade e abrangência. O módulo argparse facilita o desenvolvimento de interfaces funcionais de linha de comando. Ele lida automaticamente com a análise de parâmetros, exibe instruções úteis e fornece erros quando os usuários fornecem informações incorretas.
Neste tutorial, veremos como usar o pacote Python argparse. Começaremos com uma visão geral das interfaces de linha de comando do Python e da importância da análise de entrada de linha de comando. Em seguida, discutiremos o módulo argparse e seus benefícios.
Visão Geral das Interfaces de Linha de Comando em Python
Interfaces de linha de comando são programas que funcionam puramente com comandos baseados em texto. Os usuários inserem comandos em um terminal ou linha de comando, que normalmente incluem argumentos e opções que alteram o comportamento do programa. As CLIs são úteis porque podem ser facilmente automatizadas e integradas com outras tecnologias.
No Python, uma CLI é criada desenvolvendo um script que aceita entrada de linha de comando. Essa entrada é geralmente apresentada como uma lista de argumentos que o script pode acessar e interpretar. Para programas básicos, lidar manualmente com esses argumentos através da lista sys.argv pode ser suficiente. No entanto, quando a complexidade do programa aumenta, processar argumentos manualmente se torna ineficiente e propenso a erros.
Importância do Parsing de Argumentos da Linha de Comando
O parsing de argumentos da linha de comando é necessário por inúmeras razões:
- Flexibilidade: Ao aceitar parâmetros, um programa pode realizar várias tarefas ou agir em diferentes conjuntos de dados sem alterar o código. Os usuários podem especificar arquivos para processar, configurar configurações e selecionar modos de operação.
- Facilidade de uso: O parsing adequado de argumentos permite que o programa exiba mensagens úteis, instrua o usuário sobre como usar o programa e lide adequadamente com falhas.
- Manutenibilidade: Usar um módulo de análise dedicado, como argparse, torna seu código mais claro e mais fácil de manter. Ele separa a lógica usada para analisar os argumentos da operação principal do programa.
Introdução ao Módulo argparse e seus Benefícios
O módulo argparse faz parte da biblioteca padrão do Python. Portanto, pode ser usado sem instalar pacotes adicionais. Ele oferece uma interface direta e consistente para analisar entradas da linha de comando. Algumas das vantagens de utilizar o argparse são:
- Geração automática de ajuda: Gera mensagens de ajuda e uso com base nos argumentos do código.
- Tratamento de erros: Exibe mensagens de erro úteis quando os usuários inserem argumentos inválidos.
- Conversão de tipo: Pode converter automaticamente strings de parâmetros para o tipo de dados apropriado.
- Ele suporta tanto argumentos posicionais necessários quanto argumentos opcionais com simplicidade.
- Valores padrão: Permite fornecer valores padrão para parâmetros que o usuário não fornece.
argparse permite aos desenvolvedores focarem na funcionalidade principal de seus programas enquanto dependem de uma base sólida para gerenciar a entrada da linha de comando.
Configurando argparse e Uso Básico
Agora que cobrimos a importância de analisar argumentos da linha de comando e as vantagens de usar argparse, vamos ver como configurá-lo e usá-lo em um script Python.
Instalando e importando argparse
Não há necessidade de instalar nada separadamente, pois o argparse faz parte da biblioteca padrão do Python. Você pode importá-lo logo no início do seu script.
import argparse
Esta linha carrega o módulo argparse em seu script, permitindo que você use sua funcionalidade para analisar argumentos da linha de comando.
Criando um simples analisador de argumentos
O primeiro passo para utilizar o argparse é gerar um objeto analisador. Esse objeto armazenará informações sobre os argumentos que seu programa aceita e analisará a entrada da linha de comando.
parser = argparse.ArgumentParser(description='Process some integers.')
Neste exemplo, criamos um objeto ArgumentParser() e descrevemos o programa. Quando o usuário selecionar a opção de ajuda (-h ou --help), essa descrição será exibida.
Adicionando argumentos posicionais e opcionais
Agora que desenvolvemos o analisador, podemos especificar os argumentos que nosso programa aceitará.
Adicionando argumentos posicionais
Argumentos posicionais são essenciais e devem ser apresentados em uma ordem precisa. Por exemplo, considere um script que adiciona dois números. Podemos definir dois argumentos posicionais para os números:
parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.')
Neste código, num1 e num2 referem-se aos parâmetros posicionais.
type=int indica que os parâmetros devem ser convertidos em inteiros. O argumento help especifica uma descrição que aparecerá na mensagem de ajuda.
Adicionando argumentos opcionais
Argumentos opcionais não são necessários e normalmente fornecem opções adicionais ou alteram o comportamento do programa. Eles geralmente são prefixados com um ou dois traços. Vamos adicionar um argumento opcional para habilitar a saída verbosa:
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
Aqui:
- A opção curta é
-v(por exemplo,-v).--verboseé uma opção longa. action='store_true'indica que se a opção for selecionada, o atributo verbose será definido comoTrue; caso contrário, seráFalse.- O argumento
helpespecifica uma descrição para a mensagem de ajuda.
Analisando argumentos e acessando seus valores
Após especificar todos os argumentos, precisamos analisar a entrada da linha de comando. Use o método .parse_args() para fazer isso.
args = parser.parse_args()
Os parâmetros analisados estão agora armazenados na variável args como atributos. Podemos acessá-los usando a notação de ponto.
result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Verbose mode is enabled.')
Juntando tudo, aqui está um script completo que soma dois números e inclui um modo verboso opcional:
import argparse parser = argparse.ArgumentParser(description='Add two integers.') parser.add_argument('num1', type=int, help='The first number to add.') parser.add_argument('num2', type=int, help='The second number to add.') parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.') args = parser.parse_args() result = args.num1 + args.num2 print('The sum of {} and {} is {}'.format(args.num1, args.num2, result)) if args.verbose: print('Calculation completed successfully.')
Você pode executar este script a partir da linha de comando e fornecer os argumentos posicionais necessários:
python add_numbers.py 3 5 The sum of 3 and 5 is 8
Se você incluir a opção -v ou --verbose, o script irá imprimir a mensagem detalhada adicional:
python add_numbers.py 3 5 --verbose The sum of 3 and 5 is 8 Calculation completed successfully.
Se o usuário executar o script com a opção -h ou --help, o argparse exibirá uma mensagem de ajuda gerada automaticamente:
python add_numbers.py -h usage: add_numbers.py [-h] [-v] num1 num2 Add two integers. positional arguments: num1 The first number to add. num2 The second number to add. optional arguments: -h, --help show this help message and exit -v, --verbose Increase output verbosity.
Essa funcionalidade torna seu programa mais amigável, fornecendo instruções claras sobre como utilizá-lo.
Manipulação Avançada de Argumentos
Ao desenvolver programas de linha de comando em Python, você pode encontrar cenários que exigem análises de argumentos mais complexas. O módulo argparse do Python inclui várias funcionalidades para lidar com esses requisitos complexos, permitindo que você desenvolva interfaces flexíveis e amigáveis ao usuário.
Usando nargs para múltiplos argumentos
Há situações em que sua aplicação precisa aceitar vários valores para o mesmo argumento. Por exemplo, suponha que você queira criar um script que processe vários arquivos de uma vez. O parâmetro nargs no argparse permite que você especifique quantos argumentos de linha de comando devem ser lidos.
Aqui está como usar nargs para aceitar múltiplos nomes de arquivos:
import argparse parser = argparse.ArgumentParser(description='Process multiple files.') parser.add_argument('filenames', nargs='+', help='List of files to process.') args = parser.parse_args() for filename in args.filenames: print(f'Processing file: {filename}') # Adicione seu código de processamento de arquivos aqui
Neste caso, nargs='+' instrui o analisador a esperar um ou mais argumentos em nomes de arquivo. O usuário pode fornecer quantos nomes de arquivo forem necessários, e eles serão salvos em uma lista chamada args.filenames.
Se você deseja aceitar uma quantidade específica de argumentos, defina nargs para esse número. Por exemplo, nargs=2 requer exatamente dois parâmetros.
Implementando escolhas para limitar valores de argumento
Às vezes, você quer limitar um argumento a um intervalo especificado de valores válidos. Isso garante que o usuário forneça uma entrada válida, evitando assim erros ou ações inesperadas. O parâmetro de opções permite que você especifique os valores permitidos para um argumento.
Considere um script que executa múltiplas atividades dependendo de um modo selecionado pelo usuário.
import argparse parser = argparse.ArgumentParser(description='Perform actions in different modes.') parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.') args = parser.parse_args() if args.mode == 'backup': print('Backing up data...') # Código de backup aqui elif args.mode == 'restore': print('Restoring data...') # Código de restauração aqui elif args.mode == 'delete': print('Deleting data...') # Código de exclusão aqui
No script, o argumento --mode deve ser uma das opções. Se o usuário inserir um valor que não está na lista, argparse retornará uma mensagem de erro.
Tratando flags booleanas e alternâncias
Flags booleanas são escolhas que habilitam ou desabilitam funcionalidades específicas em sua aplicação. Elas são tipicamente definidas sem um valor, apenas incluindo a flag no comando. Você pode lidar com essas flags em argparse com o parâmetro action.
Por exemplo, vamos incluir um modo de depuração em um script:
import argparse parser = argparse.ArgumentParser(description='A script with debug mode.') parser.add_argument('--debug', action='store_true', help='Enable debug output.') args = parser.parse_args() if args.debug: print('Debug mode is enabled.') # Informações adicionais de depuração aqui else: print('Debug mode is disabled.')
Usando action='store_true', a flag --debug definirá args.debug como True quando presente e False caso contrário.
Definindo valores padrão e argumentos obrigatórios
Argumentos opcionais frequentemente incluem valores padrão sensatos. Isso significa que se o usuário não especificar o argumento, a aplicação usará o padrão. O argumento default permite que você especifique um valor padrão.
Aqui está um exemplo:
import argparse parser = argparse.ArgumentParser(description='Adjust program settings.') parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.') args = parser.parse_args() print(f'Timeout is set to {args.timeout} seconds.')
Neste cenário, se o usuário não especificar --timeout, o padrão é de 30 segundos.
Para tornar um argumento opcional obrigatório, set required=True.
import argparse parser = argparse.ArgumentParser(description='Send a message.') parser.add_argument('--recipient', required=True, help='Recipient of the message.') args = parser.parse_args() print(f'Sending message to {args.recipient}.')
O script agora exigirá o argumento --recipient.
Personalizando Mensagens de Ajuda e Erro
Fornecer mensagens claras e úteis aos usuários é um componente essencial no desenvolvimento de um programa de linha de comando eficaz. O módulo argparse do Python cria automaticamente mensagens de ajuda, mas você pode modificá-las para atender melhor às suas necessidades.
Gerando mensagens de ajuda automáticas
Por padrão, o argparse gera uma mensagem de ajuda, que pode ser acessada usando as opções -h ou --help. Essa mensagem contém o uso do programa, uma descrição e informações sobre cada argumento.
Por exemplo:
import argparse parser = argparse.ArgumentParser(description='Calculate factorial of a number.') parser.add_argument('number', type=int, help='The number to calculate the factorial for.') args = parser.parse_args()
Quando um usuário executa o script com -h, eles verão:
usage: script.py [-h] number Calculate factorial of a number. positional arguments: number The number to calculate the factorial for. optional arguments: -h, --help show this help message and exit
Esta mensagem de ajuda automática fornece informações úteis sem exigir esforço adicional.
Personalizando descrições de ajuda e mensagens de uso
Embora as mensagens de ajuda padrão sejam úteis, você pode querer alterá-las para fornecer informações extras ou para se adequar a uma estrutura específica. Você pode alterar a descrição, epílogo e texto de uso no ArgumentParser.
Por exemplo, para incluir um epílogo e personalizar a mensagem de uso:
import argparse parser = argparse.ArgumentParser( description='Convert temperatures between Celsius and Fahrenheit.', epilog='Enjoy using the temperature converter!', usage='%(prog)s [options] temperature') parser.add_argument('temperature', type=float, help='Temperature value to convert.') parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.') parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.') args = parser.parse_args()
Agora, quando o usuário verificar a mensagem de ajuda, ela incluirá a descrição personalizada, uso e epílogo:
python file.py --help usage: p.py [options] temperature Convert temperatures between Celsius and Fahrenheit. positional arguments: temperature Temperature value to convert. options: -h, --help show this help message and exit --to-fahrenheit Convert Celsius to Fahrenheit. --to-celsius Convert Fahrenheit to Celsius.
–to-fahrenheit Converter Celsius para Fahrenheit.
–to-celsius Converter Fahrenheit para Celsius.
Gestão de tratamento de erros e feedback do usuário
import argparse import sys class CustomArgumentParser(argparse.ArgumentParser): def error(self, message): print(f'Error: {message}') self.print_help() sys.exit(2) parser = CustomArgumentParser(description='Divide two numbers.') parser.add_argument('numerator', type=float, help='The numerator.') parser.add_argument('denominator', type=float, help='The denominator.') args = parser.parse_args() if args.denominator == 0: parser.error('Denominator cannot be zero.') result = args.numerator / args.denominator print(f'Result: {result}')
Se um usuário inserir argumentos inválidos, o argparse exibirá uma mensagem de erro e encerrará o programa. Você pode modificar esse comportamento para fornecer um feedback mais útil ou lidar com falhas de forma diferente.
Python file.py 6 0 Error: Denominator cannot be zero. usage: file.py [-h] numerator denominator Divide two numbers. positional arguments: numerator The numerator. denominator The denominator. options: -h, --help show this help message and exit
Uma abordagem é substituir o método de erro em uma subclasse de ArgumentParser:
import argparse import os parser = argparse.ArgumentParser(description='Read a file and display its contents.') parser.add_argument('filepath', help='Path to the file.') args = parser.parse_args() if not os.path.exists(args.filepath): parser.error(f"The file {args.filepath} does not exist.") with open(args.filepath, 'r') as file: contents = file.read() print(contents)
Se o usuário tentar dividir por zero neste script, o aplicativo exibirá um aviso de erro e texto de ajuda, direcionando o usuário a fornecer dados válidos.
python app..py file usage: p.py [-h] filepath app.py: error: The file file does not exist.
Você também pode incluir tratamento de erro personalizado em seu script. Por exemplo, para gerenciar caminhos de arquivos inválidos:
Executar o script com um caminho inválido exibirá o seguinte erro:
Exemplos e casos de uso do mundo real
Entender como usar o módulo argparse em cenários do mundo real tornará sua funcionalidade mais clara. Vamos analisar alguns exemplos de como usar argparse em aplicativos do mundo real.
Construindo uma calculadora de linha de comando
import argparse parser = argparse.ArgumentParser(description='Simple command-line calculator.') parser.add_argument('num1', type=float, help='First number.') parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.') parser.add_argument('num2', type=float, help='Second number.') args = parser.parse_args() if args.operator == '+': result = args.num1 + args.num2 elif args.operator == '-': result = args.num1 - args.num2 elif args.operator == '*': result = args.num1 * args.num2 elif args.operator == '/': if args.num2 == 0: print('Error: Division by zero is not allowed.') exit(1) result = args.num1 / args.num2 print(f'The result is: {result}')
Suponha que você precise desenvolver uma calculadora simples que possa realizar operações aritméticas básicas a partir da linha de comando. Essa calculadora deve aceitar dois números e um operador para executar o cálculo solicitado.
python calculator.py 10 + 5 The result is: 15.0
Aqui está como abordar essa tarefa:
Neste script, o módulo argparse é usado para definir três argumentos posicionais: dois números e um operador. O argumento choices limita o operador a símbolos aritméticos válidos. Quando o usuário executa o script, eles podem realizar esses cálculos:
Essa calculadora básica mostra como as opções de linha de comando podem melhorar a flexibilidade e a interatividade de um programa.
Criando um script de processamento de arquivos com várias opções
import argparse parser = argparse.ArgumentParser(description='Process text files.') parser.add_argument('input_file', help='Path to the input file.') parser.add_argument('-o', '--output', help='Path to the output file.') parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.') parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.') args = parser.parse_args() Suponha que você precise de um script que processe arquivos de texto e forneça escolhas, como designar um arquivo de saída, selecionar um modo de processamento e habilitar a saída detalhada. with open(args.input_file, 'r') as file: content = file.read() if args.verbose: print(f'Reading from {args.input_file}') Aqui está um exemplo de como você poderia configurá-lo: if args.mode == 'uppercase': processed_content = content.upper() else: processed_content = content.lower() if args.verbose: print('Processing content') # Leia o arquivo de entrada if args.output: with open(args.output, 'w') as file: file.write(processed_content) if args.verbose: print(f'Writing output to {args.output}') else: print(processed_content)
# Processe o conteúdo
python text_processor.py input.txt -o output.txt --mode lowercase -v Reading from input.txt Processing content Writing output to output.txt
# Escreva no arquivo de saída ou imprima no console
Este script aceita um arquivo de entrada e possui opções para o arquivo de saída, modo de processamento e saída detalhada. Os usuários podem modificar o comportamento do script sem alterar o código.
Desenvolvendo uma ferramenta CLI com subcomandos
import argparse parser = argparse.ArgumentParser(description='Manage tasks.') subparsers = parser.add_subparsers(dest='command', required=True) Em aplicações mais complicadas, podem ser necessários subcomandos, semelhante ao funcionamento do git utilizando comandos como git commit e git push. O móduloargparsefornece subparsers para esse propósito. parser_add = subparsers.add_parser('add', help='Add a new task.') parser_add.add_argument('name', help='Name of the task.') parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.') Aqui está como fazer uma ferramenta CLI com subcomandos: parser_list = subparsers.add_parser('list', help='List all tasks.') parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.') # Subcomando 'add' parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.') parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.') args = parser.parse_args() if args.command == 'add': print(f"Adding task '{args.name}' with priority {args.priority}") # Subcomando 'list' elif args.command == 'list': print('Listing tasks') if args.all: print('Including completed tasks') # Subcomando 'complete' elif args.command == 'complete': print(f'Marking task {args.task_id} as completed') # Código para adicionar a tarefa
# Código para listar tarefas
# Código para completar a tarefa
python task_manager.py add "Write report" -p 2 Adding task 'Write report' with priority 2
Neste exemplo, o script possui três subcomandos: add, list, e complete. Cada subcomando tem seus próprios argumentos. Quando os usuários executam o script, eles inserem o subcomando e quaisquer outros parâmetros.
python task_manager.py list Listing tasks
Por exemplo:
python task_manager.py complete 3 Marking task 3 as completed
Listando tarefas
Marcando tarefas como concluídas:
subparsers permitem que você crie ferramentas de linha de comando complexas que são bem organizadas e fáceis de estender, permitindo que você construa aplicações que podem fazer várias coisas em uma única interface.
Melhores Práticas e Dicas do Python argparse
Desenvolver programas de linha de comando envolve mais do que simplesmente escrever código que funcione. Também envolve escrever código que seja limpo, manutenível e amigável ao usuário.
Aqui estão algumas melhores práticas ao trabalhar com o módulo argparse.
Organizando o código para legibilidade e manutenção
Quando seus scripts se tornam mais complexos, é fundamental manter seu código organizado para melhor compreensão e manutenção. Uma abordagem para conseguir isso é usar funções e classes para organizar seções distintas do seu código.
Dividir seu programa em partes menores e reutilizáveis facilita a gestão e elimina a duplicação de código.
Por exemplo, em um script de gestão de tarefas, você poderia definir diferentes funções para adicionar tarefas, listar tarefas e concluir tarefas. Essa divisão permite que você se concentre em um aspecto da lógica de cada vez, tornando seu código mais claro.
Outra técnica eficaz é separar sua lógica de análise de argumentos do resto do seu código. Colocar todas as definições de argumentos e a análise no início do seu script, ou em uma função dedicada, facilita para os outros compreenderem como seu programa lida com a entrada.
Usar nomes de variáveis apropriados também melhora a legibilidade. Escolha nomes de variáveis que reflitam seu propósito, para que qualquer pessoa que visualize seu código possa entender o que está acontecendo. Incluir comentários e docstrings para explicar o que suas funções fazem e quaisquer detalhes importantes pode ajudar a aumentar a compreensão.
Testando e depurando aplicativos de linha de comando
Testar seus aplicativos é fundamental para garantir que funcionem corretamente e detectar falhas precocemente. Escrever testes unitários com frameworks de teste Python, como unittest ou pytest, é uma abordagem excelente para testar seu código. Esses testes permitem simular várias entradas e garantir que suas funções funcionem corretamente.
Por exemplo, você pode testar vários cenários simulando as entradas da linha de comando em vez de executar o script pela linha de comando. Essa estratégia permite garantir que o parsing de argumentos funcione conforme o esperado e que sua aplicação lide corretamente com diversos cenários.
Lidar com exceções de maneira adequada também é vital. Usando blocos try-except, você pode capturar erros e fornecer mensagens úteis ao usuário. Isso torna sua aplicação mais estável e amigável ao usuário.
Considere incluir também uma flag de depuração em seu script. Essa flag pode habilitar saídas adicionais que permitem rastrear a execução do programa quando algo dá errado. Ter essa opção facilita diagnosticar problemas ao longo do desenvolvimento e da manutenção.
Comparando argparse com outras bibliotecas de parsing de argumentos
Embora o argparse seja uma ferramenta valiosa na biblioteca padrão do Python, existem outras bibliotecas disponíveis que oferecem métodos alternativos para analisar argumentos da linha de comando. Compreender essas opções ajudará você a selecionar a ferramenta certa para o seu projeto.
Uma dessas bibliotecas é Click. Click é um pacote de terceiros para criar interfaces de linha de comando com decorators. Possui uma sintaxe mais intuitiva e é ideal para aplicações sofisticadas. Por exemplo, você pode usar decorators do Python para criar comandos e opções, tornando seu código mais compacto e compreensível.
Docopt é outra opção que permite definir sua interface de linha de comando usando a docstring do programa. O Docopt analisa automaticamente a mensagem de ajuda e constrói o parser de argumentos quando as instruções de uso estão incluídas na docstring. Essa abordagem é elegante e adequada para scripts simples que requerem uma especificação mais legível para humanos.
Ao escolher qual biblioteca utilizar, pense nas demandas do seu projeto. Se você deseja eliminar dependências externas e quer uma ferramenta que possa lidar com a maioria das circunstâncias, argparse é uma excelente solução. Se você deseja uma sintaxe mais intuitiva e está trabalhando em uma aplicação complexa, Click pode ser mais apropriado. Docopt é uma boa escolha para pequenos programas com interfaces simples.
Conclusão
Ao longo deste artigo, analisamos como usar o módulo argparse do Python para desenvolver programas de linha de comando em Python. Trabalhando através de exemplos do mundo real, aprendemos como criar scripts realistas que recebem entrada do usuário e realizam tarefas relevantes.