backlogops-cli 0.2__py3-none-any.whl → 0.3__py3-none-any.whl

backlogops_cli/_command_io.py

@@ -20,11 +20,39 @@ from backlogops_cli._migrate_warn import (
     CliMigrateWarnHook, CliPresetMigrateWarnHook)
 from backlogops_cli.bloc_version_reporter import BloCliVersionReporter
 from backlogops import (
-    BacklogOpsConfig, BacklogReleases, FileExistsCb, FormatRules, Levels,
-    ReleaseChanges, ReleaseDateChanges, allow_overwrite,
-    format_content_changes, format_date_changes, get_backlog_ops_config,
-    read_backlog_releases, resolve_input_config, resolve_output_config,
-    write_backlog_releases, write_content_changes, write_date_changes)
+    BacklogOpsConfig, BacklogReleases, FileExistsCb, FormatRules,
+    JiraRankAnchor, Levels, ReleaseChanges, ReleaseDateChanges,
+    allow_overwrite, format_content_changes, format_date_changes,
+    get_backlog_ops_config, read_backlog_releases, resolve_input_config,
+    resolve_output_config, write_backlog_releases, write_content_changes,
+    write_date_changes)
+
+RANK_ANCHOR_CHOICES = {
+    'backlog-top': JiraRankAnchor.BACKLOG_TOP,
+    'backlog-bottom': JiraRankAnchor.BACKLOG_BOTTOM,
+    'first-key': JiraRankAnchor.FIRST_KEY,
+    'last-key': JiraRankAnchor.LAST_KEY}
+"""Command-line anchor names mapped to :class:`JiraRankAnchor` members."""
+
+
+def rank_anchor(value: Optional[str]) -> Optional[JiraRankAnchor]:
+    """Return the anchor for a CLI anchor name, or None for a None value."""
+    return None if value is None else RANK_ANCHOR_CHOICES[value]
+
+
+def add_rank_arg(parser: argparse.ArgumentParser) -> None:
+    """Add the optional ``--rank`` flag choosing a Jira rank anchor.
+
+    Shared by the add and update commands, where ranking is opt-in: without
+    ``--rank`` the Jira rank order is left unchanged.
+    """
+    parser.add_argument('--rank', dest='rank', default=None,
+                        choices=sorted(RANK_ANCHOR_CHOICES),
+                        help='Also set the Jira rank order to match the '
+                        'supplied backlog, placing the items at this anchor: '
+                        'backlog-top, backlog-bottom, first-key (keep the '
+                        'first item fixed) or last-key (keep the last item '
+                        'fixed). Omit to leave the Jira rank order unchanged.')
 
 
 def overwrite_callback(force: bool, in_stream: Optional[TextIO] = None,
@@ -255,11 +283,14 @@ def _write_output(parsed: argparse.Namespace,
 
 def run_write(parsed: argparse.Namespace,
               data_source: Callable[[Optional[BacklogOpsConfig]],
-                                    BacklogReleases]) -> int:
+                                    BacklogReleases],
+              require_config: bool = False) -> int:
     """Build the data, write it to the output file, and report the result.
 
-    The configuration is resolved once from ``-c`` or by discovery, falling
-    back to the built-in defaults when none is found.
+    The configuration is resolved once from ``-c`` or by discovery. It
+    falls back to the built-in defaults when none is found, unless
+    ``require_config`` is True, in which case a missing configuration is
+    reported as an error.
 
     Args:
         parsed: Parsed command line arguments holding the output options
@@ -269,12 +300,15 @@ def run_write(parsed: argparse.Namespace,
             None) and returns the backlog and releases to write. It is
             called inside the error handling so that reading failures are
             reported like writing failures.
+        require_config: When True a missing configuration is reported as an
+            error instead of falling back to the built-in defaults.
 
     Returns:
         ``0`` on success, ``1`` when the data cannot be built or written.
     """
     try:
-        config = optional_config(parsed)
+        config = (required_config(parsed) if require_config
+                  else optional_config(parsed))
         _write_output(parsed, config, data_source(config))
     except (ValueError, TypeError, KeyError, OSError) as error:
         print(f'Could not write {parsed.output}: {error}', file=sys.stderr)

backlogops_cli/add_releases_to_jira.py

@@ -0,0 +1,144 @@
+#! /usr/local/bin/python3
+"""Add releases to Jira from an input file, creating one version per name.
+
+The command reads a backlog and its releases from the input file, then
+adds the releases to Jira using a named preset of the backlog-ops
+configuration. By default it stops with an error when a release name
+already exists in Jira; ``--skip-existing`` skips those releases instead.
+
+The added releases and the releases already in Jira are printed to stdout
+as two labelled lists, unless ``-q``/``--quiet`` is given. Each list is
+also written, together with the unchanged input backlog, to a file when
+``--added-file`` or ``--existing-file`` names one; without a file name the
+list is not written. An encrypted Jira token is unlocked by a pass phrase
+asked on the terminal only when it is needed.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from getpass import getpass
+from typing import Optional
+from backlogops import (
+    AddedReleasesToJira, BacklogOpsConfig, BacklogReleases, FormatRules,
+    JiraConnections, OnExistingKey, ReleaseExistsError, add_releases_to_jira,
+    format_release_result, resolve_output_config, write_backlog_releases)
+from backlogops_cli._command_io import (
+    add_config_arg, add_input_args, overwrite_callback, parsed_args,
+    read_input, required_config)
+from backlogops_cli._migrate_warn import CliPresetMigrateWarnHook
+
+DESCRIPTION = 'Add releases to Jira, creating a new version per release'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the add-releases command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    add_config_arg(parser)
+    parser.add_argument('-p', '--preset', dest='preset', required=True,
+                        help='Name of the Jira preset in the configuration.')
+    parser.add_argument('--skip-existing', dest='skip_existing',
+                        action='store_true',
+                        help='Skip releases whose name already exists in Jira '
+                        '(the default stops with an error instead).')
+    parser.add_argument('--added-file', dest='added_file', metavar='FILE',
+                        help='Write the added releases, with the input '
+                        'backlog, to this file. Omit to not write it.')
+    parser.add_argument('--existing-file', dest='existing_file',
+                        metavar='FILE',
+                        help='Write the releases already in Jira, with the '
+                        'input backlog, to this file. Omit to not write it.')
+    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
+                        help='Do not print the added and already-present '
+                        'lists to stdout.')
+    parser.add_argument('-f', '--force', dest='force', action='store_true',
+                        help='Overwrite existing output files without '
+                        'asking.')
+    return parser
+
+
+def _passphrase() -> str:
+    """Ask for the Jira token pass phrase on the terminal."""
+    return getpass('Jira API token pass phrase: ')
+
+
+def _add(parsed: argparse.Namespace, config: BacklogOpsConfig,
+         data: BacklogReleases) -> AddedReleasesToJira:
+    """Add the input releases to Jira using the named preset."""
+    print(f"Adding releases to Jira using preset '{parsed.preset}'...",
+          file=sys.stderr)
+    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    mode = (OnExistingKey.SKIP if parsed.skip_existing
+            else OnExistingKey.RAISE)
+    result = add_releases_to_jira(connections, parsed.preset, data.releases,
+                                  on_existing_key=mode)
+    print(f'Added {len(result.stored)} releases to Jira; '
+          f'{len(result.already_present)} already present; '
+          f'{len(result.failed)} failed.', file=sys.stderr)
+    return result
+
+
+def _write_file(config: BacklogOpsConfig, path: str, data: BacklogReleases,
+                force: bool) -> None:
+    """Write one backlog-and-releases result to a file."""
+    out_config = resolve_output_config(None, data_file=path,
+                                       presets=config.output_configs,
+                                       auto_ch_hook=CliPresetMigrateWarnHook())
+    write_backlog_releases(data, path, out_config, FormatRules(),
+                           levels=config.get_levels(),
+                           file_exists_callback=overwrite_callback(force))
+    print(f'Wrote {path}')
+
+
+def _write_result_files(parsed: argparse.Namespace, config: BacklogOpsConfig,
+                        data: BacklogReleases,
+                        result: AddedReleasesToJira) -> None:
+    """Write the added and already-present releases to any named files."""
+    backlog = list(data.backlog)
+    if parsed.added_file is not None:
+        added = BacklogReleases(backlog=backlog, releases=result.stored)
+        _write_file(config, parsed.added_file, added, parsed.force)
+    if parsed.existing_file is not None:
+        present = BacklogReleases(backlog=backlog,
+                                  releases=result.already_present)
+        _write_file(config, parsed.existing_file, present, parsed.force)
+
+
+def _run(parsed: argparse.Namespace) -> int:
+    """Read the input, add the releases, write files and print the lists."""
+    try:
+        config = required_config(parsed)
+        data = read_input(parsed, config)
+        result = _add(parsed, config, data)
+        _write_result_files(parsed, config, data, result)
+    except ReleaseExistsError:
+        print('Nothing added to Jira.', file=sys.stderr)
+        return 1
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'Could not add releases to Jira: {error}', file=sys.stderr)
+        return 1
+    if not parsed.quiet:
+        print(format_release_result(result))
+    return 0
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Add releases to Jira and report the added and present releases.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the releases cannot be added or a name
+        already exists in Jira without ``--skip-existing``.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return _run(parsed)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/add_to_jira.py

@@ -0,0 +1,151 @@
+#! /usr/local/bin/python3
+"""Add a backlog to Jira from an input file, creating one issue per item.
+
+The command reads a backlog (or a backlog and its releases) from the input
+file, then adds the backlog items to Jira using a named preset of the
+backlog-ops configuration. By default it stops with an error when an
+item's key already exists in Jira; ``--skip-existing`` skips those items
+instead. With ``--rank`` the items are also ranked in Jira to match the
+supplied backlog order, at the chosen anchor.
+
+The added items (carrying their new Jira keys) and the items already in
+Jira are printed to stdout as two labelled lists, unless ``-q``/``--quiet``
+is given. Each list is also written to a file when ``--added-file`` or
+``--existing-file`` names one; without a file name the list is not written.
+An encrypted Jira token is unlocked by a pass phrase asked on the terminal
+only when it is needed.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from getpass import getpass
+from typing import Optional
+from backlogops import (
+    AddedToJira, BacklogOpsConfig, BacklogReleases, ExistsInJiraError,
+    FormatRules, JiraConnections, OnExistingKey, add_backlog_to_jira,
+    format_add_result, resolve_output_config, write_backlog_releases)
+from backlogops_cli._command_io import (
+    add_config_arg, add_input_args, add_rank_arg, overwrite_callback,
+    parsed_args, rank_anchor, read_input, required_config)
+from backlogops_cli._migrate_warn import CliPresetMigrateWarnHook
+
+DESCRIPTION = 'Add a backlog to Jira, creating a new issue per item'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the add-to-Jira command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    add_config_arg(parser)
+    parser.add_argument('-p', '--preset', dest='preset', required=True,
+                        help='Name of the Jira preset in the configuration.')
+    parser.add_argument('--skip-existing', dest='skip_existing',
+                        action='store_true',
+                        help='Skip items whose key already exists in Jira '
+                        '(the default stops with an error instead).')
+    add_rank_arg(parser)
+    parser.add_argument('--added-file', dest='added_file', metavar='FILE',
+                        help='Write the added items, with their new Jira '
+                        'keys, to this file. Omit to not write it.')
+    parser.add_argument('--existing-file', dest='existing_file',
+                        metavar='FILE',
+                        help='Write the items already in Jira to this file. '
+                        'Omit to not write it.')
+    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
+                        help='Do not print the added and already-present '
+                        'lists to stdout.')
+    parser.add_argument('-f', '--force', dest='force', action='store_true',
+                        help='Overwrite existing output files without '
+                        'asking.')
+    return parser
+
+
+def _passphrase() -> str:
+    """Ask for the Jira token pass phrase on the terminal."""
+    return getpass('Jira API token pass phrase: ')
+
+
+def _add(parsed: argparse.Namespace, config: BacklogOpsConfig,
+         data: BacklogReleases) -> AddedToJira:
+    """Add the input backlog to Jira using the named write preset."""
+    print(f"Adding backlog to Jira using preset '{parsed.preset}'...",
+          file=sys.stderr)
+    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    mode = (OnExistingKey.SKIP if parsed.skip_existing
+            else OnExistingKey.RAISE)
+    result = add_backlog_to_jira(connections, parsed.preset, data.backlog,
+                                 on_existing_key=mode,
+                                 rank_anchor=rank_anchor(parsed.rank),
+                                 levels=config.get_levels(),
+                                 status_map=config.get_status_input_map())
+    print(f'Added {len(result.stored)} items to Jira; '
+          f'{len(result.already_present)} already present; '
+          f'{len(result.failed)} failed; '
+          f'{len(result.failed_links)} links not written.', file=sys.stderr)
+    return result
+
+
+def _write_backlog_file(config: BacklogOpsConfig, path: str,
+                        data: BacklogReleases, force: bool) -> None:
+    """Write one returned backlog and the input releases to a file."""
+    out_config = resolve_output_config(None, data_file=path,
+                                       presets=config.output_configs,
+                                       auto_ch_hook=CliPresetMigrateWarnHook())
+    write_backlog_releases(data, path, out_config, FormatRules(),
+                           levels=config.get_levels(),
+                           file_exists_callback=overwrite_callback(force))
+    print(f'Wrote {path}')
+
+
+def _write_result_files(parsed: argparse.Namespace, config: BacklogOpsConfig,
+                        data: BacklogReleases, result: AddedToJira) -> None:
+    """Write the added and already-present backlogs to any named files."""
+    releases = list(data.releases)
+    if parsed.added_file is not None:
+        added = BacklogReleases(backlog=result.stored, releases=releases)
+        _write_backlog_file(config, parsed.added_file, added, parsed.force)
+    if parsed.existing_file is not None:
+        present = BacklogReleases(backlog=result.already_present,
+                                  releases=releases)
+        _write_backlog_file(config, parsed.existing_file, present,
+                            parsed.force)
+
+
+def _run(parsed: argparse.Namespace) -> int:
+    """Read the input, add it to Jira, write files and print the lists."""
+    try:
+        config = required_config(parsed)
+        data = read_input(parsed, config)
+        result = _add(parsed, config, data)
+        _write_result_files(parsed, config, data, result)
+    except ExistsInJiraError:
+        print('Nothing added to Jira.', file=sys.stderr)
+        return 1
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'Could not add to Jira: {error}', file=sys.stderr)
+        return 1
+    if not parsed.quiet:
+        print(format_add_result(result))
+    return 0
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Add a backlog to Jira and report the added and present items.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the backlog cannot be added or a key
+        already exists in Jira without ``--skip-existing``.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return _run(parsed)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/jira_fields.py

@@ -0,0 +1,91 @@
+#! /usr/local/bin/python3
+"""Print Jira field information for a preset, to diagnose write mappings.
+
+The command prints the custom field id to display name map that the reader
+fetches from Jira, so a column-map name such as 'Story point estimate' can
+be matched to its field id. With ``--issue`` it also prints the fields the
+given issue's edit screen offers, which explains why a mapped field cannot
+be set on that issue's type: a field missing from the edit screen cannot be
+set through the issue edit REST endpoint.
+
+An encrypted Jira token is unlocked by a pass phrase asked on the terminal
+only when it is needed.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from getpass import getpass
+from typing import Optional
+from jira import JIRAError
+from backlogops import (
+    JiraConnections, jira_custom_fields, jira_editable_fields)
+from backlogops_cli._command_io import (
+    add_config_arg, parsed_args, required_config)
+
+DESCRIPTION = "Print Jira custom fields and an issue's editable fields"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the field diagnostic command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_config_arg(parser)
+    parser.add_argument('-p', '--preset', dest='preset', required=True,
+                        help='Name of the Jira preset in the configuration.')
+    parser.add_argument('--issue', dest='issue', metavar='KEY',
+                        help="Also print the fields this issue's edit "
+                        'screen offers (for example SCRUM-15).')
+    return parser
+
+
+def _passphrase() -> str:
+    """Ask for the Jira token pass phrase on the terminal."""
+    return getpass('Jira API token pass phrase: ')
+
+
+def _print_pairs(heading: str, pairs: list[tuple[str, str]]) -> None:
+    """Print a heading and each field id and display name pair."""
+    print(heading)
+    if not pairs:
+        print('  (none)')
+    for field_id, name in pairs:
+        print(f'  {field_id}  {name}')
+
+
+def _run(parsed: argparse.Namespace) -> int:
+    """Print the custom field map and, optionally, editable fields."""
+    try:
+        config = required_config(parsed)
+        connections = JiraConnections(config.get_jira_config(), _passphrase)
+        customs = jira_custom_fields(connections, parsed.preset)
+        editable = (jira_editable_fields(connections, parsed.preset,
+                                         parsed.issue)
+                    if parsed.issue is not None else None)
+    except (ValueError, TypeError, KeyError, OSError, JIRAError) as error:
+        print(f'Could not read Jira fields: {error}', file=sys.stderr)
+        return 1
+    _print_pairs(f"Custom fields for preset '{parsed.preset}':", customs)
+    if editable is not None:
+        print()
+        _print_pairs(f'Fields settable on the edit screen of '
+                     f'{parsed.issue}:', editable)
+    return 0
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Print Jira field information for a preset.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the fields cannot be read.
+    """
+    return _run(parsed_args(build_parser(), args))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/order_releases_in_jira.py

