backlogops-cli 0.4__tar.gz → 0.5__tar.gz

{backlogops_cli-0.4 → backlogops_cli-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backlogops-cli
-Version: 0.4
+Version: 0.5
 Summary: Command line interface for backlog operations.
 Author: Tom Björkholm
 Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
@@ -25,7 +25,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: argcomplete>=3.7.0
-Requires-Dist: backlogops>=0.4
+Requires-Dist: backlogops>=0.5
 Requires-Dist: versionreporter>=0.4
 Dynamic: author
 Dynamic: license-file
@@ -50,15 +50,11 @@ There are 3 related packages for backlog operations:
 
 ## Project status
 
-backlogops is in beta. The algorithms intended for its initial scope are in
-place, so the main work from here is on the user experience rather than on new
-core functionality. The three packages share a version number and are released
-together.
+The three packages share a version number and are released together.
 
 The library is not meant to ever be "finished": using it for real planning keeps
 surfacing new ideas. Some of those will be added to backlogops itself, and
-others will fit better in separate packages built on top of backlogops. Early
-adopters are very welcome, and their feedback shapes what comes next.
+others will fit better in separate packages built on top of backlogops.
 
 ## Available functionality
 
@@ -322,9 +318,10 @@ backlogops_cli serves 2 purposes:
 
 ## Test summary
 
-- Test result: 2638 passed, 7 deselected in 51s
+- Test result: 2450 passed, 9 deselected in 41s
 - No flake8 warnings.
 - No mypy errors found.
+- No pylint warnings.
 - No python layout warnings.
-- Built version(s): 0.4
+- Built version(s): 0.5
 - Build and test using Python 3.14.6

{backlogops_cli-0.4 → backlogops_cli-0.5}/README_pypi.md

@@ -16,15 +16,11 @@ There are 3 related packages for backlog operations:
 
 ## Project status
 
-backlogops is in beta. The algorithms intended for its initial scope are in
-place, so the main work from here is on the user experience rather than on new
-core functionality. The three packages share a version number and are released
-together.
+The three packages share a version number and are released together.
 
 The library is not meant to ever be "finished": using it for real planning keeps
 surfacing new ideas. Some of those will be added to backlogops itself, and
-others will fit better in separate packages built on top of backlogops. Early
-adopters are very welcome, and their feedback shapes what comes next.
+others will fit better in separate packages built on top of backlogops.
 
 ## Available functionality
 
@@ -288,9 +284,10 @@ backlogops_cli serves 2 purposes:
 
 ## Test summary
 
-- Test result: 2638 passed, 7 deselected in 51s
+- Test result: 2450 passed, 9 deselected in 41s
 - No flake8 warnings.
 - No mypy errors found.
+- No pylint warnings.
 - No python layout warnings.
-- Built version(s): 0.4
+- Built version(s): 0.5
 - Build and test using Python 3.14.6

{backlogops_cli-0.4 → backlogops_cli-0.5}/backlogops_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backlogops-cli
-Version: 0.4
+Version: 0.5
 Summary: Command line interface for backlog operations.
 Author: Tom Björkholm
 Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
@@ -25,7 +25,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: argcomplete>=3.7.0
-Requires-Dist: backlogops>=0.4
+Requires-Dist: backlogops>=0.5
 Requires-Dist: versionreporter>=0.4
 Dynamic: author
 Dynamic: license-file
@@ -50,15 +50,11 @@ There are 3 related packages for backlog operations:
 
 ## Project status
 
-backlogops is in beta. The algorithms intended for its initial scope are in
-place, so the main work from here is on the user experience rather than on new
-core functionality. The three packages share a version number and are released
-together.
+The three packages share a version number and are released together.
 
 The library is not meant to ever be "finished": using it for real planning keeps
 surfacing new ideas. Some of those will be added to backlogops itself, and
-others will fit better in separate packages built on top of backlogops. Early
-adopters are very welcome, and their feedback shapes what comes next.
+others will fit better in separate packages built on top of backlogops.
 
 ## Available functionality
 
@@ -322,9 +318,10 @@ backlogops_cli serves 2 purposes:
 
 ## Test summary
 
-- Test result: 2638 passed, 7 deselected in 51s
+- Test result: 2450 passed, 9 deselected in 41s
 - No flake8 warnings.
 - No mypy errors found.
+- No pylint warnings.
 - No python layout warnings.
-- Built version(s): 0.4
+- Built version(s): 0.5
 - Build and test using Python 3.14.6

{backlogops_cli-0.4 → backlogops_cli-0.5}/backlogops_cli.egg-info/requires.txt

@@ -1,3 +1,3 @@
 argcomplete>=3.7.0
-backlogops>=0.4
+backlogops>=0.5
 versionreporter>=0.4

{backlogops_cli-0.4 → backlogops_cli-0.5}/setup.py

@@ -5,7 +5,7 @@ from setuptools import setup
 
 setup(
   name='backlogops-cli',
-  version='0.4',
+  version='0.5',
   description='Command line interface for backlog operations.',
   author='Tom Björkholm',
   author_email='klausuler_linnet0q@icloud.com',
@@ -15,7 +15,7 @@ setup(
   package_data={'backlogops_cli': ['src/py.typed']},
   install_requires=[
     'argcomplete >= 3.7.0',
-    'backlogops >= 0.4',
+    'backlogops >= 0.5',
     'versionreporter >= 0.4'
   ]
 )

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/_command_io.py

@@ -12,9 +12,10 @@ underscore in the module name keeps it out of the command listing.
 
 import argparse
 import sys
+from getpass import getpass
 from pathlib import Path
 from collections.abc import Callable
-from typing import Optional, TextIO
+from typing import Optional, TextIO, TypeVar
 import argcomplete
 from backlogops_cli._migrate_warn import (
     CliMigrateWarnHook, CliPresetMigrateWarnHook)
@@ -27,6 +28,9 @@ from backlogops import (
     resolve_output_config, write_backlog_releases, write_content_changes,
     write_date_changes)
 
+ResultT = TypeVar('ResultT')
+"""Result type of a Jira write, carried from the operation to the report."""
+
 RANK_ANCHOR_CHOICES = {
     'backlog-top': JiraRankAnchor.BACKLOG_TOP,
     'backlog-bottom': JiraRankAnchor.BACKLOG_BOTTOM,
@@ -97,6 +101,11 @@ def parsed_args(parser: argparse.ArgumentParser,
     return parser.parse_args(args)
 
 
+def jira_passphrase() -> str:
+    """Ask for the Jira API token pass phrase on the terminal."""
+    return getpass('Jira API token pass phrase: ')
+
+
 def add_input_args(parser: argparse.ArgumentParser) -> None:
     """Add the input-file and input-config arguments."""
     parser.add_argument('-i', '--input', dest='input', required=True,
@@ -120,6 +129,18 @@ def add_config_arg(parser: argparse.ArgumentParser) -> None:
                         '$HOME/.backlogops.cfg.')
 
 
+def add_preset_arg(parser: argparse.ArgumentParser) -> None:
+    """Add the required ``-p``/``--preset`` Jira preset argument."""
+    parser.add_argument('-p', '--preset', dest='preset', required=True,
+                        help='Name of the Jira preset in the configuration.')
+
+
+def add_quiet_arg(parser: argparse.ArgumentParser) -> None:
+    """Add the ``-q``/``--quiet`` flag suppressing the result lists."""
+    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
+                        help='Do not print the result lists to stdout.')
+
+
 def _resolve_config(parsed: argparse.Namespace) -> BacklogOpsConfig:
     """Return the backlog-ops configuration from ``-c`` or by discovery.
 
@@ -265,6 +286,23 @@ def build_io_parser(description: str, *, with_input: bool = True,
     return parser
 
 
+def build_jira_parser(description: str, *,
+                      with_input: bool = True) -> argparse.ArgumentParser:
+    """Create a parser with the config, preset and optional input options.
+
+    The Jira commands all take a backlog-ops configuration and a required
+    ``-p``/``--preset``. Most also read an input file, so ``with_input``
+    adds the input-file and input-config options by default; a command
+    that does not read a backlog file passes ``with_input=False``.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    if with_input:
+        add_input_args(parser)
+    add_config_arg(parser)
+    add_preset_arg(parser)
+    return parser
+
+
 def _write_output(parsed: argparse.Namespace,
                   config: Optional[BacklogOpsConfig],
                   data: BacklogReleases) -> None:
@@ -317,6 +355,63 @@ def run_write(parsed: argparse.Namespace,
     return 0
 
 
+def run_write_command(
+        build_parser: Callable[[], argparse.ArgumentParser],
+        produce: Callable[[argparse.Namespace, Optional[BacklogOpsConfig]],
+                          BacklogReleases],
+        args: Optional[list[str]]) -> int:
+    """Parse the command line and write the produced backlog and releases.
+
+    Folds argument parsing and :func:`run_write` so an ordering command's
+    ``main`` stays a single delegating call. ``produce`` receives the
+    parsed args and the resolved config (or None) and returns the data.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_write(parsed, lambda config: produce(parsed, config))
+
+
+def write_result_file(config: BacklogOpsConfig, path: str,
+                      data: BacklogReleases, force: bool) -> None:
+    """Write one backlog-and-releases result file, honoring ``--force``."""
+    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 run_added_to_jira(
+        parsed: argparse.Namespace,
+        add: Callable[
+            [argparse.Namespace, BacklogOpsConfig, BacklogReleases], ResultT],
+        report: Callable[[ResultT], str], exists_error: type[Exception],
+        fail_note: str) -> int:
+    """Read the input, add it to Jira, and print the added lists.
+
+    ``add`` receives the parsed args, the config and the input data, adds
+    to Jira, writes any ``--added``/``--existing`` files, and returns the
+    result. ``report`` formats that result for stdout, printed unless
+    ``-q``/``--quiet`` was given. ``exists_error`` is the key-exists error
+    meaning nothing was added; other value or OS errors are reported with
+    ``fail_note``.
+    """
+    try:
+        config = required_config(parsed)
+        data = read_input(parsed, config)
+        result = add(parsed, config, data)
+    except exists_error:
+        print('Nothing added to Jira.', file=sys.stderr)
+        return 1
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'{fail_note}: {error}', file=sys.stderr)
+        return 1
+    if not parsed.quiet:
+        print(report(result))
+    return 0
+
+
 DEFAULT_BUFFER_DAYS = 5
 """Default slack in calendar days added when fitting dates."""
 

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/add_releases_to_jira.py

@@ -20,27 +20,21 @@ asked on the terminal only when it is needed.
 
 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)
+    AddedReleasesToJira, BacklogOpsConfig, BacklogReleases, JiraConnections,
+    OnExistingKey, ReleaseExistsError, add_releases_to_jira,
+    format_release_result)
 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
+    add_force_arg, add_quiet_arg, build_jira_parser, jira_passphrase,
+    parsed_args, run_added_to_jira, write_result_file)
 
 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 = build_jira_parser(DESCRIPTION)
     parser.add_argument('--skip-existing', dest='skip_existing',
                         action='store_true',
                         help='Skip releases whose name already exists in Jira '
@@ -52,26 +46,17 @@ def build_parser() -> argparse.ArgumentParser:
                         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.')
+    add_quiet_arg(parser)
+    add_force_arg(parser)
     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)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     mode = (OnExistingKey.SKIP if parsed.skip_existing
             else OnExistingKey.RAISE)
     result = add_releases_to_jira(connections, parsed.preset, data.releases,
@@ -82,18 +67,6 @@ def _add(parsed: argparse.Namespace, config: BacklogOpsConfig,
     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:
@@ -101,29 +74,26 @@ def _write_result_files(parsed: argparse.Namespace, config: BacklogOpsConfig,
     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)
+        write_result_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)
+        write_result_file(config, parsed.existing_file, present, parsed.force)
+
+
+def _add_and_write(parsed: argparse.Namespace, config: BacklogOpsConfig,
+                   data: BacklogReleases) -> AddedReleasesToJira:
+    """Add the releases to Jira and write any requested result files."""
+    result = _add(parsed, config, data)
+    _write_result_files(parsed, config, data, result)
+    return result
 
 
 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
+    return run_added_to_jira(parsed, _add_and_write, format_release_result,
+                             ReleaseExistsError,
+                             'Could not add releases to Jira')
 
 
 def main(args: Optional[list[str]] = None) -> int:
@@ -136,8 +106,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``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)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/add_to_jira.py

@@ -22,27 +22,21 @@ only when it is needed.
 
 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)
+    JiraConnections, OnExistingKey, add_backlog_to_jira, format_add_result)
 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
+    add_force_arg, add_quiet_arg, add_rank_arg, build_jira_parser,
+    jira_passphrase, parsed_args, rank_anchor, run_added_to_jira,
+    write_result_file)
 
 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 = build_jira_parser(DESCRIPTION)
     parser.add_argument('--skip-existing', dest='skip_existing',
                         action='store_true',
                         help='Skip items whose key already exists in Jira '
@@ -55,26 +49,17 @@ def build_parser() -> argparse.ArgumentParser:
                         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.')
+    add_quiet_arg(parser)
+    add_force_arg(parser)
     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)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     mode = (OnExistingKey.SKIP if parsed.skip_existing
             else OnExistingKey.RAISE)
     result = add_backlog_to_jira(connections, parsed.preset, data.backlog,
@@ -89,48 +74,31 @@ def _add(parsed: argparse.Namespace, config: BacklogOpsConfig,
     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)
+        write_result_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)
+        write_result_file(config, parsed.existing_file, present, parsed.force)
+
+
+def _add_and_write(parsed: argparse.Namespace, config: BacklogOpsConfig,
+                   data: BacklogReleases) -> AddedToJira:
+    """Add the backlog to Jira and write any requested result files."""
+    result = _add(parsed, config, data)
+    _write_result_files(parsed, config, data, result)
+    return result
 
 
 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
+    return run_added_to_jira(parsed, _add_and_write, format_add_result,
+                             ExistsInJiraError, 'Could not add to Jira')
 
 
 def main(args: Optional[list[str]] = None) -> int:
@@ -143,8 +111,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``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)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/encrypt_token_file.py

@@ -58,6 +58,7 @@ EXCEPTIONS = (FileNotFoundError, ValueError, FileExistsError,
               NotADirectoryError, OSError)
 
 
+# pylint: disable-next=too-many-return-statements
 def _run(parsed: argparse.Namespace) -> int:
     """Run the encrypt-token-file command with the given parsed arguments.
 

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/jira_fields.py

@@ -18,34 +18,25 @@ only when it is needed.
 
 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)
+    build_jira_parser, jira_passphrase, 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 = build_jira_parser(DESCRIPTION, with_input=False)
     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)
@@ -59,7 +50,8 @@ 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)
+        connections = JiraConnections(config.get_jira_config(),
+                                      jira_passphrase)
         customs = jira_custom_fields(connections, parsed.preset)
         editable = (jira_editable_fields(connections, parsed.preset,
                                          parsed.issue)

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/order_by_deps.py

@@ -19,7 +19,7 @@ import sys
 from typing import Optional
 from backlogops import BacklogOpsConfig, BacklogReleases, DependencyMode
 from backlogops_cli._command_io import (
-    build_io_parser, parsed_args, read_input, run_write)
+    build_io_parser, read_input, run_write_command)
 
 DESCRIPTION = 'Reorder a backlog so that dependencies are fulfilled'
 
@@ -61,8 +61,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``0`` on success, ``1`` when the data cannot be read, reordered
         or written.
     """
-    parsed = parsed_args(build_parser(), args)
-    return run_write(parsed, lambda config: _ordered(parsed, config))
+    return run_write_command(build_parser, _ordered, args)
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/order_by_keys.py

@@ -19,7 +19,7 @@ import sys
 from typing import Optional
 from backlogops import BacklogOpsConfig, BacklogReleases, read_key_list
 from backlogops_cli._command_io import (
-    build_io_parser, parsed_args, read_input, run_write)
+    build_io_parser, read_input, run_write_command)
 
 DESCRIPTION = 'Reorder a backlog so that key-list items come first'
 
@@ -50,8 +50,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``0`` on success, ``1`` when the data cannot be read, reordered
         or written.
     """
-    parsed = parsed_args(build_parser(), args)
-    return run_write(parsed, lambda config: _reordered(parsed, config))
+    return run_write_command(build_parser, _reordered, args)
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/order_by_release.py

@@ -24,7 +24,7 @@ import sys
 from typing import Optional
 from backlogops import BacklogOpsConfig, BacklogReleases
 from backlogops_cli._command_io import (
-    build_io_parser, parsed_args, read_input, run_write)
+    build_io_parser, read_input, run_write_command)
 
 DESCRIPTION = 'Order the backlog to follow the release order'
 
