Resolve Cyclic Imports

app/forms/field_handlers/__init__.py

@@ -20,7 +20,6 @@
 from app.forms.field_handlers.string_handler import StringHandler
 from app.forms.field_handlers.text_area_handler import TextAreaHandler
 from app.questionnaire.rules.rule_evaluator import RuleEvaluator
-from app.questionnaire.value_source_resolver import ValueSourceResolver
 
 FIELD_HANDLER_MAPPINGS = {
     "Checkbox": SelectMultipleHandler,
@@ -45,15 +44,13 @@
 def get_field_handler(
     *,
     answer_schema: dict,
-    value_source_resolver: ValueSourceResolver,
     rule_evaluator: RuleEvaluator,
     error_messages: ImmutableDict,
     disable_validation: bool = False,
     question_title: Optional[str] = None,
 ) -> FieldHandler:
     return FIELD_HANDLER_MAPPINGS[answer_schema["type"]](
         answer_schema=answer_schema,
-        value_source_resolver=value_source_resolver,
         rule_evaluator=rule_evaluator,
         error_messages=error_messages,
         disable_validation=disable_validation,

app/forms/field_handlers/field_handler.py

@@ -9,7 +9,6 @@
 from app.questionnaire.rules.rule_evaluator import RuleEvaluator
 from app.questionnaire.value_source_resolver import (
     ValueSourceEscapedTypes,
-    ValueSourceResolver,
     ValueSourceTypes,
 )
 
@@ -20,15 +19,14 @@ class FieldHandler(ABC):
     def __init__(
         self,
         answer_schema: Mapping[str, Any],
-        value_source_resolver: ValueSourceResolver,
         rule_evaluator: RuleEvaluator,
         error_messages: Mapping[str, str],
         disable_validation: bool = False,
         question_title: Optional[str] = None,
     ):
         self.answer_schema = answer_schema
-        self.value_source_resolver = value_source_resolver
         self.rule_evaluator = rule_evaluator
+        self.value_source_resolver = rule_evaluator.value_source_resolver
         self.error_messages = error_messages
         self.disable_validation = disable_validation
         self.question_title = str(question_title)

app/forms/questionnaire_form.py

@@ -314,19 +314,19 @@ def _get_period_range_for_single_date(
             data_stores=self.data_stores,
             schema=self.schema,
             location=self.location,
+            use_default_answer=True,
             list_item_id=list_item_id,
             escape_answer_values=False,
         )
 
         rule_evaluator = RuleEvaluator(
+            value_source_resolver=value_source_resolver,
             data_stores=self.data_stores,
             schema=self.schema,
             location=self.location,
         )
 
-        handler = DateHandler(
-            date_from, value_source_resolver, rule_evaluator, error_messages
-        )
+        handler = DateHandler(date_from, rule_evaluator, error_messages)
 
         min_period_date = handler.get_date_value("minimum") or handler.get_date_value(
             "maximum"
@@ -480,32 +480,47 @@ def get_answer_fields(
     if block_ids_by_section:
         block_ids = get_flattened_mapping_values(block_ids_by_section)
 
-    def _get_value_source_resolver(list_item: str | None = None) -> ValueSourceResolver:
+    def _get_value_source_resolver(
+        list_item: str | None = None,
+        use_default_answer: bool = False,
+        assess_routing_path: bool = False,
+    ) -> ValueSourceResolver:
         return ValueSourceResolver(
             data_stores=data_stores,
             schema=schema,
             location=location,
             list_item_id=list_item,
             escape_answer_values=False,
             routing_path_block_ids=block_ids,
-            assess_routing_path=False,
+            assess_routing_path=assess_routing_path,
+            use_default_answer=use_default_answer,
         )
 
     rule_evaluator = RuleEvaluator(
+        value_source_resolver=_get_value_source_resolver(
+            list_item=location.list_item_id if location else None,
+            use_default_answer=True,
+            assess_routing_path=True,
+        ),
         schema=schema,
         data_stores=data_stores,
         location=location,
+        routing_path_block_ids=block_ids,
     )
 
     answer_fields = {}
     question_title = question.get("title")
 
-    value_source_resolved_for_location = _get_value_source_resolver(list_item_id)
+    value_source_resolved_for_location = _get_value_source_resolver(
+        list_item=list_item_id
+    )
     for answer in question.get("answers", []):
         if "list_item_id" in answer:
-            value_source_resolver = _get_value_source_resolver(answer["list_item_id"])
+            rule_evaluator.value_source_resolver = _get_value_source_resolver(
+                list_item=answer["list_item_id"]
+            )
         else:
-            value_source_resolver = value_source_resolved_for_location
+            rule_evaluator.value_source_resolver = value_source_resolved_for_location
 
         for option in answer.get("options", []):
             if "detail_answer" in option:
@@ -518,15 +533,13 @@ def _get_value_source_resolver(list_item: str | None = None) -> ValueSourceResol
 
                 answer_fields[option["detail_answer"]["id"]] = get_field_handler(
                     answer_schema=detail_answer,
-                    value_source_resolver=value_source_resolver,
                     rule_evaluator=rule_evaluator,
                     error_messages=schema.error_messages,
                     disable_validation=disable_validation,
                     question_title=question_title,
                 ).get_field()
         answer_fields[answer["id"]] = get_field_handler(
             answer_schema=answer,
-            value_source_resolver=value_source_resolver,
             rule_evaluator=rule_evaluator,
             error_messages=schema.error_messages,
             question_title=question_title,

app/questionnaire/path_finder.py

@@ -8,6 +8,7 @@
 from app.questionnaire.questionnaire_schema import QuestionnaireSchema
 from app.questionnaire.routing_path import RoutingPath
 from app.questionnaire.rules.rule_evaluator import RuleEvaluator, RuleEvaluatorTypes
+from app.questionnaire.value_source_resolver import ValueSourceResolver
 from app.utilities.types import LocationType
 
 
@@ -181,10 +182,18 @@ def _evaluate_routing_rules(
         )
 
         when_rule_evaluator = RuleEvaluator(
-            self.schema,
-            self.data_stores,
+            schema=self.schema,
+            data_stores=self.data_stores,
             location=this_location,
             routing_path_block_ids=block_ids_for_dependencies,
+            value_source_resolver=ValueSourceResolver(
+                list_item_id=this_location.list_item_id if this_location else None,
+                schema=self.schema,
+                data_stores=self.data_stores,
+                location=this_location,
+                routing_path_block_ids=block_ids_for_dependencies,
+                use_default_answer=True,
+            ),
         )
         for rule in routing_rules:
             rule_valid = (
@@ -223,7 +232,7 @@ def evaluate_skip_conditions(
     ) -> RuleEvaluatorTypes:
         if not skip_conditions:
             return False
-
+        list_item_id = current_location.list_item_id if current_location else None
         block_ids_for_dependencies = (
             list(routing_path_block_ids) + when_rules_block_dependencies
         )
@@ -233,6 +242,14 @@ def evaluate_skip_conditions(
             data_stores=self.data_stores,
             location=current_location,
             routing_path_block_ids=block_ids_for_dependencies,
+            value_source_resolver=ValueSourceResolver(
+                list_item_id=list_item_id,
+                schema=self.schema,
+                data_stores=self.data_stores,
+                routing_path_block_ids=block_ids_for_dependencies,
+                location=current_location,
+                use_default_answer=True,
+            ),
         )
 
         return when_rule_evaluator.evaluate(skip_conditions["when"])

app/questionnaire/placeholder_parser.py

@@ -31,15 +31,13 @@
 from app.utilities.mappings import get_flattened_mapping_values, get_values_for_key
 from app.utilities.types import LocationType, SectionKey
 
+TransformedValueTypes: TypeAlias = None | str | int | Decimal | bool
 if TYPE_CHECKING:
     from app.questionnaire.placeholder_renderer import (  # pragma: no cover
         PlaceholderRenderer,
     )
 
 
-TransformedValueTypes: TypeAlias = None | str | int | Decimal | bool
-
-
 class PlaceholderParser:
     """
     Parses placeholder statements from a schema dict and returns a map of their
@@ -51,7 +49,7 @@ def __init__(
         language: str,
         data_stores: DataStores,
         schema: QuestionnaireSchema,
-        renderer: PlaceholderRenderer,
+        renderer: "PlaceholderRenderer",
         list_item_id: str | None = None,
         location: LocationType | None = None,
         placeholder_preview_mode: bool | None = False,

app/questionnaire/router.py

@@ -10,6 +10,7 @@
 from app.questionnaire.return_location import ReturnLocation
 from app.questionnaire.routing_path import RoutingPath
 from app.questionnaire.rules.rule_evaluator import RuleEvaluator
+from app.questionnaire.value_source_resolver import ValueSourceResolver
 from app.utilities.types import LocationType
 
 
@@ -535,16 +536,23 @@ def _is_section_enabled(self, section: Mapping) -> bool:
 
         enabled = section["enabled"]
         section_id = section["id"]
-
+        location = Location(section_id=section_id)
         routing_path_block_ids = self._path_finder.get_when_rules_block_dependencies(
             section_id
         )
-
+        list_item_id = location.list_item_id if location else None
         when_rule_evaluator = RuleEvaluator(
             data_stores=self._data_stores,
             schema=self._schema,
-            location=Location(section_id=section_id),
+            location=location,
             routing_path_block_ids=routing_path_block_ids,
+            value_source_resolver=ValueSourceResolver(
+                data_stores=self._data_stores,
+                schema=self._schema,
+                location=location,
+                list_item_id=list_item_id,
+                routing_path_block_ids=routing_path_block_ids,
+            ),
         )
 
         return bool(when_rule_evaluator.evaluate(enabled["when"]))

app/questionnaire/rules/rule_evaluator.py

@@ -1,46 +1,41 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from datetime import date
 from decimal import Decimal
-from typing import Generator, Iterable, Sequence, TypeAlias
+from typing import TYPE_CHECKING, Generator, Iterable, Sequence, TypeAlias, Union
 
 from app.data_models.data_stores import DataStores
 from app.questionnaire import QuestionnaireSchema
 from app.questionnaire.placeholder_renderer import PlaceholderRenderer
 from app.questionnaire.questionnaire_schema import DEFAULT_LANGUAGE_CODE
 from app.questionnaire.rules.operations import Operations
 from app.questionnaire.rules.operator import Operator
-from app.questionnaire.value_source_resolver import (
-    ValueSourceResolver,
-    ValueSourceTypes,
-)
 from app.utilities.types import LocationType
 
-RuleEvaluatorTypes: TypeAlias = (
-    bool | date | list[str] | list[date] | int | float | Decimal | None
-)
-ResolvedOperand: TypeAlias = bool | date | ValueSourceTypes | None
+if TYPE_CHECKING:
+    from app.questionnaire.value_source_resolver import (  # pragma: no cover
+        ValueSourceResolver,
+        ValueSourceTypes,
+    )
+
+RuleEvaluatorTypes: TypeAlias = Union[
+    bool, date, list[str], list[date], int, float, Decimal, None
+]
+ResolvedOperand: TypeAlias = Union[bool, date, "ValueSourceTypes", None]
 
 
 @dataclass
 class RuleEvaluator:
     schema: QuestionnaireSchema
     data_stores: DataStores
     location: LocationType | None
+    value_source_resolver: "ValueSourceResolver"
     routing_path_block_ids: Iterable[str] | None = None
     language: str = DEFAULT_LANGUAGE_CODE
 
     # pylint: disable=attribute-defined-outside-init
     def __post_init__(self) -> None:
-        list_item_id = self.location.list_item_id if self.location else None
-        self.value_source_resolver = ValueSourceResolver(
-            data_stores=self.data_stores,
-            schema=self.schema,
-            location=self.location,
-            list_item_id=list_item_id,
-            routing_path_block_ids=self.routing_path_block_ids,
-            use_default_answer=True,
-        )
-
         renderer: PlaceholderRenderer = PlaceholderRenderer(
             language=self.language,
             data_stores=self.data_stores,
@@ -71,7 +66,7 @@ def _evaluate(self, rule: dict[str, Sequence]) -> bool | date | None:
 
         return operator.evaluate(resolved_operands)
 
-    def _resolve_operand(self, operand: ValueSourceTypes) -> ResolvedOperand:
+    def _resolve_operand(self, operand: "ValueSourceTypes") -> ResolvedOperand:
         if isinstance(operand, dict) and "source" in operand:
             return self.value_source_resolver.resolve(operand)
 
@@ -81,7 +76,7 @@ def _resolve_operand(self, operand: ValueSourceTypes) -> ResolvedOperand:
         return operand
 
     def get_resolved_operands(
-        self, operands: Sequence[ValueSourceTypes]
+        self, operands: Sequence["ValueSourceTypes"]
     ) -> Generator[ResolvedOperand, None, None]:
         for operand in operands:
             yield self._resolve_operand(operand)

app/questionnaire/value_source_resolver.py

@@ -272,6 +272,14 @@ def _resolve_summary_with_calculation(
             data_stores=self.data_stores,
             location=self.location,
             routing_path_block_ids=self.routing_path_block_ids,
+            value_source_resolver=ValueSourceResolver(
+                data_stores=self.data_stores,
+                schema=self.schema,
+                location=self.location,
+                list_item_id=self.list_item_id,
+                routing_path_block_ids=self.routing_path_block_ids,
+                use_default_answer=True,
+            ),
         )
 
         return evaluator.evaluate(calculation["operation"])  # type: ignore

app/questionnaire/variants.py

@@ -5,6 +5,7 @@
 from app.data_models.data_stores import DataStores
 from app.questionnaire.questionnaire_schema import QuestionnaireSchema
 from app.questionnaire.rules.rule_evaluator import RuleEvaluator
+from app.questionnaire.value_source_resolver import ValueSourceResolver
 from app.utilities.types import LocationType
 
 
@@ -22,11 +23,17 @@ def choose_variant(  # type: ignore
         return block[single_key]  # type: ignore
     for variant in block.get(variants_key, []):
         when_rules = variant["when"]
-
         when_rule_evaluator = RuleEvaluator(
             schema,
             data_stores=data_stores,
             location=current_location,
+            value_source_resolver=ValueSourceResolver(
+                data_stores=data_stores,
+                schema=schema,
+                location=current_location,
+                use_default_answer=True,
+                list_item_id=current_location.list_item_id,
+            ),
         )
 
         if when_rule_evaluator.evaluate(when_rules):

app/views/contexts/calculated_summary_context.py

@@ -222,6 +222,18 @@ def _get_evaluated_total(
         For a calculation in the new style and the list of involved block ids (possibly across sections) evaluate the total
         """
         evaluate_calculated_summary = RuleEvaluator(
+            value_source_resolver=ValueSourceResolver(
+                schema=self._schema,
+                data_stores=self._data_stores,
+                routing_path_block_ids=routing_path_block_ids,
+                location=self.current_location,
+                list_item_id=(
+                    self.current_location.list_item_id
+                    if self.current_location
+                    else None
+                ),
+                use_default_answer=True,
+            ),
             data_stores=self._data_stores,
             schema=self._schema,
             routing_path_block_ids=routing_path_block_ids,