backlogops-cli 1.2__py3-none-any.whl → 1.4__py3-none-any.whl

backlogops_cli/_command_io.py

@@ -145,12 +145,16 @@ def add_config_arg(parser: argparse.ArgumentParser) -> None:
     """Add the ``-c``/``--config`` backlog-ops configuration argument.
 
     The configuration file holds the workforce, the named input and output
-    presets, the levels and the global status map. Without ``-c`` the file
-    is discovered the same way as the GUI.
+    presets, the levels, the global status map, the guess for unestimated
+    items, the remaining time settings, the GUI display settings and the
+    Jira configuration. Without
+    ``-c`` the file is discovered the same way as the GUI.
     """
     parser.add_argument('-c', '--config', dest='config',
                         help='Backlog-ops configuration file (workforce, '
-                        'named presets, levels, status map). Without -c the '
+                        'named presets, levels, status map, default story '
+                        'points, remaining time settings, Jira '
+                        'configuration). Without -c the '
                         'file is found from $BACKLOGOPS_CFG, else '
                         'backlogops.cfg in $BACKLOGOPS_DIR, else '
                         '$HOME/.backlogops.cfg.')
@@ -231,6 +235,20 @@ def io_levels(config: Optional[BacklogOpsConfig]) -> Optional[Levels]:
     return config.get_levels() if config is not None else None
 
 
+def io_remaining_time(config: Optional[BacklogOpsConfig]) -> bool:
+    """Return whether ``config`` enables remaining time estimates.
+
+    Args:
+        config: The resolved backlog-ops configuration, or None for the
+            defaults, which do not use remaining time estimates.
+
+    Returns:
+        True when remaining time estimates are enabled in ``config``.
+    """
+    return config is not None and \
+        config.remaining_time.enable_remaining_time
+
+
 def read_input(parsed: argparse.Namespace,
                config: Optional[BacklogOpsConfig]) -> BacklogReleases:
     """Read and validate the backlog and releases from the input file.
@@ -343,7 +361,8 @@ def _write_output(parsed: argparse.Namespace,
     write_backlog_releases(data, parsed.output, out_config, rules,
                            levels=io_levels(config),
                            file_exists_callback=overwrite_callback(
-                               parsed.force))
+                               parsed.force),
+                           use_remaining_time=io_remaining_time(config))
 
 
 def run_write(parsed: argparse.Namespace,
@@ -405,7 +424,8 @@ def write_result_file(config: BacklogOpsConfig, path: str,
                                        auto_ch_hook=CliPresetMigrateWarnHook())
     write_backlog_releases(data, path, out_config, FormatRules(),
                            levels=config.get_levels(),
-                           file_exists_callback=overwrite_callback(force))
+                           file_exists_callback=overwrite_callback(force),
+                           use_remaining_time=io_remaining_time(config))
     print(f'Wrote {path}')
 
 
@@ -418,7 +438,8 @@ def run_added_to_jira(
     """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
+    to Jira, writes any ``--added-file``/``--existing-file`` 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

backlogops_cli/add_to_jira.py

@@ -66,10 +66,13 @@ def _add(parsed: argparse.Namespace, config: BacklogOpsConfig,
                                  on_existing_key=mode,
                                  rank_anchor=rank_anchor(parsed.rank),
                                  levels=config.get_levels(),
-                                 status_map=config.get_status_input_map())
+                                 status_map=config.get_status_input_map(),
+                                 use_remaining_time=config.remaining_time
+                                 .enable_remaining_time)
     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_fields)} fields not set; '
           f'{len(result.failed_links)} links not written.', file=sys.stderr)
     return result
 

backlogops_cli/encrypt_token_file.py

@@ -4,7 +4,7 @@
 Read a clear text API token from a file or from standard input, encrypt it
 with a pass phrase and write the encrypted token to a file. The pass phrase
 is requested on the terminal and is not echoed. The clear text token file
-is not modified, unless the the encrypted token file is the same as the
+is not modified, unless the encrypted token file is the same as the
 clear text token file, in which case the clear text token file is overwritten
 with the encrypted token. The encrypted token file is written atomically,
 so that it is either the old version or the new version, and never a

backlogops_cli/estimate_ready_date.py

@@ -6,10 +6,17 @@ estimates the ready date of each backlog item from the available teams,
 as documented for :func:`backlogops.estimate_ready_date`. The teams
 configuration (velocity, work hours, vacations and so on) is taken from
 the file given by ``--config`` or, when that is absent, from the
-configured backlog-ops file. The backlog with the estimated dates and the
-releases are written to the output file. The input and output formats are
-inferred from the file name extensions, but can be overridden by a
-configuration file or by a named preset.
+configured backlog-ops file, and so is what a backlog item that nobody
+has estimated is worked with. With ``--remaining-time`` the ready dates
+are instead estimated from the remaining time of the items and the focus
+factor of the teams (or the configured default focus factor), as
+documented for
+:func:`backlogops.estimate_rt_ready_date`; that needs remaining time
+estimates to be enabled in the configuration, and the command fails
+without writing anything when they are not. The backlog with the
+estimated dates and the releases are written to the output file. The
+input and output formats are inferred from the file name extensions, but
+can be overridden by a configuration file or by a named preset.
 """
 
 # PYTHON_ARGCOMPLETE_OK
@@ -35,6 +42,16 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument('-d', '--start-date', dest='start_date',
                         metavar='ISO_DATE',
                         help='Day the teams start working (default today).')
+    parser.add_argument('--remaining-time', dest='remaining_time',
+                        action='store_true',
+                        help='Estimate from the remaining time of the items '
+                        'and the focus factor of the teams (or the default '
+                        'focus factor) instead of from '
+                        'story points and velocity. Requires remaining time '
+                        'estimates to be enabled in the configuration '
+                        '("enable_remaining_time": true in its '
+                        '"remaining_time" section); otherwise the command '
+                        'fails and writes nothing.')
     parser.add_argument('--set-plan', dest='set_plan', action='store_true',
                         help='Also copy each estimated date to the planned '
                         'date.')
@@ -54,12 +71,20 @@ def _estimate(parsed: argparse.Namespace, config: Optional[BacklogOpsConfig],
               ) -> tuple[str, Optional[Callable[[str], None]]]:
     """Estimate the dates and return the release date change report.
 
-    The configuration is required for this command, so ``config`` is never
-    None here; the assertion makes that explicit for the type checker.
+    The dates are estimated from remaining time when ``--remaining-time``
+    is given, and from story points otherwise. The configuration is
+    required for this command, so ``config`` is never None here; the
+    assertion makes that explicit for the type checker.
     """
     assert isinstance(config, BacklogOpsConfig)
-    changes = data.estimate_ready_date(config.available_teams,
-                                       _start_date(parsed))
+    start = _start_date(parsed)
+    if parsed.remaining_time:
+        changes = data.estimate_rt_ready_date(config.available_teams,
+                                              config.remaining_time, start)
+    else:
+        changes = data.estimate_ready_date(
+            config.available_teams, start,
+            default_story_points=config.default_story_points)
     if parsed.set_plan:
         data.set_plan_from_estimate()
     return date_report(changes, overwrite_callback(parsed.force))
@@ -69,9 +94,12 @@ def main(args: Optional[list[str]] = None) -> int:
     """Estimate the ready dates and write the output file.
 
     The backlog with the estimated dates and the releases are written to
-    the output file. The estimated release dates are updated as well, and
-    the list of release date changes is printed to stdout, or also saved
-    to a file when ``--changes-file`` is given.
+    the output file. The ready dates are estimated from story points, or
+    from remaining time with ``--remaining-time``, which fails when the
+    configuration does not enable remaining time estimates. The estimated
+    release dates are updated as well, and the list of release date
+    changes is printed to stdout, or also saved to a file when
+    ``--changes-file`` is given.
 
     Args:
         args: Optional replacement for ``sys.argv[1:]``, mainly for tests.

backlogops_cli/jira_fields.py

@@ -6,7 +6,11 @@ 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.
+set through the issue edit REST endpoint. Each ``--field`` (which needs
+``--issue``) prints the raw Jira JSON at a field id or dotted path of that
+issue, such as ``timetracking.remainingEstimateSeconds``, and the field's
+edit screen entry, so a column map path can be checked against what Jira
+really holds and how it may be written.
 
 An encrypted Jira token is unlocked by a pass phrase asked on the terminal
 only when it is needed.
