Global optional arguments

Hi again,

I have 2 controller: Base and Parser. In Base I have:

class BaseController(controller.CementBaseController):

    class Meta:
        label = 'base'
        description = "application"
        config_defaults = dict(
            debug = False,
            foo='bar', some_other_option='my default value',
        )

        arguments = [
            (['-f', '--foo'], dict(action='store')),
            (['--log-level'],
                dict(action='store', dest='level',
                    choices=('debug', 'info', 'warn', 'error', 'critical'),
                    help='Change logging level')),

        ]

    @controller.expose(hide=True, aliases=['run'])
    def default(self):
        logger.error("Test error")
        logger.info("Test info")

Thosre are the allowed arguments:

python application.py --help                                                                                                                                                          1 ↵
usage: application.py (sub-commands ...) [options ...] {arguments ...}

application

commands:

  parser
    Parser controller

optional arguments:
  -h, --help            show this help message and exit
  --debug               toggle debug output
  --quiet               suppress all output
  -f FOO, --foo FOO
  --log-level {debug,info,warn,error,critical}
                        Change logging level

Especially the log-level argument should be passed “globally” to all other controller. However when I try to do that, I get:

$ python application.py parser.py --log-level info
usage: application.py (sub-commands ...) [options ...] {arguments ...}
application.py: error: unrecognized arguments: parser.py

The other way around doesn’t work as well:

python application.py --log-level info parser       
usage: application.py (sub-commands ...) [options ...] {arguments ...}
application.py: error: unrecognized arguments: parser

Am I missing sth? Thx in advance.

[derks]

This has now been refactored into the new ArgparseController that will eventually replace CementBaseController.

See: http://cement.readthedocs.org/en/latest/api/ext/ext_argparse/

Essentially, rather than having to duplicate the same option onto every controller… such as ‘log-level’, the controller now honors options throughout the entire change. Meaning, a global option of --log-level belongs on the base controller, and would be passed as:

$ myapp --log-level ERROR [some-controller] --some-other-option {some-command}

The ArgparseController provides the ability for all controllers to handle their arguments (or other arguments) regardless of which controller/function is actually being dispatched.

Example:

class Base(ArgparseController):
    class Meta:
        label = 'base'
        arguments = [
            (['--log-level'], 
             dict(help='modify the log level', dest='log_level', action='store')),
        ]

    def _post_argument_parsing(self):
        # this gets called in every controller after argument parsing, before command execution
        if self.app.pargs.log_level:
            self.app.log.set_level(self.app.pargs.log_level)

The above is just an example, it’s untested… but provided to simply follow up with this discussion. Please see the doc on the new capabilities of cement.ext.ext_argparse.ArgparseController.

[dorneanu]

Your solution worked like a charm! 😃