backlogops 0.4__tar.gz → 0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backlogops
-Version: 0.4
+Version: 0.5
 Summary: Library with backlog operations.
 Author: Tom Björkholm
 Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
@@ -26,7 +26,7 @@ Requires-Dist: config-as-json>=1.4
 Requires-Dist: cryptography>=49.0.0
 Requires-Dist: jira[cli,opt]>=3.10.5
 Requires-Dist: tableio>=1.1
-Requires-Dist: tableio-cfg-json>=0.9
+Requires-Dist: tableio-cfg-json>=1.0
 Requires-Dist: versionreporter>=0.4
 Dynamic: author
 Dynamic: license-file
@@ -51,15 +51,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
 
@@ -316,9 +312,10 @@ For the full set of public names see the API documentation linked above.
 
 ## 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-0.4 → backlogops-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
 
@@ -281,9 +277,10 @@ For the full set of public names see the API documentation linked above.
 
 ## 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-0.4 → backlogops-0.5}/backlogops.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backlogops
-Version: 0.4
+Version: 0.5
 Summary: Library with backlog operations.
 Author: Tom Björkholm
 Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
@@ -26,7 +26,7 @@ Requires-Dist: config-as-json>=1.4
 Requires-Dist: cryptography>=49.0.0
 Requires-Dist: jira[cli,opt]>=3.10.5
 Requires-Dist: tableio>=1.1
-Requires-Dist: tableio-cfg-json>=0.9
+Requires-Dist: tableio-cfg-json>=1.0
 Requires-Dist: versionreporter>=0.4
 Dynamic: author
 Dynamic: license-file
@@ -51,15 +51,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
 
@@ -316,9 +312,10 @@ For the full set of public names see the API documentation linked above.
 
 ## 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-0.4 → backlogops-0.5}/backlogops.egg-info/requires.txt

@@ -2,5 +2,5 @@ config-as-json>=1.4
 cryptography>=49.0.0
 jira[cli,opt]>=3.10.5
 tableio>=1.1
-tableio-cfg-json>=0.9
+tableio-cfg-json>=1.0
 versionreporter>=0.4

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

@@ -5,7 +5,7 @@ from setuptools import setup
 
 setup(
   name='backlogops',
-  version='0.4',
+  version='0.5',
   description='Library with backlog operations.',
   author='Tom Björkholm',
   author_email='klausuler_linnet0q@icloud.com',
@@ -18,7 +18,7 @@ setup(
     'cryptography >= 49.0.0',
     'jira[cli,opt] >= 3.10.5',
     'tableio >= 1.1',
-    'tableio-cfg-json >= 0.9',
+    'tableio-cfg-json >= 1.0',
     'versionreporter >= 0.4'
   ]
 )

{backlogops-0.4 → backlogops-0.5}/src/backlogops/backlog_ops_wizard.py

@@ -31,7 +31,8 @@ from backlogops.levels import DEFAULT_LEVELS, Level
 from backlogops.person import Person
 from backlogops.table_rows import RELEASE_FIELDS
 from backlogops.team import FteException, Membership, Team
-from backlogops.work_hours import CompanyWorkHours, ExceptionWorkHours
+from backlogops.work_hours import CompanyWorkHours, DEFAULT_WORK_WEEK, \
+    ExceptionWorkHours, ScheduleWorkHours, WeekDay
 from backlogops.wizard_helpers import _backlog_map_fields
 from backlogops.wizard_navigator import _Navigator, _ask_level_display
 from backlogops.wizard_forms import FormField, FormResult, choice_field, \
@@ -220,29 +221,145 @@ def _levels_or_none(levels: list[Level]) -> Optional[list[Level]]:
     return levels
 
 
+_COMPANY_QUESTION = (
+    'Configure the company work hours.\n'
+    'Set the work hours for each week day, then, if there are any, the '
+    'first holiday, closure or special-work period and how many more '
+    'there are.')
+"""Instruction shown above the combined company work-hours form."""
+
+
+_MAX_EXCEPTIONS = 60
+"""Upper bound on the number of extra company periods the wizard adds."""
+
+
 def _build_company(nav: _Navigator,
                    default: Optional[AvailableTeams]) -> CompanyWorkHours:
     """Ask for the company weekly schedule and holiday periods.
 
-    The weekly schedule is one table and the holiday, closure and
-    special-work periods are a second table, so the whole company work
-    schedule is two screens.
+    The weekly work hours and the first holiday, closure or special-work
+    period are asked together on one form; any further periods each get
+    their own form whose question lists the periods entered so far.
     """
     company = default.company_work_hours if default else None
