QCommandLineParser¶

PyQt5.QtCore.QCommandLineParser

Description¶

The QCommandLineParser class provides a means for handling the command line options.

QCoreApplication provides the command-line arguments as a simple list of strings. QCommandLineParser provides the ability to define a set of options, parse the command-line arguments, and store which options have actually been used, as well as option values.

Any argument that isn’t an option (i.e. doesn’t start with a -) is stored as a “positional argument”.

The parser handles short names, long names, more than one name for the same option, and option values.

Options on the command line are recognized as starting with a single or double - character(s). The option - (single dash alone) is a special case, often meaning standard input, and not treated as an option. The parser will treat everything after the option -- (double dash) as positional arguments.

Short options are single letters. The option v would be specified by passing -v on the command line. In the default parsing mode, short options can be written in a compact form, for instance -abc is equivalent to -a -b -c. The parsing mode for can be set to ParseAsLongOptions, in which case -abc will be parsed as the long option abc.

Long options are more than one letter long and cannot be compacted together. The long option verbose would be passed as --verbose or -verbose.

Passing values to options can be done using the assignment operator: -v=value --verbose=value, or a space: -v value --verbose value, i.e. the next argument is used as value (even if it starts with a -).

The parser does not support optional values - if an option is set to require a value, one must be present. If such an option is placed last and has no value, the option will be treated as if it had not been specified.

The parser does not automatically support negating or disabling long options by using the format --disable-option or --no-option. However, it is possible to handle this case explicitly by making an option with no-option as one of its names, and handling the option explicitly.

Example:

# int main(int argc, char *argv[])
# {
#     QCoreApplication app(argc, argv);
#     QCoreApplication::setApplicationName("my-copy-program");
#     QCoreApplication::setApplicationVersion("1.0");

#     QCommandLineParser parser;
#     parser.setApplicationDescription("Test helper");
#     parser.addHelpOption();
#     parser.addVersionOption();
#     parser.addPositionalArgument("source", QCoreApplication::translate("main", "Source file to copy."));
#     parser.addPositionalArgument("destination", QCoreApplication::translate("main", "Destination directory."));

#     // A boolean option with a single name (-p)
#     QCommandLineOption showProgressOption("p", QCoreApplication::translate("main", "Show progress during copy"));
#     parser.addOption(showProgressOption);

#     // A boolean option with multiple names (-f, --force)
#     QCommandLineOption forceOption(QStringList() << "f" << "force",
#             QCoreApplication::translate("main", "Overwrite existing files."));
#     parser.addOption(forceOption);

#     // An option with a value
#     QCommandLineOption targetDirectoryOption(QStringList() << "t" << "target-directory",
#             QCoreApplication::translate("main", "Copy all source files into <directory>."),
#             QCoreApplication::translate("main", "directory"));
#     parser.addOption(targetDirectoryOption);

#     // Process the actual command line arguments given by the user
#     parser.process(app);

#     const QStringList args = parser.positionalArguments();
#     // source is args.at(0), destination is args.at(1)

#     bool showProgress = parser.isSet(showProgressOption);
#     bool force = parser.isSet(forceOption);
#     QString targetDir = parser.value(targetDirectoryOption);
#     // ...
# }

If your compiler supports the C++11 standard, the three addOption() calls in the above example can be simplified:

#     parser.addOptions({
#         // A boolean option with a single name (-p)
#         {"p",
#             QCoreApplication::translate("main", "Show progress during copy")},
#         // A boolean option with multiple names (-f, --force)
#         {{"f", "force"},
#             QCoreApplication::translate("main", "Overwrite existing files.")},
#         // An option with a value
#         {{"t", "target-directory"},
#             QCoreApplication::translate("main", "Copy all source files into <directory>."),
#             QCoreApplication::translate("main", "directory")},
#     });

Known limitation: the parsing of Qt options inside QCoreApplication and subclasses happens before QCommandLineParser exists, so it can’t take it into account. This means any option value that looks like a builtin Qt option, will be treated by QCoreApplication as a builtin Qt option. Example: --profile -reverse will lead to QGuiApplication seeing the -reverse option set, and removing it from arguments() before QCommandLineParser defines the profile option and parses the command line.

How to Use QCommandLineParser in Complex Applications¶

In practice, additional error checking needs to be performed on the positional arguments and option values. For example, ranges of numbers should be checked.

It is then advisable to introduce a function to do the command line parsing which takes a struct or class receiving the option values returning an enumeration representing the result. The dnslookup example of the QtNetwork module illustrates this:

# struct DnsQuery
# {
#     DnsQuery() : type(QDnsLookup::A) {}

#     QDnsLookup::Type type;
#     QHostAddress nameServer;
#     QString name;
# };