@@ -63,8 +63,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``0`` on success, ``1`` when the data cannot be read, ordered or
         written.
     """
-    parsed = parsed_args(build_parser(), args)
-    return run_write(parsed, lambda config: _ordered(parsed, config))
+    return run_write_command(build_parser, _ordered, args)
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/order_releases.py

@@ -20,7 +20,7 @@ import sys
 from typing import Optional
 from backlogops import BacklogOpsConfig, BacklogReleases
 from backlogops_cli._command_io import (
-    build_io_parser, parsed_args, read_input, run_write)
+    build_io_parser, read_input, run_write_command)
 
 DESCRIPTION = 'Order the releases by their planned or estimated date'
 
@@ -53,8 +53,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``0`` on success, ``1`` when the data cannot be read, ordered or
         written.
     """
-    parsed = parsed_args(build_parser(), args)
-    return run_write(parsed, lambda config: _ordered(parsed, config))
+    return run_write_command(build_parser, _ordered, args)
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/order_releases_in_jira.py

@@ -23,14 +23,14 @@ unlocked by a pass phrase asked on the terminal only when it is needed.
 
 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)
+    add_quiet_arg, build_jira_parser, jira_passphrase, parsed_args,
+    read_input, required_config)
 
 DESCRIPTION = 'Order releases in Jira by date, a name list or the input order'
 