-    work_hours = nav.ask_schedule(seed=company.work_hours if company else None)
-    exceptions = nav.ask_exceptions(
-        'Company holiday, closure and special-work periods.',
-        seed=company.exceptions if company else None)
-    return CompanyWorkHours(work_hours=work_hours, exceptions=exceptions)
+    values = nav.ask_form(_COMPANY_QUESTION, _company_fields(), _company_rule,
+                          seed=_company_seed(company))
+    stored = company.exceptions if company else []
+    return CompanyWorkHours(work_hours=_schedule_from(values),
+                            exceptions=_build_exceptions(nav, values, stored))
+
+
+def _schedule_fields() -> list[FormField]:
+    """Return one work-hours field per week day, Monday first.
+
+    A day has between zero and twenty-four work hours, so the float field
+    enforces that inclusive range.
+    """
+    return [number_field(day.name.lower(), day.name.capitalize(),
+                         default=DEFAULT_WORK_WEEK[day], minimum=0.0,
+                         maximum=24.0)
+            for day in WeekDay]
+
+
+def _company_fields() -> list[FormField]:
+    """Return the combined company schedule and first-period fields."""
+    periods_q = 'Any holiday, closure or special-work periods?'
+    more_q = 'Number of additional such periods'
+    return (_schedule_fields()
+            + [yes_no_field('has_periods', periods_q, False)]
+            + _exception_fields()
+            + [int_field('more', more_q, default=0, minimum=0,
+                         maximum=_MAX_EXCEPTIONS)])
+
+
+def _company_rule(values: FormResult) -> tuple[Optional[str], set[str]]:
+    """Disable the period fields with no periods, else order-check them."""
+    if not values.flag('has_periods'):
+        return None, {'start', 'end', 'hours', 'new_days', 'more'}
+    return _period_rule(values)
+
+
+def _company_seed(company: Optional[CompanyWorkHours]) -> Optional[FormResult]:
+    """Return the combined company form values from stored work hours."""
+    if company is None:
+        return None
+    values: dict[str, object] = {
+        day.name.lower(): company.work_hours.get(day, DEFAULT_WORK_WEEK[day])
+        for day in WeekDay}
+    periods = company.exceptions
+    values['has_periods'] = bool(periods)
+    values['more'] = max(len(periods) - 1, 0)
+    if periods:
+        values.update(_period_values(periods[0]))
+    return FormResult(values)
+
+
+def _schedule_from(values: FormResult) -> ScheduleWorkHours:
+    """Return the weekly schedule read from the combined company form."""
+    return {day: values.number(day.name.lower()) for day in WeekDay}
+
+
+def _build_exceptions(nav: _Navigator, values: FormResult,
+                      stored: list[ExceptionWorkHours]
+                      ) -> list[ExceptionWorkHours]:
+    """Return the company periods, the first from the combined form."""
+    if not values.flag('has_periods'):
+        return []
+    first = _period_from(values)
+    rest = stored[1:] if len(stored) > 1 else []
+    return [first] + _more_exceptions(nav, values.whole('more'), first, rest)
+
+
+def _more_exceptions(nav: _Navigator, count: int, first: ExceptionWorkHours,
+                     seeds: list[ExceptionWorkHours]
+                     ) -> list[ExceptionWorkHours]:
+    """Collect the additional company periods after the first one.
+
+    Each period is asked on its own form whose question lists the periods
+    entered so far. The running list is reset on the first item, so a
+    replayed sub-level after a back or cancel request does not double it.
+    """
+    shown = [first]
+
+    def build(item: Optional[tuple[int, Optional[ExceptionWorkHours]]]
+              ) -> ExceptionWorkHours:
+        """Ask one additional period, shown after the earlier ones."""
+        assert item is not None
+        index, seed = item
+        if index == 0:
+            del shown[1:]
+        values = nav.ask_form(_more_question(shown), _exception_fields(),
+                              _period_rule, seed=_exc_seed(seed))
+        shown.append(_period_from(values))
+        return shown[-1]
+    indexed: list[tuple[int, Optional[ExceptionWorkHours]]] = [
+        (k, seeds[k] if k < len(seeds) else None) for k in range(count)]
+    return nav.counted(count, indexed, build)
+
+
+def _more_question(shown: list[ExceptionWorkHours]) -> str:
+    """Return the next-period question listing the periods entered so far."""
+    lines = ['Configure the next holiday, closure or special-work period.',
+             'Periods entered so far:']
+    return '\n'.join(lines + [_period_line(period) for period in shown])
+
+
+def _period_line(period: ExceptionWorkHours) -> str:
+    """Return a one-line summary of one exception period."""
+    extra = ' (adds free-day work)' if period.new_work_days else ''
+    return (f'  {period.start_date} to {period.end_date}: '
+            f'{period.hours_per_day:g} h/day{extra}')
+
+
+def _period_values(period: ExceptionWorkHours) -> dict[str, object]:
+    """Return the form values for one work-hour exception period."""
+    return {'start': period.start_date, 'end': period.end_date,
+            'hours': period.hours_per_day, 'new_days': period.new_work_days}
 
 
 def _exc_seed(exc: Optional[ExceptionWorkHours]) -> Optional[FormResult]:
     """Return the work-hour exception form values from an exception."""
-    if exc is None:
-        return None
-    return FormResult({'start': exc.start_date, 'end': exc.end_date,
-                       'hours': exc.hours_per_day,
-                       'new_days': exc.new_work_days})
+    return None if exc is None else FormResult(_period_values(exc))
 
 
 def _period_rule(values: FormResult) -> tuple[Optional[str], set[str]]:
@@ -265,16 +382,21 @@ def _exception_fields() -> list[FormField]:
                      'normally free?', False)]
 
 
