This is solved, I was being dumb. Please see second EDIT below

This isn’t really language specific, but if it helps I’m using Python. I can get the parameters just fine with the Traitlets module, but I’m still a novice really and figuring out which patterns to use is challenging.

Say you have a bunch of command line parameters. Some are booleans, where their presence means True, absence means False. Other parameters must accept one text string, and others can be used multiple times to build a list of strings.

It feels inefficient/wrong to use a bunch of IF/THEN/ELSE statements to decide what to do with the parameters, and prone to edge case errors. Is there a pattern that would invoke the correct method based on the combination of input parameters?

Examples:

app thing --dry-run --create --name=newname01 --name=newname02 --verbose

app thing --create --name=newname01 --name=newname02 --name=newname03

app job --cancel -i 01 -i 02 -i 03

EDIT: Via the Traitlets module, I get those arguments parsed and accessible as self.argname, so getting them into my app is working great. It’s just deciding what to do with them that is confusing me.

Thank you, sorry for my noobness.

EDIT2: I think I understand where I’m going wrong:

I’m creating subcommands based on objects, not actions. i.e. appname thing --action should really be appname action --thing. Once things are divided up into actions, assigning things to those actions will be much, much easier and straightforward.

Sorry for a confusing and fairly pointless post :(

As a few others mentioned, the argparse module from the stdlib is the way to go for Python. It takes care of most of this for you in an optimized way. Here’s a minimal example of the above:

#!/bin/env python3

import argparse


# Setup main parser
parser = argparse.ArgumentParser(
    prog="app",
    description="App that manages things and jobs",
)
parser.add_argument(
    "-v",
    "--verbose",
    action="store_true",
)
subparsers = parser.add_subparser(
    help="Sub commands",
    dest="command",
)

# Setup sub-parsers
thing_parser = subparsers.add_parser(
    "thing",
    help="Manage things",
)
# thing_parser args
thing_parser.add_argument(
    "--dry_run",
    action="store_true",
    help="dry run",
)
thing_parser.add_argument(
    "--create",
    action="store_true",
    help="Create thing",
)
thing_parser.add_argument(
    "--name",
    action="store",
    type=str,
    required=True,
    nargs="+",
    help="Thing name",
)

job_parser = subparsers.add_parser(
    "job",
    help="Manage jobs",
)
job_parser.add_argument(
    "--cancel",
    "-c",
    action="store_true",
    help="Cancel job",
)
job_parser.add_argument(
    "--index",
    "-i",
    action="store",
    type=int,
    required=True,
    nargs="+",
    help="Job index",
)


def main():
    args=parser.parse_args()
    if args.verbose:
        print("Verbose mode")
    # Match-Case statement for cleaner logic
    match args.command:
        case "thing":
            # thing logic and function calls here
        case "job":
            # job logic and function calls here
        case _:
            parser.print_usage()

if __name__ == "__main__":
    main()
@bloopernova@programming.dev
creator
link
fedilink
English
81Y

That’s an awesome answer, thank you very much. It’s much more elegant than my stuff!

You’re very welcome! I’ve spent a lot of time with Python and really think that argparse as of 3.x makes most non-stdlib libraries for parsing are unnecessary. You get a ton of functionally and ability to add end-user documentation as you go, while abstracting away some of the basics like type casting/checking

The addition of Match-Case, while not adding much, functionally, does a LOT for readability and keeping logic clear.

@bloopernova@programming.dev
creator
link
fedilink
English
31Y

I’m so annoyed with myself for using Traitlets for command line argument parsing! Your solution using argparse has so many more useful options, like the ability to define a mutually exclusive group of arguments.

Sigh. I live and learn and code a bunch more lol.

No reason to be annoyed with yourself. It’s part of the process of learning. In starting with Traitlets, you tried something new to you and between that and refactoring to use argparse, you’ve given yourself more practice writing code and learned a bit more about available libraries. And, at the same time, you’ve worked through the logic of your CLI design, building a better understanding of ways to organize arguments.

deleted by creator

Create a post

Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!

Cross posting is strongly encouraged in the instance. If you feel your post or another person’s post makes sense in another community cross post into it.

Hope you enjoy the instance!

Rules

Rules

  • Follow the programming.dev instance rules
  • Keep content related to programming in some way
  • If you’re posting long videos try to add in some form of tldr for those who don’t want to watch videos

Wormhole

Follow the wormhole through a path of communities !webdev@programming.dev



  • 1 user online
  • 1 user / day
  • 1 user / week
  • 1 user / month
  • 1.11K users / 6 months
  • 1 subscriber
  • 1.21K Posts
  • 17.8K Comments
  • Modlog