@@ -43,10 +43,7 @@ def build_parser() -> argparse.ArgumentParser:
     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.')
+    parser = build_jira_parser(DESCRIPTION, with_input=False)
     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, '
@@ -61,16 +58,10 @@ def build_parser() -> argparse.ArgumentParser:
     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.')
+    add_quiet_arg(parser)
     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.
 
@@ -87,7 +78,7 @@ def _order(parsed: argparse.Namespace,
     """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)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     if parsed.by_date:
         result = order_jira_rel_by_date(connections, parsed.preset)
     else:
@@ -120,8 +111,7 @@ def main(args: Optional[list[str]] = None) -> int:
     Returns:
         ``0`` on success, ``1`` when the order cannot be resolved or applied.
     """
-    parsed = parsed_args(build_parser(), args)
-    return _run(parsed)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/rank_in_jira.py

@@ -24,24 +24,21 @@ terminal only when it is needed.
 
 import argparse
 import sys
-from getpass import getpass
 from typing import Optional
 from jira import JIRAError
 from backlogops import (
     BacklogOpsConfig, JiraConnections, RankedInJira, format_rank_result,
     jira_rank_move_keys, read_key_list)
 from backlogops_cli._command_io import (
-    RANK_ANCHOR_CHOICES, add_config_arg, parsed_args, required_config)
+    RANK_ANCHOR_CHOICES, add_quiet_arg, build_jira_parser, jira_passphrase,
+    parsed_args, required_config)
 
 DESCRIPTION = 'Move key-list items to a chosen anchor in the Jira rank order'
 
 
 def build_parser() -> argparse.ArgumentParser:
     """Build the command line parser for the rank-in-Jira 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 = build_jira_parser(DESCRIPTION, with_input=False)
     parser.add_argument('-k', '--key-list', dest='key_list', required=True,
                         help='Key list file naming the issues to move.')
     parser.add_argument('--anchor', dest='anchor',
@@ -59,22 +56,16 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument('--filter', dest='filter', metavar='JQL', default=None,
                         help='JQL filter reading the backlog; it may only '
                         'order by rank. Omit to use the preset filter.')
-    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
-                        help='Do not print the result lists to stdout.')
+    add_quiet_arg(parser)
     return parser
 
 
-def _passphrase() -> str:
-    """Ask for the Jira token pass phrase on the terminal."""
-    return getpass('Jira API token pass phrase: ')
-
-
 def _rank(parsed: argparse.Namespace,
           config: BacklogOpsConfig) -> RankedInJira:
     """Move the key-list items in the Jira rank order using the preset."""
     print(f"Ranking items in Jira using preset '{parsed.preset}'...",
           file=sys.stderr)
-    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     keys = read_key_list(parsed.key_list)
     result = jira_rank_move_keys(connections, parsed.preset, keys,
                                  filter_override=parsed.filter,
@@ -112,8 +103,7 @@ def main(args: Optional[list[str]] = None) -> int:
     Returns:
         ``0`` on success, ``1`` when the items cannot be ranked.
     """