+def _period_from(values: FormResult) -> ExceptionWorkHours:
+    """Return one exception period from a form's period fields."""
+    return ExceptionWorkHours(start_date=values.day('start'),
+                              end_date=values.day('end'),
+                              hours_per_day=values.number('hours'),
+                              new_work_days=values.flag('new_days'))
+
+
 def _ask_exception(nav: _Navigator, seed: Optional[ExceptionWorkHours] = None
                    ) -> ExceptionWorkHours:
     """Ask for one work-hour exception period on a single form."""
     values = nav.ask_form('Configure the work-hour exception period.',
                           _exception_fields(), _period_rule,
                           seed=_exc_seed(seed))
-    return ExceptionWorkHours(start_date=values.day('start'),
-                              end_date=values.day('end'),
-                              hours_per_day=values.number('hours'),
-                              new_work_days=values.flag('new_days'))
+    return _period_from(values)
 
 
 def _build_persons(nav: _Navigator,

{backlogops-0.4 → backlogops-0.5}/src/backlogops/jira_wizard.py

@@ -25,7 +25,7 @@ token is visible while typed; the pass phrases are masked.
 from dataclasses import dataclass
 from functools import partial
 from typing import Callable, Optional, TypeVar
-from tableio_cfg_json import WizardPathKind
+from tableio_cfg_json import PrefillValueType, WizardPathKind
 from backlogops.jira_io_config import DEF_BACKLOG_COLUMN_MAP, \
     DEF_RELEASE_COLUMN_MAP, JiraColumnMap, JiraConnectConfig, JiraIOConfig, \
     JiraIssueTypeMap, JiraPreset, JiraType, TokenStorage, _FILE_MODES, \
@@ -364,8 +364,9 @@ _ISSUE_MAP_Q = ('Use a level-to-issue-type map when writing (otherwise the '
 
 _FILTER_EG = default_jira_filter('<project key>')
 """Illustrative blank-filter default shown in the filter help text."""
-_FILTER_HELP = ('Leave blank to select the default project in rank '
-                f'order, i.e. {_FILTER_EG}.')
+_FILTER_HELP = ('Leave blank to select the whole project in rank order; '
+                f'the default {_FILTER_EG} is offered once the project key '
+                'is set.')
 """Help shown for the blank-defaulting issue filter field."""
 
 
@@ -417,6 +418,40 @@ def _preset_rule(has_issue_type: bool
     return rule
 
 
+# pylint: disable-next=too-few-public-methods
+class _FilterPrefill:
+    """Offer the default rank filter while the preset filter stays blank.
+
+    While the user has not written their own issue filter, every change to
+    the project key re-derives the default filter and offers it to the
+    filter field, so the filter tracks the project as it is typed. The
+    moment the filter holds text the user placed there, tracking stops and
+    the filter is left alone. The last value offered is remembered so the
+    bridge writing that value back does not look like the user typing it.
+    """
+
+    def __init__(self) -> None:
+        """Start with nothing offered and the filter not yet user-owned."""
+        self._taken_over = False
+        self._last_fill: Optional[str] = None
+
+    def __call__(self, values: FormResult,
+                 changed: str) -> list[tuple[str, PrefillValueType]]:
+        """Return a filter prefill for a project change, or nothing."""
+        self._note_user_filter(values)
+        project = values.opt_text('def_project')
+        if self._taken_over or changed != 'def_project' or not project:
+            return []
+        self._last_fill = default_jira_filter(project)
+        return [('def_filter', self._last_fill)]
+
+    def _note_user_filter(self, values: FormResult) -> None:
+        """Mark the filter user-owned once it holds text we did not offer."""
+        current = values.opt_text('def_filter')
+        if current and current != self._last_fill:
+            self._taken_over = True
+
+
 def _preset_seed(name: Optional[str], preset: Optional[JiraPreset],
                  choices: _PresetChoices) -> Optional[FormResult]:
     """Return the preset form values from a stored preset."""
@@ -444,6 +479,7 @@ def _ask_preset(nav: _Navigator, choices: _PresetChoices, used: set[str],
     values = nav.ask_form('Configure the Jira preset.',
                           _preset_fields(used, choices),
                           _preset_rule(bool(choices.issue_type_maps)),
+                          prefill=_FilterPrefill(),
                           seed=_preset_seed(seed_name, seed_preset, choices))
     return _preset_from(nav, values, choices)
 

{backlogops-0.4 → backlogops-0.5}/src/backlogops/wizard_forms.py

@@ -15,9 +15,16 @@ the answers so far make irrelevant. :func:`run_form` shows the fields,
 disables the irrelevant ones, blocks an invalid form and returns the typed
 answers as a :class:`FormResult`.
 
-Dates and decimals have no native field type, so they are asked as text
-fields validated here. :func:`_parse_date` and :func:`_num_text` are shared
-with the table-based wizard helpers.
+A form may also pass a ``prefill`` callback. It is called with the current
+:class:`FormResult` and the key of the field that just changed, and returns
+``(key, value)`` requests that offer a value to another field as its live
+default, exactly as if the user had typed it. This lets one field be derived
+from others, such as a Jira filter derived from the project key, while the
+user stays free to override the offered value.
+
+Dates use :class:`AskDateField` (a calendar picker in a graphical bridge) and
+decimals use :class:`AskFloatField`, so both come back as typed answers, with
+their format and range checked by the field rather than by validated text.
 """
 
 # Copyright (c) 2026, Tom Björkholm
@@ -27,21 +34,18 @@ from dataclasses import dataclass, replace
 from datetime import date
 from pathlib import Path
 from typing import Callable, Optional, Sequence
-from tableio_cfg_json import AnswerField, AskChoiceField, AskField, \
-    AskIntField, AskPathField, AskTextField, AskYesNoField, \
-    PartFormValidationResult, PathAskOptions, WizardPathKind, \
-    WizardUiBridge
+from tableio_cfg_json import AnswerField, AskChoiceField, AskDateField, \
+    AskField, AskFloatField, AskIntField, AskPathField, AskTextField, \
+    AskYesNoField, PartFormValidationResult, PathAskOptions, PrefillValues, \
+    PrefillValueType, WizardPathKind, WizardUiBridge
 from backlogops.io_config import PRESET_NAME_RE
 
 _REQUIRED = 'Please enter a value.'
-_NUMBER_ERROR = 'Please enter a number.'
-_DATE_ERROR = 'Please enter a date as YYYY-MM-DD.'
+_DATE_ERROR = 'Please enter a date.'
 _NAME_ERROR = 'Use only letters and digits for a name.'
 _CHOICE_ERROR = 'Please choose a value.'
 _PHRASE_ERROR = 'Please enter a pass phrase.'
 _INVALID_FORM = 'Please correct the highlighted fields.'
-_DATE_HINT = ' (YYYY-MM-DD)'
-_DATE_HINT_OPT = ' (YYYY-MM-DD, blank for none)'
 
 
 @dataclass(frozen=True)
@@ -126,6 +130,12 @@ def _no_rule(_values: FormResult) -> tuple[Optional[str], set[str]]:
     return None, set()
 
 
+def _no_prefill(_values: FormResult,
+                _changed: str) -> list[tuple[str, PrefillValueType]]:
+    """Offer no field a derived default."""
+    return []
+
+
 def _seeded_fields(fields: Sequence[FormField],
                    seed: Optional[FormResult]) -> list[FormField]:
     """Return the fields with each ask pre-filled from a seed result."""
@@ -148,15 +158,24 @@ def _reseed_ask(ask: AskField, value: object) -> AskField:
     if isinstance(ask, AskIntField) and isinstance(value, int) \
             and not isinstance(value, bool):
         return replace(ask, default=_clamped_int(value, ask))
-    if isinstance(ask, AskChoiceField) and isinstance(value, str) \
-            and value in ask.choices:
-        return replace(ask, default=value)
-    if isinstance(ask, AskTextField) and not ask.sensitive:
-        text = _as_text(value)
-        return ask if text is None else replace(ask, default=text)
     if isinstance(ask, AskPathField) and isinstance(value, str) and value:
         options = replace(ask.path_options, default=Path(value))
         return replace(ask, path_options=options)
+    return _reseed_typed(ask, value)
+
+
+def _reseed_typed(ask: AskField, value: object) -> AskField:
+    """Return ask reseeded for the value-typed fields, else unchanged."""
+    if isinstance(ask, AskFloatField) and isinstance(value, float):
+        return replace(ask, default=value)
+    if isinstance(ask, AskDateField) and isinstance(value, date):
+        return replace(ask, default=value)
+    if isinstance(ask, AskChoiceField) and isinstance(value, str) \
+            and value in ask.choices:
+        return replace(ask, default=value)
+    if isinstance(ask, AskTextField) and not ask.sensitive \
+            and isinstance(value, str):
+        return replace(ask, default=value)
     return ask
 
 
@@ -174,31 +193,25 @@ def _clamped_int(value: int, ask: AskIntField) -> int:
     return value
 
 
-def _as_text(value: object) -> Optional[str]:
-    """Return a text default for a value, or None when it has no text."""
-    if isinstance(value, date):
-        return value.isoformat()
-    if isinstance(value, bool):
-        return None
-    if isinstance(value, float):
-        return _num_text(value)
-    if isinstance(value, str):
-        return value
-    return None
-
-
+# pylint: disable-next=too-many-arguments
 def run_form(bridge: WizardUiBridge, question: str,
              fields: Sequence[FormField],
              rule: Callable[[FormResult], tuple[Optional[str], set[str]]]
-             = _no_rule, seed: Optional[FormResult] = None) -> FormResult:
+             = _no_rule, *,
+             prefill: Callable[[FormResult, str],
+                               list[tuple[str, PrefillValueType]]]
+             = _no_prefill,
+             seed: Optional[FormResult] = None) -> FormResult:
     """Ask a whole form and return its validated, typed answers.
 
     The rule disables the fields that the current answers make irrelevant
-    and reports any cross-field problem. A bridge that validates on submit
-    returns only valid answers; a plain console bridge may return an
-    invalid form, which is re-asked with the blocking message shown. When a
-    ``seed`` result is given each field starts pre-filled with its seed
-    value, so a re-asked or default-driven form opens on the earlier
+    and reports any cross-field problem. The prefill callback offers a
+    derived value to another field after each change, ignored on submit so
+    the caller must still apply the same default itself. A bridge that
+    validates on submit returns only valid answers; a plain console bridge
+    may return an invalid form, which is re-asked with the blocking message
+    shown. When a ``seed`` result is given each field starts pre-filled with
+    its seed value, so a re-asked or default-driven form opens on the earlier
     answers; sensitive fields keep no default and are always asked afresh.
     """
     fields = _seeded_fields(fields, seed)
@@ -207,7 +220,7 @@ def run_form(bridge: WizardUiBridge, question: str,
     def validate(answers: Sequence[AnswerField],
                  changed: int) -> PartFormValidationResult:
         """Validate the current answers for the bridge's live feedback."""
-        return _validate(fields, rule, list(answers), changed)
+        return _validate(fields, rule, list(answers), changed, prefill)
     reason: Optional[str] = None
     while True:
         answers = list(bridge.ask_form(question, asks, re_ask_reason=reason,
@@ -227,28 +240,46 @@ def _values_of(fields: Sequence[FormField],
 
 def _validate(fields: Sequence[FormField],
               rule: Callable[[FormResult], tuple[Optional[str], set[str]]],
-              answers: list[AnswerField],
-              changed: int) -> PartFormValidationResult:
-    """Run the rule and the field checks into one validation result."""
-    message, disabled_keys = rule(FormResult(_values_of(fields, answers)))
+              answers: list[AnswerField], changed: int,
+              prefill: Callable[[FormResult, str],
+                                list[tuple[str, PrefillValueType]]]
+              = _no_prefill) -> PartFormValidationResult:
+    """Run the rule, the field checks and the prefill into one result."""
+    values = FormResult(_values_of(fields, answers))
+    message, disabled_keys = rule(values)
     errors = _field_errors(fields, answers, disabled_keys)
     disabled = tuple(index for index, field in enumerate(fields)
                      if field.key in disabled_keys)
     valid = message is None and not errors
+    prefills = _prefills(fields, values, changed, prefill)
     return PartFormValidationResult(valid, _message(errors, message, changed),
-                                    disabled)
+                                    disabled, prefills)
+
+
+def _prefills(fields: Sequence[FormField], values: FormResult, changed: int,
+              prefill: Callable[[FormResult, str],
+                                list[tuple[str, PrefillValueType]]]
+              ) -> PrefillValues:
+    """Translate the prefill callback's key requests into row indexes."""
+    index_of = {field.key: index for index, field in enumerate(fields)}
+    return tuple((index_of[key], value)
+                 for key, value in prefill(values, fields[changed].key))
 
 
 def _field_errors(fields: Sequence[FormField], answers: list[AnswerField],
                   disabled_keys: set[str]) -> dict[int, str]:
-    """Return the own error of every enabled field, keyed by row index."""
+    """Return the labelled own error of each enabled field, by row index.
+
+    Each message is prefixed with the field's label so a form that shows
+    every field at once makes clear which field the message refers to.
+    """
     errors: dict[int, str] = {}
     for index, field in enumerate(fields):
         if field.key in disabled_keys:
             continue
         error = field.error(answers[index])
         if error is not None:
-            errors[index] = error
+            errors[index] = f'{field.ask.short_question}: {error}'
     return errors
 
 
@@ -278,29 +309,6 @@ def _answer_path(answer: AnswerField) -> Optional[Path]:
     return value
 
 
-def _parse_date(answer: str) -> Optional[date]:
-    """Return the ISO date in ``answer``, or None when it is invalid."""
-    try:
-        return date.fromisoformat(answer)
-    except ValueError:
-        return None
-
-
-def _num_text(value: float) -> str:
-    """Return a compact decimal text for a default numeric value."""
-    return f'{value:g}'
-
-
-def _parse_float(text: Optional[str]) -> Optional[float]:
-    """Return the float in ``text``, or None when it is not a number."""
-    if not text:
-        return None
-    try:
-        return float(text)
-    except ValueError:
-        return None
-
-
 def name_error(name: Optional[str], used: set[str]) -> Optional[str]:
     """Return why a preset-style name is invalid, or None when it is fine."""
     if name is None or PRESET_NAME_RE.match(name) is None:
@@ -422,41 +430,32 @@ def int_field(key: str, question: str, *, default: int,
 def number_field(key: str, question: str, *, default: float,
                  minimum: Optional[float] = None,
                  maximum: Optional[float] = None) -> FormField:
-    """Return a decimal field pre-filled with its default."""
-    ask = AskTextField(question, None, nullable=True,
-                       default=_num_text(default))
+    """Return a decimal field pre-filled with its default.
 
-    def error(answer: AnswerField) -> Optional[str]:
-        """Reject a non-numeric or out-of-range decimal answer."""
-        return _number_error(_answer_text(answer), minimum, maximum)
-
-    def value(answer: AnswerField) -> object:
-        """Return the entered decimal, or the default for a blank answer."""
-        parsed = _parse_float(_answer_text(answer))
-        return default if parsed is None else parsed
-    return FormField(key, ask, error, value)
+    The field itself checks that the answer is a number within the
+    inclusive bounds and returns the default for a blank answer.
+    """
+    ask = AskFloatField(question, None, default=default, min_value=minimum,
+                        max_value=maximum)
+    return FormField(key, ask, _no_error, _float_value)
 
 
 def date_field(key: str, question: str, *,
                help_text: Optional[str] = None) -> FormField:
-    """Return a required ISO date field, asked as validated text."""
-    ask = AskTextField(question + _DATE_HINT, help_text, nullable=True)
+    """Return a required date field, shown with a calendar picker."""
+    ask = AskDateField(question, help_text, nullable=True)
 
     def error(answer: AnswerField) -> Optional[str]:
-        """Reject a missing or malformed required date."""
-        return _date_error(_answer_text(answer), required=True)
-    return FormField(key, ask, error, _date_value)
+        """Reject a missing required date."""
+        return None if _answer_date(answer) is not None else _DATE_ERROR
+    return FormField(key, ask, error, _answer_date)
 
 
 def opt_date_field(key: str, question: str, *,
                    help_text: Optional[str] = None) -> FormField:
-    """Return an optional ISO date field that may be left blank."""
-    ask = AskTextField(question + _DATE_HINT_OPT, help_text, nullable=True)
-
-    def error(answer: AnswerField) -> Optional[str]:
-        """Reject a malformed date but accept a blank one."""
-        return _date_error(_answer_text(answer), required=False)
-    return FormField(key, ask, error, _date_value)
+    """Return an optional date field that may be left blank."""
+    ask = AskDateField(question, help_text, nullable=True)
+    return FormField(key, ask, _no_error, _answer_date)
 
 
 def _no_error(_answer: AnswerField) -> Optional[str]:
@@ -472,35 +471,26 @@ def _flag_value(answer: AnswerField) -> object:
 
 
 def _int_value(answer: AnswerField) -> object:
-    """Return the integer an answer holds."""
+    """Return the integer an answer holds, or None when not yet valid.
+
+    A graphical or textual bridge runs the validator after every change,
+    so a field may still be empty or out of range; the strict FormResult
+    getters check the type only when the accepted answer is read.
+    """
     value = answer.value
-    assert isinstance(value, int)
+    assert value is None or isinstance(value, int)
     return value
 
 
-def _date_value(answer: AnswerField) -> object:
-    """Return the date an answer holds, or None when it is blank."""
-    text = _answer_text(answer)
-    return _parse_date(text) if text else None
-
-
-def _number_error(text: Optional[str], minimum: Optional[float],
-                  maximum: Optional[float]) -> Optional[str]:
-    """Return why a decimal answer is invalid, or None when it is fine."""
-    if not text:
-        return None
-    value = _parse_float(text)
-    if value is None:
-        return _NUMBER_ERROR
-    if minimum is not None and value < minimum:
-        return f'Please enter a value of at least {minimum:g}.'
-    if maximum is not None and value > maximum:
-        return f'Please enter a value of at most {maximum:g}.'
-    return None
+def _float_value(answer: AnswerField) -> object:
+    """Return the decimal an answer holds, or None when not yet valid."""
+    value = answer.value
+    assert value is None or isinstance(value, float)
+    return value
 
 
-def _date_error(text: Optional[str], required: bool) -> Optional[str]:
-    """Return why a date answer is invalid, or None when it is fine."""
-    if not text:
-        return _DATE_ERROR if required else None
-    return None if _parse_date(text) else _DATE_ERROR
+def _answer_date(answer: AnswerField) -> Optional[date]:
+    """Return the date an answer holds, or None when it is blank."""
+    value = answer.value
+    assert value is None or isinstance(value, date)
+    return value

{backlogops-0.4 → backlogops-0.5}/src/backlogops/wizard_helpers.py

@@ -2,12 +2,13 @@
 """Reusable field-input helpers for the wizards.
 
 The ``_read_*`` and ``_parse_*`` helpers ask and validate the single-value
-and whole-table fields, such as a preset name, the weekly work-hours
-schedule, the column rename maps and the backlog item levels, and pre-fill
-each from an optional seed value so a re-asked or default-driven question
-opens on the earlier answer. The re-runnable :class:`_Navigator` that calls
-them lives in :mod:`backlogops.wizard_navigator`; the one-screen form
-toolkit lives in :mod:`backlogops.wizard_forms`. The small domain helper
+and whole-table fields, such as a preset name, the column rename maps and
+the backlog item levels, and pre-fill each from an optional seed value so a
+re-asked or default-driven question opens on the earlier answer. The
+re-runnable :class:`_Navigator` that calls them lives in
+:mod:`backlogops.wizard_navigator`; the one-screen form toolkit, which now
+asks the company work hours and its exception periods, lives in
+:mod:`backlogops.wizard_forms`. The small domain helper
 :func:`_backlog_map_fields` is shared by the configuration and the preset
 wizards.
 
@@ -27,12 +28,10 @@ from tableio_cfg_json import TableCell, TableColumn, TioJsonConfig, \
 from backlogops.backlog import Status
 from backlogops.jira_io_config import JiraAttrPath, JiraAttrType, \
     JiraColumnMap, JiraIssueTypeMap
-from backlogops.wizard_forms import name_error, _num_text, _parse_date
+from backlogops.wizard_forms import name_error
 from backlogops.levels import DEFAULT_LEVELS, Level, Levels, levels_from_list
 from backlogops.table_rows import BACKLOG_FIELDS, LEVEL_COLUMN, \
     LEVEL_NAME_COLUMN
-from backlogops.work_hours import DEFAULT_WORK_WEEK, ExceptionWorkHours, \
-    ScheduleWorkHours, WeekDay
 
 
 def _read_text(ui: WizardUiBridge, question: str, default: Optional[str],
@@ -94,173 +93,6 @@ def _read_tableio(ui: WizardUiBridge, file_access: FileAccess,
                                   default=default, backward=backward)
 
 
-def _is_nonneg(text: Optional[str]) -> bool:
-    """Return whether ``text`` parses as a number that is at least zero."""
-    if text is None:
-        return False
-    try:
-        return float(text) >= 0.0
-    except ValueError:
-        return False
-
-
-def _sched_check(table: list[list[Optional[str]]],
-                 position: tuple[int, int]) -> tuple[bool, str]:
-    """Give early feedback that an edited work-hours cell is a number."""
-    row, col = position
-    if col != 1:
-        return (True, '')
-    ok = _is_nonneg(table[row][1])
-    return (ok, '' if ok else 'Enter work hours as a number that is >= 0.')
-
-
-def _parse_schedule(days: Sequence[WeekDay],
-                    table: Sequence[Sequence[Optional[str]]]
-                    ) -> Optional[ScheduleWorkHours]:
-    """Return the weekly schedule from a table, or None when invalid."""
-    schedule: ScheduleWorkHours = {}
-    for day, row in zip(days, table):
-        hours = row[1]
-        if not _is_nonneg(hours):
-            return None
-        assert hours is not None
-        schedule[day] = float(hours)
-    return schedule
-
-
-def _read_schedule(ui: WizardUiBridge, seed: Optional[ScheduleWorkHours] = None
-                   ) -> ScheduleWorkHours:
-    """Ask the weekly work-hours schedule as one table question.
-
-    The hours are pre-filled from the seed schedule, or from the default
-    work week when no seed is given.
-    """
-    days = list(WeekDay)
-    source = seed if seed is not None else DEFAULT_WORK_WEEK
-    columns = [TableColumn(header='Day', read_only=True),
-               TableColumn(header='Work hours')]
-    cells = [[TableCell(value=day.name.capitalize()),
-              TableCell(value=_num_text(source.get(day,
-                                                   DEFAULT_WORK_WEEK[day])))]
-             for day in days]
-    reason: Optional[str] = None
-    while True:
-        table = ui.ask_table(columns, cells,
-                             'Company work hours per week day:',
-                             re_ask_reason=reason, partial_check=_sched_check)
-        schedule = _parse_schedule(days, table)
-        if schedule is not None:
-            return schedule
-        reason = 'Enter work hours as a number that is at least zero.'
-
-
-_MAX_EXCEPTIONS = 60
-"""Upper bound on the number of exception-period rows the wizard accepts."""
-
-_EXC_HINT = ("Enter each period's dates as YYYY-MM-DD, its work hours per "
-             "day as a number (blank means zero), and 'yes' or 'no' for "
-             'whether it adds work on days that are normally free.')
-"""Help text shown above the work-hour exception table."""
-
-
-def _parse_yes_no(text: Optional[str]) -> Optional[bool]:
-    """Return the boolean a yes/no cell holds, or None when invalid.
-
-    A blank cell counts as 'no', so an added but unset flag means the
-    period adds no work on days that are normally free.
-    """
-    token = '' if text is None else text.strip().lower()
-    if token in ('', 'no', 'n', 'false', '0'):
-        return False
-    if token in ('yes', 'y', 'true', '1'):
-        return True
-    return None
-
-
-def _exc_check(table: list[list[Optional[str]]],
-               position: tuple[int, int]) -> tuple[bool, str]:
-    """Give early feedback on one work-hour exception cell."""
-    row, col = position
-    text = table[row][col] or ''
-    if col in (0, 1):
-        ok = text == '' or _parse_date(text) is not None
-        return (ok, '' if ok else 'Enter the date as YYYY-MM-DD.')
-    if col == 2:
-        ok = text == '' or _is_nonneg(text)
-        return (ok, '' if ok else 'Enter work hours as a number >= 0.')
-    ok = _parse_yes_no(text) is not None
-    return (ok, '' if ok else "Enter 'yes' or 'no'.")
-
-
-def _parse_exceptions(table: list[list[Optional[str]]]
-                      ) -> Optional[list[ExceptionWorkHours]]:
-    """Return the exception periods from a table, or None when invalid.
-
-    A row with both dates blank is treated as an unused row and skipped.
-    Any other row needs a valid start and end date with the end on or
-    after the start, non-negative work hours (blank means zero) and a
-    yes/no adds-free-day-work flag (blank means no).
-    """
-    result: list[ExceptionWorkHours] = []
-    for row in table:
-        start_text, end_text = row[0], row[1]
-        hours_text, adds_text = row[2], row[3]
-        if not start_text and not end_text:
-            continue
-        start = _parse_date(start_text) if start_text else None
-        end = _parse_date(end_text) if end_text else None
-        adds = _parse_yes_no(adds_text)
-        if start is None or end is None or end < start or adds is None:
-            return None
-        if hours_text and not _is_nonneg(hours_text):
-            return None
-        hours = float(hours_text) if hours_text else 0.0
-        result.append(ExceptionWorkHours(start_date=start, end_date=end,
-                                         hours_per_day=hours,
-                                         new_work_days=adds))
-    return result
-
-
-def _exc_cells(exceptions: Sequence[ExceptionWorkHours]
-               ) -> list[list[TableCell]]:
-    """Return table rows filled from the given exception periods."""
-    return [[TableCell(value=exc.start_date.isoformat()),
-             TableCell(value=exc.end_date.isoformat()),
-             TableCell(value=_num_text(exc.hours_per_day)),
-             TableCell(value='yes' if exc.new_work_days else 'no')]
-            for exc in exceptions]
-
-
-def _read_exceptions(ui: WizardUiBridge, question: str,
-                     seed: Optional[Sequence[ExceptionWorkHours]] = None
-                     ) -> list[ExceptionWorkHours]:
-    """Ask the work-hour exception periods as one variable-row table.
-
-    The table starts from the seed periods, or empty when none are given,
-    and may be left empty for no exceptions. Individual cells are checked
-    as they are entered; an inconsistent whole table, such as a period
-    whose end precedes its start, is re-asked with the user's own rows
-    kept.
-    """
-    columns = [TableColumn(header='Start date'),
-               TableColumn(header='End date'),
-               TableColumn(header='Work hours per day'),
-               TableColumn(header='Adds work on free days?')]
-    cells = _exc_cells(seed) if seed else []
-    instruction = f'{question} {_EXC_HINT}'
-    reason: Optional[str] = None
-    while True:
-        table = ui.ask_table(columns, cells, instruction, re_ask_reason=reason,
-                             partial_check=_exc_check, min_rows=0,
-                             max_rows=_MAX_EXCEPTIONS)
-        parsed = _parse_exceptions(table)
-        if parsed is not None:
-            return parsed
-        reason = ('Give each period a start and end date (end not before '
-                  'start), non-negative hours, and yes or no.')
-        cells = _cells_from_table(table)
-
-
 _MAX_EXTRA_COLUMNS = 30
 """How many extra-field rows the user may add to a backlog rename table."""
 

{backlogops-0.4 → backlogops-0.5}/src/backlogops/wizard_navigator.py

@@ -21,17 +21,16 @@ from dataclasses import dataclass, field
 from functools import partial
 from typing import Callable, Optional, Sequence, TextIO, TypeVar
 from tableio import FileAccess
-from tableio_cfg_json import TioJsonConfig, WizardBack, WizardCancelLevel, \
-    WizardUiBridge
+from tableio_cfg_json import PrefillValueType, TioJsonConfig, WizardBack, \
+    WizardCancelLevel, WizardUiBridge
 from backlogops.backlog import Status
 from backlogops.jira_io_config import JiraColumnMap, JiraIssueTypeMap
 from backlogops.levels import Level, LevelDisplay, Levels
-from backlogops.work_hours import ExceptionWorkHours, ScheduleWorkHours
-from backlogops.wizard_forms import FormField, FormResult, run_form, _no_rule
-from backlogops.wizard_helpers import _RenameKind, _read_exceptions, \
-    _read_int, _read_issue_type_map, _read_jira_map, _read_levels, \
-    _read_preset_name, _read_renames, _read_schedule, _read_status_map, \
-    _read_tableio, _read_text
+from backlogops.wizard_forms import FormField, FormResult, run_form, \
+    _no_prefill, _no_rule
+from backlogops.wizard_helpers import _RenameKind, _read_int, \
+    _read_issue_type_map, _read_jira_map, _read_levels, _read_preset_name, \
+    _read_renames, _read_status_map, _read_tableio, _read_text
 
 _T = TypeVar('_T')
 _D = TypeVar('_D')
@@ -234,11 +233,15 @@ class _Navigator:
     def ask_form(self, question: str, fields: Sequence[FormField],
                  rule: Callable[[FormResult], tuple[Optional[str], set[str]]]
                  = _no_rule, *,
+                 prefill: Callable[[FormResult, str],
+                                   list[tuple[str, PrefillValueType]]]
+                 = _no_prefill,
                  seed: Optional[FormResult] = None) -> FormResult:
         """Ask a whole form on one screen, pre-filled from a seed result."""
         def ask(sd: object, _bw: bool) -> object:
             pre = sd if isinstance(sd, FormResult) else None
-            return run_form(self._ui, question, fields, rule, pre)
+            return run_form(self._ui, question, fields, rule, prefill=prefill,
+                            seed=pre)
         result = self._ask(ask, seed)
         assert isinstance(result, FormResult)
         return result
@@ -267,27 +270,6 @@ class _Navigator:
         assert isinstance(result, TioJsonConfig)
         return result
 
-    def ask_schedule(self, *, seed: Optional[ScheduleWorkHours] = None
-                     ) -> ScheduleWorkHours:
-        """Ask the weekly work-hours schedule as one table question."""
-        def ask(sd: object, _bw: bool) -> object:
-            pre = sd if isinstance(sd, dict) else None
-            return _read_schedule(self._ui, pre)
-        result = self._ask(ask, seed)
-        assert isinstance(result, dict)
-        return result
-
-    def ask_exceptions(self, question: str, *,
-                       seed: Optional[list[ExceptionWorkHours]] = None
-                       ) -> list[ExceptionWorkHours]:
-        """Ask the work-hour exception periods as one variable-row table."""
-        def ask(sd: object, _bw: bool) -> object:
-            pre = sd if isinstance(sd, list) else None
-            return _read_exceptions(self._ui, question, pre)
-        result = self._ask(ask, seed)
-        assert isinstance(result, list)
-        return result
-
     def ask_levels(self, *, seed: Optional[list[Level]] = None) -> list[Level]:
         """Ask the backlog item levels as one variable-row table."""
         def ask(sd: object, _bw: bool) -> object: