Criar comandos e opções com argparse

import argparse

CATALOGO = [
    "Python para análise de dados",
    "Arquitetura de aplicações Python",
    "Algoritmos em prática",
]


def buscar_catalogo(termo: str) -> list[str]:
    termo_normalizado = termo.casefold()
    return [
        titulo
        for titulo in CATALOGO
        if termo_normalizado in titulo.casefold()
    ]


def listar_catalogo() -> list[str]:
    return CATALOGO.copy()


parser = argparse.ArgumentParser(
    description="Consulta um catálogo em memória."
)
argumentos = parser.parse_args()

print("Parser criado. Em seguida, a CLI receberá entradas declaradas.")

import argparse

parser = argparse.ArgumentParser(
    description="Consulta um catálogo em memória."
)

parser.add_argument("termo", help="Texto a procurar no catálogo")
parser.add_argument(
    "-l", "--limite",
    help="Quantidade máxima de itens exibidos"
)
parser.add_argument(
    "-d", "--detalhado",
    action="store_true",
    help="Exibe informações detalhadas"
)

args = parser.parse_args()

import argparse

parser = argparse.ArgumentParser(description="Consulta um catálogo em memória")
parser.add_argument("termo", help="texto a procurar no catálogo")
parser.add_argument(
    "-l",
    "--limite",
    type=int,
    default=5,
    help="quantidade máxima de itens (padrão: 5)",
)
parser.add_argument(
    "-o",
    "--ordenar",
    choices=["nome", "preco"],
    default="nome",
    help="critério de ordenação: nome ou preco (padrão: nome)",
)

args = parser.parse_args()
print(args)

import argparse

parser = argparse.ArgumentParser(
    description="Consulta títulos em um catálogo em memória."
)
parser.add_argument(
    "termo",
    help="termo obrigatório usado na busca; use aspas se houver espaços"
)
parser.add_argument(
    "-l", "--limite",
    type=int,
    default=10,
    help="quantidade máxima de resultados (padrão: 10)"
)
parser.add_argument(
    "--ordem",
    choices=["titulo", "ano"],
    default="titulo",
    help="critério de ordenação: titulo ou ano (padrão: titulo)"
)
parser.add_argument(
    "-d", "--detalhado",
    action="store_true",
    help="exibe também o ano de cada título"
)

args = parser.parse_args()
print(args)

import argparse

parser = argparse.ArgumentParser(
    description="Consulta um catálogo em memória."
)

subparsers = parser.add_subparsers(
    dest="comando",
    required=True,
    title="operações"
)

buscar_parser = subparsers.add_parser(
    "buscar",
    help="busca itens por termo",
    description="Busca itens cujo título contém o termo informado."
)
buscar_parser.add_argument("termo", help="termo da busca")
buscar_parser.add_argument(
    "-l", "--limite",
    type=int,
    default=10,
    help="quantidade máxima de resultados (padrão: 10)"
)
buscar_parser.add_argument(
    "-d", "--detalhado",
    action="store_true",
    help="exibe detalhes de cada item"
)

listar_parser = subparsers.add_parser(
    "listar",
    help="lista todos os itens",
    description="Lista os itens do catálogo em uma ordem escolhida."
)
listar_parser.add_argument(
    "--ordem",
    choices=["titulo", "ano"],
    default="titulo",
    help="critério de ordenação (padrão: titulo)"
)
listar_parser.add_argument(
    "-l", "--limite",
    type=int,
    default=10,
    help="quantidade máxima de resultados (padrão: 10)"
)

args = parser.parse_args()
print(args)

import argparse

CATALOGO = [
    {"titulo": "Python Fluente", "categoria": "programacao"},
    {"titulo": "Arquitetura Limpa", "categoria": "arquitetura"},
    {"titulo": "Python para Dados", "categoria": "dados"},
]


def buscar_catalogo(termo: str, limite: int, detalhes: bool) -> list[str]:
    termo_normalizado = termo.lower()
    encontrados = [
        item
        for item in CATALOGO
        if termo_normalizado in item["titulo"].lower()
    ]

    if detalhes:
        resultados = [
            f"{item['titulo']} — categoria: {item['categoria']}"
            for item in encontrados
        ]
    else:
        resultados = [item["titulo"] for item in encontrados]

    return resultados[:limite]


def listar_catalogo(ordem: str) -> list[str]:
    itens_ordenados = sorted(CATALOGO, key=lambda item: item[ordem])
    return [item["titulo"] for item in itens_ordenados]


def criar_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Consulta um catálogo em memória.")
    subparsers = parser.add_subparsers(dest="operacao", required=True)

    buscar = subparsers.add_parser("buscar", help="Busca títulos no catálogo.")
    buscar.add_argument("termo", help="Termo presente no título.")
    buscar.add_argument("-l", "--limite", type=int, default=3, help="Máximo de resultados.")
    buscar.add_argument("-d", "--detalhes", action="store_true", help="Exibe a categoria.")

    listar = subparsers.add_parser("listar", help="Lista todos os títulos.")
    listar.add_argument(
        "--ordem",
        choices=["titulo", "categoria"],
        default="titulo",
        help="Campo usado para ordenar.",
    )

    return parser


def main() -> None:
    parser = criar_parser()
    args = parser.parse_args()

    if args.operacao == "buscar":
        resultados = buscar_catalogo(
            termo=args.termo,
            limite=args.limite,
            detalhes=args.detalhes,
        )
    elif args.operacao == "listar":
        resultados = listar_catalogo(ordem=args.ordem)

    for resultado in resultados:
        print(resultado)


if __name__ == "__main__":
    main()

import argparse


def criar_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Consulta um catálogo em memória.")
    subcomandos = parser.add_subparsers(dest="comando", required=True)

    buscar = subcomandos.add_parser("buscar", help="Busca itens pelo termo informado.")
    buscar.add_argument("termo", help="Termo a procurar no catálogo.")

    listar = subcomandos.add_parser("listar", help="Lista os itens do catálogo.")

    for comando in (buscar, listar):
        comando.add_argument("-l", "--limite", type=int, default=10)
        comando.add_argument(
            "-o",
            "--ordenar",
            choices=("titulo", "id"),
            default="titulo",
        )
        comando.add_argument("-d", "--detalhado", action="store_true")

    return parser


def buscar_catalogo(termo: str, *, limite: int, ordenar: str, detalhado: bool) -> str:
    return f"Busca por {termo!r}: limite={limite}, ordenar={ordenar}, detalhado={detalhado}"


def listar_catalogo(*, limite: int, ordenar: str, detalhado: bool) -> str:
    return f"Listagem: limite={limite}, ordenar={ordenar}, detalhado={detalhado}"


def main(argv: list[str] | None = None) -> str:
    args = criar_parser().parse_args(argv)

    if args.comando == "buscar":
        return buscar_catalogo(
            args.termo,
            limite=args.limite,
            ordenar=args.ordenar,
            detalhado=args.detalhado,
        )

    return listar_catalogo(
        limite=args.limite,
        ordenar=args.ordenar,
        detalhado=args.detalhado,
    )


parser = criar_parser()

busca = parser.parse_args(
    ["buscar", "python avançado", "--limite", "2", "--detalhado"]
)
assert busca.comando == "buscar"
assert busca.termo == "python avançado"
assert busca.limite == 2
assert busca.detalhado is True

listagem = parser.parse_args(["listar"])
assert listagem.comando == "listar"
assert listagem.limite == 10
assert listagem.ordenar == "titulo"
assert listagem.detalhado is False

import argparse

CATALOGO = [
    {"id": 1, "titulo": "Python para Dados", "autor": "Ana Lima"},
    {"id": 2, "titulo": "Automatize com Python", "autor": "Bruno Reis"},
    {"id": 3, "titulo": "Algoritmos Práticos", "autor": "Carla Souza"},
]


def buscar(termo: str, limite: int, ordem: str, detalhes: bool) -> list[dict]:
    encontrados = [
        livro
        for livro in CATALOGO
        if termo.lower() in livro["titulo"].lower()
    ]
    encontrados.sort(key=lambda livro: livro[ordem])
    return encontrados[:limite]


def listar(ordem: str) -> list[dict]:
    return sorted(CATALOGO, key=lambda livro: livro[ordem])


def mostrar(livros: list[dict], detalhes: bool = False) -> None:
    for livro in livros:
        if detalhes:
            print(f"- #{livro['id']} | {livro['titulo']} | {livro['autor']}")
        else:
            print(f"- {livro['titulo']}")


def construir_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Consulte o catálogo de livros em memória."
    )
    subparsers = parser.add_subparsers(
        dest="comando",
        required=True,
        help="operação a executar",
    )

    parser_buscar = subparsers.add_parser(
        "buscar",
        help="busca livros pelo título",
        description="Busca livros cujo título contém o termo informado.",
    )
    parser_buscar.add_argument("termo", help="termo presente no título")
    parser_buscar.add_argument(
        "-l",
        "--limit",
        type=int,
        default=2,
        help="quantidade máxima de resultados (padrão: 2)",
    )
    parser_buscar.add_argument(
        "-o",
        "--ordem",
        choices=["id", "titulo"],
        default="titulo",
        help="campo de ordenação: id ou titulo (padrão: titulo)",
    )
    parser_buscar.add_argument(
        "-d",
        "--detalhes",
        action="store_true",
        help="mostra identificador e autor",
    )

    parser_listar = subparsers.add_parser(
        "listar",
        help="lista todos os livros",
        description="Lista todos os livros do catálogo.",
    )
    parser_listar.add_argument(
        "-o",
        "--ordem",
        choices=["id", "titulo"],
        default="titulo",
        help="campo de ordenação: id ou titulo (padrão: titulo)",
    )

    return parser


def verificar_parser() -> None:
    parser = construir_parser()

    busca = parser.parse_args(
        ["buscar", "python", "--limit", "3", "--detalhes"]
    )
    assert busca.comando == "buscar"
    assert busca.termo == "python"
    assert busca.limit == 3
    assert busca.ordem == "titulo"
    assert busca.detalhes is True

    listagem = parser.parse_args(["listar"])
    assert listagem.comando == "listar"
    assert listagem.ordem == "titulo"
    assert not hasattr(listagem, "termo")
    assert not hasattr(listagem, "limit")


def main(argv: list[str] | None = None) -> None:
    parser = construir_parser()
    argumentos = parser.parse_args(argv)

    if argumentos.comando == "buscar":
        livros = buscar(
            termo=argumentos.termo,
            limite=argumentos.limit,
            ordem=argumentos.ordem,
            detalhes=argumentos.detalhes,
        )
        mostrar(livros, detalhes=argumentos.detalhes)
    elif argumentos.comando == "listar":
        livros = listar(ordem=argumentos.ordem)
        mostrar(livros)


if __name__ == "__main__":
    main()

python catalogo.py --help
python catalogo.py buscar --help

python catalogo.py buscar python
# - Automatize com Python
# - Python para Dados

python catalogo.py buscar python --limit 1 --detalhes
# - #2 | Automatize com Python | Bruno Reis

python catalogo.py listar --ordem id
# - Python para Dados
# - Automatize com Python
# - Algoritmos Práticos

python catalogo.py buscar python --limit dois
python catalogo.py buscar python --ordem data
python catalogo.py

python -c "from catalogo import verificar_parser; verificar_parser(); print('Verificações concluídas')"