@@ -0,0 +1,128 @@
+#! /usr/local/bin/python3
+"""Order releases in Jira, changing the order of a project's versions.
+
+The command reorders the Jira versions of a named preset of the backlog-ops
+configuration. Exactly one order source must be given, and the three are
+mutually exclusive: ``--by-date`` orders the versions by their own release
+date, earliest first, with undated versions at the end; ``--name-list`` names
+a file whose lines give the wanted order, one release name per line; and
+``-i``/``--input`` names a backlog-and-releases input file whose release order
+is used. argparse enforces that exactly one of the three is given.
+
+With ``--by-date`` every version is ordered. With a name source, the named
+versions are moved to the front in the listed order and every other version
+keeps its existing relative order and trails them; a name that is not a
+version is reported. The ordered names and the names not in Jira are printed
+to stdout unless ``-q``/``--quiet`` is given. An encrypted Jira token is
+unlocked by a pass phrase asked on the terminal only when it is needed.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from getpass import getpass
+from typing import Optional
+from backlogops import (
+    BacklogOpsConfig, JiraConnections, OrderedReleasesInJira,
+    format_order_result, order_jira_rel_by_date, order_releases_in_jira,
+    read_name_list)
+from backlogops_cli._command_io import (
+    add_config_arg, parsed_args, read_input, required_config)
+
+DESCRIPTION = 'Order releases in Jira by date, a name list or the input order'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the order-releases command.
+
+    The three order sources form a required, mutually exclusive group, so
+    argparse checks that exactly one of them is given. Giving the input file
+    with ``-i``/``--input`` is itself the third source; ``-I`` only names its
+    format.
+    """
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_config_arg(parser)
+    parser.add_argument('-p', '--preset', dest='preset', required=True,
+                        help='Name of the Jira preset in the configuration.')
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument('--by-date', dest='by_date', action='store_true',
+                        help='Order the versions by their release date, '
+                        'earliest first, undated versions last.')
+    source.add_argument('--name-list', dest='name_list', metavar='FILE',
+                        help='File whose lines give the wanted order, one '
+                        'release name per line (a name may contain spaces); '
+                        'a table file uses one name per row.')
+    source.add_argument('-i', '--input', dest='input', metavar='FILE',
+                        help='Backlog-and-releases input file; ordering '
+                        'follows the release order in this file.')
+    parser.add_argument('-I', '--input-config', dest='input_config',
+                        help='Format of the -i/--input file: a config file '
+                        'or a preset name.')
+    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
+                        help='Do not print the result lists to stdout.')
+    return parser
+
+
+def _passphrase() -> str:
+    """Ask for the Jira token pass phrase on the terminal."""
+    return getpass('Jira API token pass phrase: ')
+
+
+def _names(parsed: argparse.Namespace, config: BacklogOpsConfig) -> list[str]:
+    """Return the wanted order of names from the chosen name source.
+
+    Used only when ``--by-date`` is not given, so the source is either the
+    ``--name-list`` file or, otherwise, the ``-i``/``--input`` file.
+    """
+    if parsed.name_list is not None:
+        return read_name_list(parsed.name_list)
+    return [release.name for release in read_input(parsed, config).releases]
+
+
+def _order(parsed: argparse.Namespace,
+           config: BacklogOpsConfig) -> OrderedReleasesInJira:
+    """Order the releases in Jira using the chosen order source."""
+    print(f"Ordering releases in Jira using preset '{parsed.preset}'...",
+          file=sys.stderr)
+    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    if parsed.by_date:
+        result = order_jira_rel_by_date(connections, parsed.preset)
+    else:
+        result = order_releases_in_jira(connections, parsed.preset,
+                                        _names(parsed, config))
+    print(f'Ordered {len(result.ordered)} releases in Jira; '
+          f'{len(result.not_in_jira)} not in Jira.', file=sys.stderr)
+    return result
+
+
+def _run(parsed: argparse.Namespace) -> int:
+    """Resolve the order source, order the releases and print the result."""
+    try:
+        config = required_config(parsed)
+        result = _order(parsed, config)
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'Could not order releases in Jira: {error}', file=sys.stderr)
+        return 1
+    if not parsed.quiet:
+        print(format_order_result(result))
+    return 0
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Order releases in Jira and report the ordered and skipped names.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the order cannot be resolved or applied.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return _run(parsed)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())