Vfrdtyky

I have the following CLI program which adds two numbers:

import argparse



def foo(args):

    print('X + Y:', args.x + args.y)

    return args.x + args.y





if __name__ == '__main__':

    parser = argparse.ArgumentParser()

    subparsers = parser.add_subparsers()



    foo_parser = subparsers.add_parser('foo')

    foo_parser.add_argument('-x', type=int, default=1)

    foo_parser.add_argument('-y', type=int, default=2)

    foo_parser.set_defaults(func=foo)



    parser.add_argument('--debug', action='store_true', default=False)





    args = parser.parse_args()

    args.func(args)

Suppose now I want my users to also be able to import foo and call it directly with arguments x and y. I.e. I want foo to look like this:

def foo(x, y):

    print('X + Y:', x + y)

    return x + y

How can I adapt args.func(args) to handle this new foo?

The use of args.func(**vars(args)) is not a best fit for use-cases which require import as well as a CLI view

• When users import a function and call it, they expect a return value for further processing (nothing printed on a console. The caller can decide to print based on the result obtained)


• When they use a CLI, they expect to see an output printed on the console and a proper exit code (0 or 1 based on the return value)

The ideal way is to separate the parsing/CLI management/sum-function into separate functions and delegate processing once the parsing is complete (below is a sample example)

from __future__ import print_function # for python2

import argparse



def mysum(x, y=5):

    return x+y



def delegator(input_args):

    func_map = {

        "mysum" : {

            "func" : mysum,

            "args": (input_args.get("x"),),

            "kwargs" : {

                "y" : input_args.get("y")

            },

            "result_renderer": print

         }

    }



    func_data = func_map.get(input_args.get("action_to_perform"))



    func = func_data.get("func")

    args = func_data.get("args")

    kwargs = func_data.get("kwargs")

    renderer = func_data.get("result_renderer")



    renderer(func(*args, **kwargs))



if __name__ == '__main__':

    parser = argparse.ArgumentParser()

    subparsers = parser.add_subparsers(dest="action_to_perform")



    foo_parser = subparsers.add_parser('mysum')

    foo_parser.add_argument('-x', metavar='PATH', type=int, default=1)

    foo_parser.add_argument('-y', metavar='PATH', type=int, default=3)

    delegator(vars(parser.parse_args()))

Above example would also remove *args, **kwargs from your original function and lets the delegator send only what is needed by the function based on the command

You can extend it to support multiple commands

Hope this helps!

This is the cleanest way I've found so far:

import argparse



def foo(*, x, y, **kwargs):

    print('X + Y:', x + y)

    return x + y



if __name__ == '__main__':

    parser = argparse.ArgumentParser()

    subparsers = parser.add_subparsers()



    foo_parser = subparsers.add_parser('foo')

    foo_parser.add_argument('-x', metavar='PATH', type=int, default=1)

    foo_parser.add_argument('-y', metavar='PATH', type=int, default=2)

    foo_parser.set_defaults(func=foo)



    parser.add_argument('--debug', action='store_true', default=False)



    args = parser.parse_args()

    args.func(**vars(args))

Maybe someone else can find something better.