@@ -17,15 +21,17 @@ only when it is needed.
 # MIT License
 
 import argparse
+import json
 import sys
 from typing import Optional
 from jira import JIRAError
 from backlogops import (
-    JiraConnections, jira_custom_fields, jira_editable_fields)
+    JiraConnections, JiraFieldJson, jira_custom_fields, jira_editable_fields,
+    jira_field_json)
 from backlogops_cli._command_io import (
     build_jira_parser, jira_passphrase, parsed_args, required_config)
 
-DESCRIPTION = "Print Jira custom fields and an issue's editable fields"
+DESCRIPTION = "Print Jira custom fields, an issue's editable fields and JSON"
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -34,6 +40,12 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument('--issue', dest='issue', metavar='KEY',
                         help="Also print the fields this issue's edit "
                         'screen offers (for example SCRUM-15).')
+    parser.add_argument('--field', dest='fields', action='append',
+                        metavar='NAME', default=[],
+                        help='Also print the raw Jira JSON of this field of '
+                        'the --issue: a field id, a custom field name, or a '
+                        'dotted path such as '
+                        'timetracking.remainingEstimateSeconds. Repeatable.')
     return parser
 
 
@@ -46,16 +58,46 @@ def _print_pairs(heading: str, pairs: list[tuple[str, str]]) -> None:
         print(f'  {field_id}  {name}')
 
 
+def _print_json(heading: str, value: object) -> None:
+    """Print a heading and the value as indented JSON below it."""
+    print(f'  {heading}:')
+    text = json.dumps(value, indent=2, ensure_ascii=False, default=str)
+    for line in text.splitlines():
+        print(f'    {line}')
+
+
+def _print_field(issue: str, found: JiraFieldJson) -> None:
+    """Print one field path's JSON value and its edit screen entry."""
+    print(f"\nField '{found.name}' of {issue} (Jira field {found.field_id}):")
+    if found.present:
+        _print_json('value', found.value)
+    else:
+        print('  value: (no such path in the issue)')
+    if found.edit_entry is None:
+        print('  edit screen: (not offered, so not writable by an edit)')
+    else:
+        _print_json('edit screen', found.edit_entry)
+
+
+def _read_all(parsed: argparse.Namespace) -> tuple[
+        list[tuple[str, str]], Optional[list[tuple[str, str]]],
+        list[JiraFieldJson]]:
+    """Read the custom fields, edit screen fields and field JSON asked for."""
+    config = required_config(parsed)
+    connections = JiraConnections(config.get_jira_config(), jira_passphrase)
+    customs = jira_custom_fields(connections, parsed.preset)
+    if parsed.issue is None:
+        return customs, None, []
+    editable = jira_editable_fields(connections, parsed.preset, parsed.issue)
+    found = jira_field_json(connections, parsed.preset, parsed.issue,
+                            parsed.fields)
+    return customs, editable, found
+
+
 def _run(parsed: argparse.Namespace) -> int:
-    """Print the custom field map and, optionally, editable fields."""
+    """Print the custom field map and, optionally, the issue's fields."""
     try:
-        config = required_config(parsed)
-        connections = JiraConnections(config.get_jira_config(),
-                                      jira_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)
+        customs, editable, found = _read_all(parsed)
     except (ValueError, TypeError, KeyError, OSError, JIRAError) as error:
         print(f'Could not read Jira fields: {error}', file=sys.stderr)
         return 1
@@ -64,6 +106,8 @@ def _run(parsed: argparse.Namespace) -> int:
         print()
         _print_pairs(f'Fields settable on the edit screen of '
                      f'{parsed.issue}:', editable)
+    for field in found:
+        _print_field(parsed.issue, field)
     return 0
 
 
@@ -75,8 +119,16 @@ def main(args: Optional[list[str]] = None) -> int:
 
     Returns:
         ``0`` on success, ``1`` when the fields cannot be read.