# struct DnsQuery
# {
#     DnsQuery() : type(QDnsLookup::A) {}

#     QDnsLookup::Type type;
#     QHostAddress nameServer;
#     QString name;
# };

In the main function, help should be printed to the standard output if the help option was passed and the application should return the exit code 0.

If an error was detected, the error message should be printed to the standard error output and the application should return an exit code other than 0.

# This code needs porting to Python.

# /****************************************************************************
# **
# ** Copyright (C) 2016 Jeremy Lainé <jeremy.laine@m4x.org>
# ** Contact: https://www.qt.io/licensing/
# **
# ** This file is part of the examples of the Qt Toolkit.
# **
# ** $QT_BEGIN_LICENSE:BSD$
# ** Commercial License Usage
# ** Licensees holding valid commercial Qt licenses may use this file in
# ** accordance with the commercial license agreement provided with the
# ** Software or, alternatively, in accordance with the terms contained in
# ** a written agreement between you and The Qt Company. For licensing terms
# ** and conditions see https://www.qt.io/terms-conditions. For further
# ** information use the contact form at https://www.qt.io/contact-us.
# **
# ** BSD License Usage
# ** Alternatively, you may use this file under the terms of the BSD license
# ** as follows:
# **
# ** "Redistribution and use in source and binary forms, with or without
# ** modification, are permitted provided that the following conditions are
# ** met:
# **   * Redistributions of source code must retain the above copyright
# **     notice, this list of conditions and the following disclaimer.
# **   * Redistributions in binary form must reproduce the above copyright
# **     notice, this list of conditions and the following disclaimer in
# **     the documentation and/or other materials provided with the
# **     distribution.
# **   * Neither the name of The Qt Company Ltd nor the names of its
# **     contributors may be used to endorse or promote products derived
# **     from this software without specific prior written permission.
# **
# **
# ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
# **
# ** $QT_END_LICENSE$
# **
# ****************************************************************************/

# #include <QDnsLookup>
# #include <QHostAddress>

# #! [0]

# struct DnsQuery
# {
#     DnsQuery() : type(QDnsLookup::A) {}

#     QDnsLookup::Type type;
#     QHostAddress nameServer;
#     QString name;
# };

# #! [0]

# class DnsManager : public QObject
# {
#     Q_OBJECT

# public:
#     DnsManager();
#     void setQuery(const DnsQuery &q) { query = q; }

# public slots:
#     void execute();
#     void showResults();

# private:
#     QDnsLookup *dns;
#     DnsQuery query;
# };

A special case to consider here are GUI applications on Windows and mobile platforms. These applications may not use the standard output or error channels since the output is either discarded or not accessible.

On Windows, QCommandLineParser uses message boxes to display usage information and errors if no console window can be obtained.

For other platforms, it is recommended to display help texts and error messages using a QMessageBox. To preserve the formatting of the help text, rich text with <pre> elements should be used:

switch (parseCommandLine(parser, &query, &errorMessage)) {
case CommandLineOk:
    break;
case CommandLineError:
    QMessageBox::warning(0, QGuiApplication::applicationDisplayName(),
                         "<html><head/><body><h2>" + errorMessage + "</h2><pre>"
                         + parser.helpText() + "</pre></body></html>");
    return 1;
case CommandLineVersionRequested:
    QMessageBox::information(0, QGuiApplication::applicationDisplayName(),
                             QGuiApplication::applicationDisplayName() + ' '
                             + QCoreApplication::applicationVersion());
    return 0;
case CommandLineHelpRequested:
    QMessageBox::warning(0, QGuiApplication::applicationDisplayName(),
                         "<html><head/><body><pre>"
                         + parser.helpText() + "</pre></body></html>");
    return 0;
}

However, this does not apply to the dnslookup example, because it is a console application.

See also

QCommandLineOption, QCoreApplication.

Enums¶

OptionsAfterPositionalArgumentsMode

This enum describes the way the parser interprets options that occur after positional arguments.

Member	Value	Description
ParseAsOptions	0	`application argument --opt -t` is interpreted as setting the options `opt` and `t`, just like `application --opt -t argument` would do. This is the default parsing mode. In order to specify that `--opt` and `-t` are positional arguments instead, the user can use `--`, as in `application argument -- --opt -t`.
ParseAsPositionalArguments	1	`application argument --opt` is interpreted as having two positional arguments, `argument` and `--opt`. This mode is useful for executables that aim to launch other executables (e.g. wrappers, debugging tools, etc.) or that support internal commands followed by options for the command. `argument` is the name of the command, and all options occurring after it can be collected and parsed by another command line parser, possibly in another executable.

SingleDashWordOptionMode

This enum describes the way the parser interprets command-line options that use a single dash followed by multiple letters, as as -abc.

See also

setSingleDashWordOptionMode().

Member	Value	Description
ParseAsCompactedShortOptions	0	`-abc` is interpreted as `-a -b -c`, i.e. as three short options that have been compacted on the command-line, if none of the options take a value. If `a` takes a value, then it is interpreted as `-a bc`, i.e. the short option `a` followed by the value `bc`. This is typically used in tools that behave like compilers, in order to handle options such as `-DDEFINE=VALUE` or `-I/include/path`. This is the default parsing mode. New applications are recommended to use this mode.
ParseAsLongOptions	1	`-abc` is interpreted as `--abc`, i.e. as the long option named `abc`. This is how Qt’s own tools (uic, rcc…) have always been parsing arguments. This mode should be used for preserving compatibility in applications that were parsing arguments in such a way. There is an exception if the `a` option has the ShortOptionStyle flag set, in which case it is still interpreted as `-a bc`.

Methods¶

__init__(): Constructs a command line parser object.

addHelpOption() → QCommandLineOption

Adds the help option (-h, --help and -? on Windows) This option is handled automatically by QCommandLineParser.

Remember to use setApplicationDescription() to set the application description, which will be displayed when this option is used.

Example:

# int main(int argc, char *argv[])
# {
#     QCoreApplication app(argc, argv);
#     QCoreApplication::setApplicationName("my-copy-program");
#     QCoreApplication::setApplicationVersion("1.0");

#     QCommandLineParser parser;
#     parser.setApplicationDescription("Test helper");
#     parser.addHelpOption();
#     parser.addVersionOption();
#     parser.addPositionalArgument("source", QCoreApplication::translate("main", "Source file to copy."));
#     parser.addPositionalArgument("destination", QCoreApplication::translate("main", "Destination directory."));

#     // A boolean option with a single name (-p)
#     QCommandLineOption showProgressOption("p", QCoreApplication::translate("main", "Show progress during copy"));
#     parser.addOption(showProgressOption);

#     // A boolean option with multiple names (-f, --force)
#     QCommandLineOption forceOption(QStringList() << "f" << "force",
#             QCoreApplication::translate("main", "Overwrite existing files."));
#     parser.addOption(forceOption);

#     // An option with a value
#     QCommandLineOption targetDirectoryOption(QStringList() << "t" << "target-directory",
#             QCoreApplication::translate("main", "Copy all source files into <directory>."),
#             QCoreApplication::translate("main", "directory"));
#     parser.addOption(targetDirectoryOption);

#     // Process the actual command line arguments given by the user
#     parser.process(app);

#     const QStringList args = parser.positionalArguments();
#     // source is args.at(0), destination is args.at(1)

#     bool showProgress = parser.isSet(showProgressOption);
#     bool force = parser.isSet(forceOption);
#     QString targetDir = parser.value(targetDirectoryOption);
#     // ...
# }

Returns the option instance, which can be used to call isSet().

addOption(QCommandLineOption) → bool: TODO

addOptions(Iterable[QCommandLineOption]) → bool: TODO

addPositionalArgument(str, str, syntax: str = '')

Defines an additional argument to the application, for the benefit of the help text.

The argument name and description will appear under the Arguments: section of the help. If syntax is specified, it will be appended to the Usage line, otherwise the name will be appended.

Example:

# // Usage: image-editor file
# //
# // Arguments:
# //   file                  The file to open.
# parser.addPositionalArgument("file", QCoreApplication::translate("main", "The file to open."));

# // Usage: web-browser [urls...]
# //
# // Arguments:
# //   urls                URLs to open, optionally.
# parser.addPositionalArgument("urls", QCoreApplication::translate("main", "URLs to open, optionally."), "[urls...]");

# // Usage: cp source destination
# //
# // Arguments:
# //   source                Source file to copy.
# //   destination           Destination directory.
# parser.addPositionalArgument("source", QCoreApplication::translate("main", "Source file to copy."));
# parser.addPositionalArgument("destination", QCoreApplication::translate("main", "Destination directory."));

See also

addHelpOption(), helpText().

addVersionOption() → QCommandLineOption

Adds the -v / --version option, which displays the version string of the application.

This option is handled automatically by QCommandLineParser.

You can set the actual version string by using setApplicationVersion().

Returns the option instance, which can be used to call isSet().

applicationDescription() → str: Returns the application description set in setApplicationDescription().

See also

setApplicationDescription().

clearPositionalArguments()

Clears the definitions of additional arguments from the help text.

This is only needed for the special case of tools which support multiple commands with different options. Once the actual command has been identified, the options for this command can be defined, and the help text for the command can be adjusted accordingly.

Example:

# QCoreApplication app(argc, argv);
# QCommandLineParser parser;

# parser.addPositionalArgument("command", "The command to execute.");

# // Call parse() to find out the positional arguments.
# parser.parse(QCoreApplication::arguments());

# const QStringList args = parser.positionalArguments();
# const QString command = args.isEmpty() ? QString() : args.first();
# if (command == "resize") {
#     parser.clearPositionalArguments();
#     parser.addPositionalArgument("resize", "Resize the object to a new size.", "resize [resize_options]");
#     parser.addOption(QCommandLineOption("size", "New size.", "new_size"));
#     parser.process(app);
#     // ...
# }

# /*
# This code results in context-dependent help:

# $ tool --help
# Usage: tool command

# Arguments:
#   command  The command to execute.

# $ tool resize --help
# Usage: tool resize [resize_options]

# Options:
#   --size <size>  New size.

# Arguments:
#   resize         Resize the object to a new size.
# */

errorText() → str: Returns a translated error text for the user. This should only be called when parse() returns false.

helpText() → str: Returns a string containing the complete help information.

See also

showHelp().

isSet(str) → bool

Checks whether the option name was passed to the application.

Returns true if the option name was set, false otherwise.

The name provided can be any long or short name of any option that was added with addOption(). All the options names are treated as being equivalent. If the name is not recognized or that option was not present, false is returned.

Example:

# bool verbose = parser.isSet("verbose");

isSet(QCommandLineOption) → bool: TODO

optionNames() → List[str]

Returns a list of option names that were found.

This returns a list of all the recognized option names found by the parser, in the order in which they were found. For any long options that were in the form {–option=value}, the value part will have been dropped.

The names in this list do not include the preceding dash characters. Names may appear more than once in this list if they were encountered more than once by the parser.

Any entry in the list can be used with value() or with values() to get any relevant option values.

parse(Iterable[str]) → bool

Parses the command line arguments.

Most programs don’t need to call this, a simple call to process() is enough.

is more low-level, and only does the parsing. The application will have to take care of the error handling, using errorText() if returns false. This can be useful for instance to show a graphical error message in graphical programs.

Calling instead of process() can also be useful in order to ignore unknown options temporarily, because more option definitions will be provided later on (depending on one of the arguments), before calling process().

Don’t forget that arguments must start with the name of the executable (ignored, though).

Returns false in case of a parse error (unknown option or missing value); returns true otherwise.

See also

process().

positionalArguments() → List[str]

Returns a list of positional arguments.

These are all of the arguments that were not recognized as part of an option.

process(Iterable[str])

Processes the command line arguments.

In addition to parsing the options (like parse()), this function also handles the builtin options and handles errors.

The builtin options are --version if addVersionOption() was called and --help if addHelpOption() was called.

When invoking one of these options, or when an error happens (for instance an unknown option was passed), the current process will then stop, using the exit() function.

See also

arguments(), parse().

process(QCoreApplication)

This is an overloaded function.

The command line is obtained from the QCoreApplication instance app.

setApplicationDescription(str): Sets the application description shown by helpText().

See also

applicationDescription().

setOptionsAfterPositionalArgumentsMode(OptionsAfterPositionalArgumentsMode): Sets the parsing mode to parsingMode. This must be called before process() or parse().

setSingleDashWordOptionMode(SingleDashWordOptionMode): Sets the parsing mode to singleDashWordOptionMode. This must be called before process() or parse().

showHelp(exitCode: int = 0): TODO

showVersion(): TODO

unknownOptionNames() → List[str]

Returns a list of unknown option names.

This list will include both long an short name options that were not recognized. For any long options that were in the form {–option=value}, the value part will have been dropped and only the long name is added.

The names in this list do not include the preceding dash characters. Names may appear more than once in this list if they were encountered more than once by the parser.

See also

optionNames().

value(str) → str

Returns the option value found for the given option name optionName, or an empty string if not found.

The name provided can be any long or short name of any option that was added with addOption(). All the option names are treated as being equivalent. If the name is not recognized or that option was not present, an empty string is returned.

For options found by the parser, the last value found for that option is returned. If the option wasn’t specified on the command line, the default value is returned.

An empty string is returned if the option does not take a value.

value(QCommandLineOption) → str: TODO

values(str) → List[str]

Returns a list of option values found for the given option name optionName, or an empty list if not found.

The name provided can be any long or short name of any option that was added with addOption(). All the options names are treated as being equivalent. If the name is not recognized or that option was not present, an empty list is returned.

For options found by the parser, the list will contain an entry for each time the option was encountered by the parser. If the option wasn’t specified on the command line, the default values are returned.

An empty list is returned if the option does not take a value.

values(QCommandLineOption) → List[str]: TODO