-    parsed = parsed_args(build_parser(), args)
-    return _run(parsed)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/read_jira.py

@@ -18,12 +18,11 @@ phrase asked on the terminal only when it is needed.
 
 import argparse
 import sys
-from getpass import getpass
 from typing import Optional
 from backlogops import (
     BacklogOpsConfig, BacklogReleases, read_jira_from_config)
 from backlogops_cli._command_io import (
-    build_io_parser, parsed_args, run_write)
+    build_io_parser, jira_passphrase, parsed_args, run_write)
 
 DESCRIPTION = 'Read a backlog and releases from Jira and store to a file'
 
@@ -40,11 +39,6 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _passphrase() -> str:
-    """Ask for the Jira token pass phrase on the terminal."""
-    return getpass('Jira API token pass phrase: ')
-
-
 def _warn_if_inconsistent(data: BacklogReleases) -> None:
     """Warn when the data read from Jira is not fully consistent.
 
@@ -67,7 +61,7 @@ def _read_jira(parsed: argparse.Namespace,
           file=sys.stderr)
     data = read_jira_from_config(config, parsed.preset,
                                  filter_override=parsed.filter,
-                                 passphrase=_passphrase)
+                                 passphrase=jira_passphrase)
     print(f'Read {len(data.backlog)} backlog items and '
           f'{len(data.releases)} releases from Jira.', file=sys.stderr)
     _warn_if_inconsistent(data)

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/rename_releases_in_jira.py

@@ -22,13 +22,13 @@ phrase asked on the terminal only when it is needed.
 
 import argparse
 import sys
-from getpass import getpass
 from typing import Optional, Sequence
 from backlogops import (
     BacklogOpsConfig, JiraConnections, ReleaseRename, RenamedReleasesInJira,
     format_rename_result, read_renames, rename_releases_in_jira)
 from backlogops_cli._command_io import (
-    add_config_arg, parsed_args, required_config)
+    add_quiet_arg, build_jira_parser, jira_passphrase, parsed_args,
+    required_config)
 
 DESCRIPTION = 'Rename releases in Jira, changing Jira version names'
 
@@ -40,10 +40,7 @@ def build_parser() -> argparse.ArgumentParser:
     group, so argparse checks that exactly one way is given. ``--rename``
     takes both names at once, so its old and new name always travel together.
     """