+
+    Raises:
+        SystemExit: With status ``2`` when ``--field`` is given without
+            ``--issue``, as for any other command line usage error.
     """
-    return _run(parsed_args(build_parser(), args))
+    parser = build_parser()
+    parsed = parsed_args(parser, args)
+    if parsed.fields and parsed.issue is None:
+        parser.error('--field needs --issue')
+    return _run(parsed)
 
 
 if __name__ == '__main__':  # pragma: no cover

backlogops_cli/preset_wizard.py

@@ -2,8 +2,9 @@
 """Run the IO preset wizard and store the created preset file.
 
 The created file holds a single input or output TableIO preset (a format
-configuration with its column-name maps, and a level display for an output
-preset). Such a stand-alone file is used wherever an input or output
+configuration with its column-name maps, and a level display and whether
+to leave out empty columns for an output preset). Such a stand-alone file
+is used wherever an input or output
 configuration is taken, by giving its file name.
 """
 

backlogops_cli/update_backlog_in_jira.py

@@ -7,11 +7,13 @@ backlog-ops configuration, changing only a chosen subset of the mapped
 fields. The subset is chosen with exactly one of two flags: ``-s``/``--store``
 lists the columns to update (or the single word ``all`` for every mapped
 writable column), while ``-e``/``--exclude`` updates every mapped writable
-column except the listed ones.
+column except the listed ones. The remaining time is a writable column only
+while remaining time estimates are enabled.
 
 ``--on-missing`` chooses what to do with an item whose key is not present in
 Jira: ``raise`` (the default) stops with an error, ``ignore`` leaves it
-alone, and ``add`` creates it with all of its fields. ``--links`` chooses how
+alone, and ``add`` creates it with all of its mapped fields (the remaining
+time only while remaining time estimates are enabled). ``--links`` chooses how
 the parent and dependency links are updated: ``reconcile`` (the default) makes
 the Jira links match the backlog exactly, removing a Jira link the backlog no
 longer has and clearing a dropped parent, while ``add`` only adds the missing
@@ -20,8 +22,9 @@ selected fields are updated the same way under either value. With ``--rank``
 the items are also ranked in Jira to match the backlog order, at the chosen
 anchor.
 
-The updated, already-correct, ignored, added and failed items are printed
-to stdout as labelled lists, unless ``-q``/``--quiet`` is given. An
+The updated, already-correct, ignored and added items, and what Jira
+refused to add, to set or to link, are printed to stdout as labelled
+lists, unless ``-q``/``--quiet`` is given. An
 encrypted Jira token is unlocked by a pass phrase asked on the terminal
 only when it is needed.
 """
@@ -48,6 +51,9 @@ _MISSING_MODES = {'raise': OnMissingKey.RAISE, 'ignore': OnMissingKey.IGNORE,
 _LINK_MODES = {'reconcile': LinkUpdate.RECONCILE,
                'add': LinkUpdate.ADD_MISSING}
 _STORE_ALL = 'all'
+_RT_WRITABLE = ('remaining_time is writable only while '
+                '"enable_remaining_time" is true in the configuration.')
+"""Help and message note on when the remaining time can be updated."""
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -75,40 +81,57 @@ def _add_column_flags(parser: argparse.ArgumentParser) -> None:
     group.add_argument('-s', '--store', dest='store', nargs='+',
                        metavar='COLUMN',
                        help='Columns to update, or the single word "all" for '
-                       'every mapped writable column.')
+                       'every mapped writable column. ' + _RT_WRITABLE)
     group.add_argument('-e', '--exclude', dest='exclude', nargs='+',
                        metavar='COLUMN',
-                       help='Update every mapped writable column but these.')
+                       help='Update every mapped writable column but these. '
+                       + _RT_WRITABLE)
 
 
-def _resolve_fields(parsed: argparse.Namespace,
-                    connections: JiraConnections) -> list[str]:
+def _resolve_fields(parsed: argparse.Namespace, connections: JiraConnections,
+                    use_remaining_time: bool) -> list[str]:
     """Return the internal field names to update from the -s/-e flags.
 
     ``-s all`` and ``-e`` are resolved against the preset's updatable
     columns. A ``-s`` name that is not an updatable column is reported and
-    dropped, so a typo does not silently update nothing.
+    dropped, so a typo does not silently update nothing. The remaining
+    time is an updatable column only while remaining time estimates are
+    used.
     """
