Consider `sc.argparse()`

[cliffckerr]

# option 1
args = sc.argparse(
  arg1='foo',
  arg2='bar',
)

# option 2
args = sc.argparse()
args.add(arg1=1, type=int)
args.add(arg2='2')
args.parse()

# usage
python script.py v1 v2
python script.py arg1=v1 arg2=v2
python script.py v1 arg2=v2

[cliffckerr]

Implementation:

import sciris as sc
import sys

class argparse(sc.objdict):

    def __init__(self, parse=True, **kwargs):
        self.update(kwargs)
        if parse and len(kwargs): # If supplied, parse immediately
            self.parse()
        self.setattribute('_parsed', False)
        return

    def add(self, **kwargs):
        """ Add an argument """
        if self._parsed:
            errormsg = 'Cannot and an argument to an already parsed object'
            raise ValueError(errormsg)
        self.update(kwargs)
        return

    def parse(self):
        args = []
        kw = {}
        kw_supplied = False
        for item in sys.argv[1:]:
            if "=" in item:
                key, val = item.split("=", 1)
                key = key.lstrip('-').lstrip().rstrip()
                val = val.lstrip().rstrip()
                kw[key] = val
                kw_supplied = True
            else:
                if kw_supplied:
                    errormsg = 'Cannot supply a positional argument after a keyword argument'
                    raise ValueError(errormsg)
                else:
                    args.append(item)

        def keep_type(key, arg):
            default_type = self[key].__class__
            try:
                out = default_type(arg)
            except Exception as e:
                errormsg = f'Could not convert "{arg}" to {default_type}, leaving as string.\n{e}'
                print(errormsg) # TODO: warning
                out = arg
            return out

        keys = self.keys()
        for i,arg in enumerate(args):
            key = keys[i]
            self[key] = keep_type(key, arg)

        for key,val in kw.items():
            if key not in self:
                errormsg = f'Unrecognized key {key}; valid arguments are:\n{sc.strjoin(self.keys())}'
                raise sc.KeyNotFoundError(errormsg)
            self[key] = keep_type(key, val)
        self.setattribute('_parsed', True)
        return


if __name__ == '__main__':

    # Option 1
    args = argparse(
        foo = 1,
        bar = 'two',
    )
    print(args)

    # Option 2
    args = argparse()
    args.add(foo=1)
    args.add(bar='two')
    args.parse()
    print(args)

Tests:

python argparse_example.py 3 bar='four'
python argparse_example.py 3 4
python argparse_example.py foo=3 --bar='four'