-    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 = build_jira_parser(DESCRIPTION, with_input=False)
     source = parser.add_mutually_exclusive_group(required=True)
     source.add_argument('--rename', dest='rename', nargs=2,
                         metavar=('OLD', 'NEW'),
@@ -53,16 +50,10 @@ def build_parser() -> argparse.ArgumentParser:
                         help='Two column file of old and new names for a '
                         'batch of renames, with columns separated by tab. '
                         '(Spaces are allowed in a release name.)')
-    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
-                        help='Do not print the result lists to stdout.')
+    add_quiet_arg(parser)
     return parser
 
 
-def _passphrase() -> str:
-    """Ask for the Jira token pass phrase on the terminal."""
-    return getpass('Jira API token pass phrase: ')
-
-
 def _renames(parsed: argparse.Namespace) -> Sequence[ReleaseRename]:
     """Return the renames from ``--rename`` or the ``--rename-file``.
 
@@ -81,7 +72,7 @@ def _rename(parsed: argparse.Namespace, config: BacklogOpsConfig,
     """Rename the releases in Jira using the named preset."""
     print(f"Renaming releases in Jira using preset '{parsed.preset}'...",
           file=sys.stderr)
-    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     result = rename_releases_in_jira(connections, parsed.preset, renames)
     print(f'Renamed {len(result.renamed)} releases in Jira; '
           f'{len(result.unchanged)} unchanged; {len(result.missing)} not in '
@@ -112,8 +103,7 @@ def main(args: Optional[list[str]] = None) -> int:
     Returns:
         ``0`` on success, ``1`` when the renames cannot be read or applied.
     """