-    updatable = updatable_backlog_fields(connections, parsed.preset)
+    updatable = updatable_backlog_fields(connections, parsed.preset,
+                                         use_remaining_time=use_remaining_time)
     if parsed.store is not None:
         if parsed.store == [_STORE_ALL]:
             return updatable
         unknown = [name for name in parsed.store if name not in updatable]
         if unknown:
-            print('Ignoring columns not updatable in this preset: '
-                  + ', '.join(unknown), file=sys.stderr)
+            _report_ignored(unknown, use_remaining_time)
         return [name for name in parsed.store if name in updatable]
     excluded = set(parsed.exclude)
     return [name for name in updatable if name not in excluded]
 
 
+def _report_ignored(unknown: list[str], use_remaining_time: bool) -> None:
+    """Report the ``-s`` columns dropped as not updatable to stderr.
+
+    A dropped ``remaining_time`` while remaining time estimates are not
+    used gets a note saying why, because the preset may well map it.
+    """
+    note = ''
+    if 'remaining_time' in unknown and not use_remaining_time:
+        note = ' (' + _RT_WRITABLE + ')'
+    print('Ignoring columns not updatable in this preset: '
+          + ', '.join(unknown) + note, file=sys.stderr)
+
+
 def _update(parsed: argparse.Namespace, config: BacklogOpsConfig,
             data_backlog: object) -> UpdatedBacklogInJira:
     """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(), jira_passphrase)
-    fields = _resolve_fields(parsed, connections)
+    use_rt = config.remaining_time.enable_remaining_time
+    fields = _resolve_fields(parsed, connections, use_rt)
     mode = _MISSING_MODES[parsed.on_missing]
     link_update = _LINK_MODES[parsed.links]
     assert isinstance(data_backlog, list)
@@ -118,7 +141,8 @@ def _update(parsed: argparse.Namespace, config: BacklogOpsConfig,
                                     link_update=link_update,
                                     rank_anchor=rank_anchor(parsed.rank),
                                     levels=config.get_levels(),
-                                    status_map=config.get_status_input_map())
+                                    status_map=config.get_status_input_map(),
+                                    use_remaining_time=use_rt)
     _report_summary(result)
     return result
 
@@ -128,7 +152,11 @@ def _report_summary(result: UpdatedBacklogInJira) -> None:
     print(f'Updated {len(result.updated)} items in Jira; '
           f'{len(result.already_correct)} already correct; '
           f'{len(result.ignored)} ignored; {len(result.added.stored)} added; '
-          f'{len(result.failed)} failed.', file=sys.stderr)
+          f'{len(result.added.failed)} not added; '
+          f'{len(result.failed_fields) + len(result.added.failed_fields)} '
+          'fields not set; '
+          f'{len(result.failed_links) + len(result.added.failed_links)} '
+          'links not written.', file=sys.stderr)
 
 
 def _run(parsed: argparse.Namespace) -> int:

{backlogops_cli-1.2.dist-info → backlogops_cli-1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backlogops-cli
-Version: 1.2
+Version: 1.4
 Summary: Command line interface for backlog operations.
 Author: Tom Björkholm
 Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
@@ -24,9 +24,9 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: argcomplete>=3.7.2
-Requires-Dist: backlogops>=1.2
-Requires-Dist: wizard-ui-bridge[textual]>=1.3
-Requires-Dist: edit-cfg-json-textual>=0.2.0
+Requires-Dist: backlogops>=1.4
+Requires-Dist: wizard-ui-bridge[textual]>=1.4
+Requires-Dist: edit-cfg-json-textual>=0.4.0
 Requires-Dist: versionreporter>=0.4
 Dynamic: author
 Dynamic: license-file
@@ -76,6 +76,14 @@ The following functionality is available in all 3 packages:
 - Estimate ready date for the backlog items based on available teams, team
   velocity, vacation dates, periods with half time work, etc.
 
+- Alternatively, where remaining time estimates are required, estimate ready
+  dates from the remaining time of the backlog items and the focus factor of the
+  teams (story points are recommended).
+
+- Configure what a backlog item that nobody has estimated counts as, per backlog
+  item level, so that an unestimated item does not make the estimated dates too
+  optimistic.
+
 - Extract backlog keys at given backlog item levels.
 
 - Reorder the backlog so that the dependencies are satisfied.
@@ -100,6 +108,9 @@ The following functionality is available in all 3 packages:
 
 - Rename columns when reading a file and when writing a file.
 
+- Leave out columns that are empty on every row, when writing a file and when
+  showing the backlog in the GUI.
+
 - Map custom status names in input files to backlog item statuses.
 
 - Choose how backlog item levels are written: by number, by name, or both, and
@@ -110,7 +121,16 @@ The following functionality is available in all 3 packages:
 - Migrate an older configuration or preset file to the current file format.
 
 - A wizard to create a backlog-ops configuration file with the workforce, named
-  input and output presets, level names, and status name mapping.
+  input and output presets, level names, status name mapping, the guess for
+  unestimated items, whether remaining time estimates are also used, how the
+  graphical user interface shows the data, and the Jira integration.
+
+- An editor showing a whole configuration file or a stand-alone preset file at
+  once, folded where it is deep, to change a single value without stepping
+  through the wizard.
+
+- Encrypt the Jira API token to a pass-phrase-protected file, so that no
+  configuration file holds the token in clear text.
 
 - Read a backlog and releases from Jira into a backlog and release table.
 
@@ -129,6 +149,14 @@ The following functionality is available in all 3 packages:
 - Move backlog items to a chosen anchor in the Jira rank order, following a key
   list.
 
+- Report what a Jira operation did not do. Every Jira result opens with what
+  Jira refused or what was skipped, so a value that was not written is visible
+  without reading the whole listing.
+
+- Show the custom fields of Jira, the fields an issue's edit screen accepts, and
+  the raw JSON Jira holds for a field of an issue, to find the correct Jira
+  field mapping.
+
 ## The operating model
 
 The operating model that most of the functionality is designed for is that the
@@ -137,8 +165,8 @@ are ordered by priority and dependencies to allow the teams to work in the
 backlog order. Each backlog item and each release may have a planned ready date,
 that records what has been communicated to the customer. Each backlog item and
 each release may have an estimated ready date, that is calculated from the
-current backlog state, the team velocity, and what we know about the
-availability of the team members.
+current backlog state, the team velocity (or, for remaining time estimates, the
+focus factor), and what we know about the availability of the team members.
 
 ## The backlog item fields
 
@@ -153,7 +181,10 @@ the library:
 
 - `title` The title of the backlog item. Required.
 
-- `story_points` The story points of the backlog item. Required.
+- `story_points` The story points of the backlog item. Optional. An item with no
+  story points is one that nobody has estimated yet, and what such an item is
+  worked with when a completion date is estimated is configured. May be a
+  fraction, such as 0.5.
 
 - `status` The status of the backlog item. Required.
 
@@ -170,7 +201,11 @@ the library:
 
 - `team` The team responsible for the backlog item. Optional. Must not be empty
   string. Must be a valid team name. If None the item can be done by any team.
-  If not None. the item can only be done by the specified team.
+  If not None, the item can only be done by the specified team.
+
+- `remaining_time` The remaining time of the backlog item, as ideal focused work
+  time of one person. Optional. Only used by the alternative remaining time
+  estimates; story points are recommended. Must not be negative.
 
 - `depends_on_f2s` The list of keys of the backlog items that must have been
   finished before the current item can start. May be empty.
@@ -210,7 +245,7 @@ pip install --upgrade backlogops-cli
 
 For a better understanding of how to use the library, CLI or GUI, see the user
 documentation:
-[Using backlogops](https://github.com/tom-bjorkholm/backlog-ops/blob/master/doc//using_backlogops/README.md)
+[Using backlogops](https://github.com/tom-bjorkholm/backlog-ops/blob/master/doc/using_backlogops/README.md)
 
 ## API documentation
 
@@ -271,7 +306,7 @@ backlogops_cli serves 2 purposes:
      Extract backlog keys at the given levels to a key list
 
   python3 -m backlogops_cli.jira_fields
-     Print Jira custom fields and an issue's editable fields
+     Print Jira custom fields, an issue's editable fields and JSON
 
   python3 -m backlogops_cli.list
      List all commands available in backlogops_cli
@@ -322,10 +357,10 @@ backlogops_cli serves 2 purposes:
 
 ## Test summary
 
-- Test result: 2309 passed, 1 deselected in 58s
+- Test result: 2902 passed, 1 deselected in 68s (0:01:08)
 - No flake8 warnings.
 - No mypy errors found.
 - No pylint warnings.
 - No python layout warnings.
-- Built version(s): 1.2
+- Built version(s): 1.4
 - Build and test using Python 3.14.7

{backlogops_cli-1.2.dist-info → backlogops_cli-1.4.dist-info}/RECORD

@@ -1,20 +1,20 @@
 backlogops_cli/__init__.py,sha256=_fQCpIvVjUpxy90m9QHLW13b0KTJXttFRH_P6UrfVD8,168
 backlogops_cli/__main__.py,sha256=3VGp1eTHo0ihcDtJe_702Aub_NeoIEUpUDkMUsAXCJs,268
-backlogops_cli/_command_io.py,sha256=UaqHRy8bLW4xWyJVDE1wcFRyQF2CDJwRDH1ZlKtuos4,23656
+backlogops_cli/_command_io.py,sha256=Du39zElm50Cch5y0xc-6nd1ftBI7DfAsDmWwFuWPmr8,24521
 backlogops_cli/_migrate_warn.py,sha256=XhUATa5qG7ZT4YTIEHZaJTjEhi5H_K7mEgCcNTW3HBM,2269
 backlogops_cli/_wizard_io.py,sha256=IrVHsMqyKHi6pTgTgfashqLd0VzSUc18XucNGVLXuaE,5628
 backlogops_cli/add_releases_to_jira.py,sha256=_X--t5UsNf9pomdmFjdTEAHAOWzfvZxVh-1Mh0reYcI,4968
-backlogops_cli/add_to_jira.py,sha256=Ia5CDDpPgGESLEHDTMz7GGl2Iyy8L50xx9HrLdT5cZ0,5244
+backlogops_cli/add_to_jira.py,sha256=dqqsG7hOhz2W6MOJH0PDbMgj-MtR1CousGsAp7dQoRc,5433
 backlogops_cli/adjust_release_content.py,sha256=bowohyiURAqroZBsL7uOh2qE3aQZbZPh_JkxykSbQaA,1975
 backlogops_cli/bloc_version_reporter.py,sha256=HBzCBQBKXjxVjaPKIrpliaXbKIPK3KBo_gehb6SHbpg,706
 backlogops_cli/config_edit.py,sha256=rj6kwR9qGnCPdgtIICMbV7hFQ3gbiurenKfxHqWgEEo,5729
 backlogops_cli/config_wizard.py,sha256=QAqdIjS13FjLAODs9o2OAEa_fJUFxgJFXru09XP6FZQ,1917
 backlogops_cli/convert.py,sha256=I66pUgtSwKrIkS_08skRyJusYFHYdeGz2GzVcxgXD2s,1420
 backlogops_cli/demo_backlog.py,sha256=jR8G8P4MDe0OqHUsuUUdOOW3XlptaeIgz73BrcWCQDg,1309
-backlogops_cli/encrypt_token_file.py,sha256=F27c0fJZFAiHjUp12r6InkjF3Z4Qi85Ftbh-fgImnLQ,4557
-backlogops_cli/estimate_ready_date.py,sha256=ArKQTOnxKessobXAY17rJdAUjC7lgX1bHv_f72ayzU8,3491
+backlogops_cli/encrypt_token_file.py,sha256=FbjNgKEJsBggGE7HMZMKSzXfn1O8G3qjA3Zk32T4htQ,4553
+backlogops_cli/estimate_ready_date.py,sha256=syJtL7MIeyWGaDOsX8QKjSsdTtRBu3SRnbWvtoIsZiY,5160
 backlogops_cli/extract_keys.py,sha256=Y_YdWuytwDokA3m4j9y1hLOr_Z84gSBvSLEKM4Xks1c,2909
-backlogops_cli/jira_fields.py,sha256=bAiQ_IV8cQt9HpGHvt2EmhHeCzmO8rkqs6BG8ehXulo,3072
+backlogops_cli/jira_fields.py,sha256=uRz9HqxkuEAN1Z8EKtZw2lL-S5xdTlKpZvAzvSwy9_g,5305
 backlogops_cli/list.py,sha256=lvvdb_UjNKLnGb1c2pilRWfSQrOptTrAiMGRcEVizhQ,2168
 backlogops_cli/migrate_cfg.py,sha256=6nnihDLZ8IxY0GFTrMzKeboHTUwA2UuFXE0Isr7_vT8,2528
 backlogops_cli/order_by_deps.py,sha256=N0vCRAnfV1xuC10T0ll1UUuOgWghus7eiXTut-QLaSA,2696
@@ -23,16 +23,16 @@ backlogops_cli/order_by_release.py,sha256=VUm6yywNEV9zMs0n0LqQvy3BZzjFrDLQKRZOqz
 backlogops_cli/order_releases.py,sha256=LbK0irFrXs_ib581oxV8JzZ8yl5bYf8g_MUhZB91FGU,2102
 backlogops_cli/order_releases_in_jira.py,sha256=kd2bV6tQexNBgRoCU0txM9aaxRGBAqUz7cX4-fCV3XA,5131
 backlogops_cli/plan_release_dates.py,sha256=d_8idlpQRpZFfHgo-fWmvm9Gc3g23eNh9mFNrSemt_w,1977
-backlogops_cli/preset_wizard.py,sha256=9Bnbes_E-nbYHEB0w4_HlHPARN8q2qv3m8Gm6nW16U4,2396
+backlogops_cli/preset_wizard.py,sha256=NltOoDiHLDZujvJAnlo6pLblaaXcDpSRLyRq-RNXIZQ,2435
 backlogops_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 backlogops_cli/rank_in_jira.py,sha256=-uGFXpne40dY_4ZtYqJTz6JIUelzsaBp8B2G_4EbMC4,4923
 backlogops_cli/read_jira.py,sha256=2-HQKIH7avENw7XMEIcFqt1mzPpsmoZ0Oy1SfBiFXlU,3423
 backlogops_cli/rename_releases_in_jira.py,sha256=yq2Xwst5tEOay0wAIWJso09GB1XP4z58zJlYo4Pga5I,4656
-backlogops_cli/update_backlog_in_jira.py,sha256=3H50cogxyDUsx8NxL6MMKsokw1YPwcBrW1Uhf9avwao,7413
+backlogops_cli/update_backlog_in_jira.py,sha256=Gg4nOldRRR8l6MfV7qgJeszOAlvL9zlmD8v4sKG038M,8888
 backlogops_cli/update_releases_in_jira.py,sha256=U96CVl6lJHOpEFRukQofleK8EGBR6BKSXMNk-OE7BNY,5300
 backlogops_cli/version.py,sha256=rhU5rq0tdxwJk0rJZKYZXc0rvH7aKd5zykDo2bPjmyY,528
-backlogops_cli-1.2.dist-info/licenses/LICENSE.txt,sha256=YbzYf1byKHV7rKnb_zN_ouS8n9ttzGcYHpfTdTf-dPk,1072
-backlogops_cli-1.2.dist-info/METADATA,sha256=pGp7rfKgHpVID2oGCaK6FXHrGyjOxXgMJGRLKUOBES4,12293
-backlogops_cli-1.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-backlogops_cli-1.2.dist-info/top_level.txt,sha256=6Vp2UR5vFqzujUt9VJ7sE9SkjBBICuS6zTe86Nzwd2w,15
-backlogops_cli-1.2.dist-info/RECORD,,
+backlogops_cli-1.4.dist-info/licenses/LICENSE.txt,sha256=YbzYf1byKHV7rKnb_zN_ouS8n9ttzGcYHpfTdTf-dPk,1072
+backlogops_cli-1.4.dist-info/METADATA,sha256=m88PDAQJU_JM249OWiga0ISDrdYw2GTLAPDJHQWDBHc,14093
+backlogops_cli-1.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+backlogops_cli-1.4.dist-info/top_level.txt,sha256=6Vp2UR5vFqzujUt9VJ7sE9SkjBBICuS6zTe86Nzwd2w,15
+backlogops_cli-1.4.dist-info/RECORD,,