-    parsed = parsed_args(build_parser(), args)
-    return _run(parsed)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/update_backlog_in_jira.py

@@ -32,15 +32,14 @@ only when it is needed.
 
 import argparse
 import sys
-from getpass import getpass
 from typing import Optional
 from backlogops import (
     BacklogOpsConfig, ItemNotInJiraError, JiraConnections, LinkUpdate,
     OnMissingKey, UpdatedBacklogInJira, format_backlog_updates,
     update_backlog_in_jira, updatable_backlog_fields)
 from backlogops_cli._command_io import (
-    add_config_arg, add_input_args, add_rank_arg, parsed_args, rank_anchor,
-    read_input, required_config)
+    add_quiet_arg, add_rank_arg, build_jira_parser, jira_passphrase,
+    parsed_args, rank_anchor, read_input, required_config)
 
 DESCRIPTION = 'Update a backlog in Jira, changing only the chosen columns'
 
@@ -53,11 +52,7 @@ _STORE_ALL = 'all'
 
 def build_parser() -> argparse.ArgumentParser:
     """Build the command line parser for the update-backlog 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 = build_jira_parser(DESCRIPTION)
     _add_column_flags(parser)
     parser.add_argument('--on-missing', dest='on_missing',
                         choices=sorted(_MISSING_MODES), default='raise',
@@ -70,8 +65,7 @@ def build_parser() -> argparse.ArgumentParser:
                         'removing links it no longer has; add only adds '
                         'missing links.')
     add_rank_arg(parser)
-    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
-                        help='Do not print the result lists to stdout.')
+    add_quiet_arg(parser)
     return parser
 
 
@@ -87,11 +81,6 @@ def _add_column_flags(parser: argparse.ArgumentParser) -> None:
                        help='Update every mapped writable column but these.')
 
 
-def _passphrase() -> str:
-    """Ask for the Jira token pass phrase on the terminal."""
-    return getpass('Jira API token pass phrase: ')
-
-
 def _resolve_fields(parsed: argparse.Namespace,
                     connections: JiraConnections) -> list[str]:
     """Return the internal field names to update from the -s/-e flags.
@@ -118,7 +107,7 @@ def _update(parsed: argparse.Namespace, config: BacklogOpsConfig,
     """Update the input backlog in Jira using the named preset."""
     print(f"Updating backlog in Jira using preset '{parsed.preset}'...",
           file=sys.stderr)
-    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     fields = _resolve_fields(parsed, connections)
     mode = _MISSING_MODES[parsed.on_missing]
     link_update = _LINK_MODES[parsed.links]
@@ -169,8 +158,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``0`` on success, ``1`` when the backlog cannot be updated or a key
         is not present in Jira with the raise policy.
     """
-    parsed = parsed_args(build_parser(), args)
-    return _run(parsed)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover

{backlogops_cli-0.4 → backlogops_cli-0.5}/src/backlogops_cli/update_releases_in_jira.py

@@ -23,14 +23,14 @@ only when it is needed.
 
 import argparse
 import sys
-from getpass import getpass
 from typing import Optional
 from backlogops import (
     BacklogOpsConfig, ItemNotInJiraError, JiraConnections, OnMissingKey,
     Releases, UpdatedReleasesInJira, format_release_updates,
     update_releases_in_jira)
 from backlogops_cli._command_io import (
-    add_config_arg, add_input_args, parsed_args, read_input, required_config)
+    add_quiet_arg, build_jira_parser, jira_passphrase, parsed_args,
+    read_input, required_config)
 
 DESCRIPTION = 'Update releases in Jira, setting dates to the planned dates'
 
@@ -40,11 +40,7 @@ _MISSING_MODES = {'raise': OnMissingKey.RAISE, 'ignore': OnMissingKey.IGNORE,
 
 def build_parser() -> argparse.ArgumentParser:
     """Build the command line parser for the update-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 = build_jira_parser(DESCRIPTION)
     parser.add_argument('--on-missing', dest='on_missing',
                         choices=sorted(_MISSING_MODES), default='raise',
                         help='What to do with a release whose name is not in '
@@ -57,16 +53,10 @@ def build_parser() -> argparse.ArgumentParser:
                         action='store_true',
                         help='Update only the releases named with --release; '
                         'without it every input release is updated.')
-    parser.add_argument('-q', '--quiet', dest='quiet', action='store_true',
-                        help='Do not print the result lists to stdout.')
+    add_quiet_arg(parser)
     return parser
 
 
-def _passphrase() -> str:
-    """Ask for the Jira token pass phrase on the terminal."""
-    return getpass('Jira API token pass phrase: ')
-
-
 def _select(parsed: argparse.Namespace, releases: Releases) -> Releases:
     """Return the releases to update, limited to --release when asked.
 
@@ -89,7 +79,7 @@ def _update(parsed: argparse.Namespace, config: BacklogOpsConfig,
     """Update the selected releases in Jira using the named preset."""
     print(f"Updating releases in Jira using preset '{parsed.preset}'...",
           file=sys.stderr)
-    connections = JiraConnections(config.get_jira_config(), _passphrase)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
     mode = _MISSING_MODES[parsed.on_missing]
     result = update_releases_in_jira(connections, parsed.preset, releases,
                                      on_missing_key=mode)
@@ -127,8 +117,7 @@ def main(args: Optional[list[str]] = None) -> int:
         ``0`` on success, ``1`` when the releases cannot be updated or a
         name is not present in Jira with the raise policy.
     """
-    parsed = parsed_args(build_parser(), args)
-    return _run(parsed)
+    return _run(parsed_args(build_parser(), args))
 
 
 if __name__ == '__main__':  # pragma: no cover