ELI-351: Renames rules model to campaign_config

Author: shweta-nhs

src/eligibility_signposting_api/audit/audit_context.py

@@ -18,14 +18,20 @@
     RequestAuditQueryParams,
 )
 from eligibility_signposting_api.audit.audit_service import AuditService
+from eligibility_signposting_api.model.campaign_config import (
+    CampaignID,
+    CampaignVersion,
+    Iteration,
+    RuleName,
+    RulePriority,
+)
 from eligibility_signposting_api.model.eligibility_status import (
     CohortGroupResult,
     ConditionName,
     IterationResult,
     Status,
     SuggestedAction,
 )
-from eligibility_signposting_api.model.rules import CampaignID, CampaignVersion, Iteration, RuleName, RulePriority
 
 logger = logging.getLogger(__name__)
 

…igibility_signposting_api/model/rules.py …signposting_api/model/campaign_config.pysrc/eligibility_signposting_api/model/rules.py renamed to src/eligibility_signposting_api/model/campaign_config.py src/eligibility_signposting_api/model/rules.py renamed to src/eligibility_signposting_api/model/campaign_config.py

@@ -5,7 +5,7 @@
 from botocore.client import BaseClient
 from wireup import Inject, service
 
-from eligibility_signposting_api.model.rules import CampaignConfig, Rules
+from eligibility_signposting_api.model.campaign_config import CampaignConfig, Rules
 
 BucketName = NewType("BucketName", str)
 

src/eligibility_signposting_api/repos/campaign_repo.py

@@ -5,28 +5,24 @@
 from collections.abc import Collection, Iterable, Iterator, Mapping
 from dataclasses import dataclass, field
 from itertools import groupby
-from typing import TYPE_CHECKING, Any
-
-from eligibility_signposting_api.audit.audit_context import AuditContext
-from eligibility_signposting_api.services.processors.campaign_evaluator import CampaignEvaluator
-from eligibility_signposting_api.services.processors.person_data_reader import PersonDataReader
-
-if TYPE_CHECKING:
-    from eligibility_signposting_api.model.rules import (
-        ActionsMapper,
-        CampaignConfig,
-        CampaignID,
-        CampaignVersion,
-        Iteration,
-        IterationCohort,
-        RuleName,
-        RulePriority,
-        RuleType,
-    )
+from typing import Any
 
 from wireup import service
 
-from eligibility_signposting_api.model import eligibility_status, rules
+from eligibility_signposting_api.audit.audit_context import AuditContext
+from eligibility_signposting_api.model import eligibility_status
+from eligibility_signposting_api.model.campaign_config import (
+    ActionsMapper,
+    CampaignConfig,
+    CampaignID,
+    CampaignVersion,
+    Iteration,
+    IterationCohort,
+    IterationRule,
+    RuleName,
+    RulePriority,
+    RuleType,
+)
 from eligibility_signposting_api.model.eligibility_status import (
     ActionCode,
     ActionDescription,
@@ -44,21 +40,23 @@
 from eligibility_signposting_api.services.calculators.rule_calculator import (
     RuleCalculator,
 )
+from eligibility_signposting_api.services.processors.campaign_evaluator import CampaignEvaluator
+from eligibility_signposting_api.services.processors.person_data_reader import PersonDataReader
 
 Row = Collection[Mapping[str, Any]]
 
 
 @service
 class EligibilityCalculatorFactory:
     @staticmethod
-    def get(person_data: Row, campaign_configs: Collection[rules.CampaignConfig]) -> EligibilityCalculator:
+    def get(person_data: Row, campaign_configs: Collection[CampaignConfig]) -> EligibilityCalculator:
         return EligibilityCalculator(person_data=person_data, campaign_configs=campaign_configs)
 
 
 @dataclass
 class EligibilityCalculator:
     person_data: Row
-    campaign_configs: Collection[rules.CampaignConfig]
+    campaign_configs: Collection[CampaignConfig]
 
     campaign_evaluator: CampaignEvaluator = field(default_factory=CampaignEvaluator)
     person_data_reader: PersonDataReader = field(default_factory=PersonDataReader)
@@ -89,9 +87,7 @@ def get_the_best_cohort_memberships(
         return best_status, best_cohorts
 
     @staticmethod
-    def get_exclusion_rules(
-        cohort: IterationCohort, filter_rules: Iterable[rules.IterationRule]
-    ) -> Iterator[rules.IterationRule]:
+    def get_exclusion_rules(cohort: IterationCohort, filter_rules: Iterable[IterationRule]) -> Iterator[IterationRule]:
         return (
             ir
             for ir in filter_rules
@@ -103,23 +99,23 @@ def get_exclusion_rules(
     @staticmethod
     def get_rules_by_type(
         active_iteration: Iteration,
-    ) -> tuple[tuple[rules.IterationRule, ...], tuple[rules.IterationRule, ...]]:
+    ) -> tuple[tuple[IterationRule, ...], tuple[IterationRule, ...]]:
         filter_rules, suppression_rules = (
             tuple(rule for rule in active_iteration.iteration_rules if attrgetter("type")(rule) == rule_type)
-            for rule_type in (rules.RuleType.filter, rules.RuleType.suppression)
+            for rule_type in (RuleType.filter, RuleType.suppression)
         )
         return filter_rules, suppression_rules
 
     @staticmethod
     def get_action_rules_components(
         active_iteration: Iteration, rule_type: RuleType
-    ) -> tuple[tuple[rules.IterationRule, ...], ActionsMapper, str | None]:
+    ) -> tuple[tuple[IterationRule, ...], ActionsMapper, str | None]:
         action_rules = tuple(rule for rule in active_iteration.iteration_rules if rule.type in rule_type)
 
         routing_map = {
-            rules.RuleType.redirect: active_iteration.default_comms_routing,
-            rules.RuleType.not_eligible_actions: active_iteration.default_not_eligible_routing,
-            rules.RuleType.not_actionable_actions: active_iteration.default_not_actionable_routing,
+            RuleType.redirect: active_iteration.default_comms_routing,
+            RuleType.not_eligible_actions: active_iteration.default_not_eligible_routing,
+            RuleType.not_actionable_actions: active_iteration.default_not_actionable_routing,
         }
 
         default_comms = routing_map.get(rule_type)
@@ -168,9 +164,9 @@ def evaluate_eligibility(
             condition_results[condition_name] = best_candidate
 
             status_to_rule_type = {
-                Status.actionable: rules.RuleType.redirect,
-                Status.not_eligible: rules.RuleType.not_eligible_actions,
-                Status.not_actionable: rules.RuleType.not_actionable_actions,
+                Status.actionable: RuleType.redirect,
+                Status.not_eligible: RuleType.not_eligible_actions,
+                Status.not_actionable: RuleType.not_actionable_actions,
             }
 
             if best_candidate.status in status_to_rule_type and best_active_iteration is not None:
@@ -257,7 +253,7 @@ def handle_action_rules(
 
         return actions, matched_action_rule_priority, matched_action_rule_name
 
-    def get_cohort_results(self, active_iteration: rules.Iteration) -> dict[str, CohortGroupResult]:
+    def get_cohort_results(self, active_iteration: Iteration) -> dict[str, CohortGroupResult]:
         cohort_results: dict[str, CohortGroupResult] = {}
         filter_rules, suppression_rules = self.get_rules_by_type(active_iteration)
         for cohort in sorted(active_iteration.iteration_cohorts, key=attrgetter("priority")):
@@ -322,7 +318,7 @@ def is_eligible_by_filter_rules(
         self,
         cohort: IterationCohort,
         cohort_results: dict[str, CohortGroupResult],
-        filter_rules: Iterable[rules.IterationRule],
+        filter_rules: Iterable[IterationRule],
     ) -> bool:
         is_eligible = True
         priority_getter = attrgetter("priority")
@@ -347,7 +343,7 @@ def evaluate_suppression_rules(
         self,
         cohort: IterationCohort,
         cohort_results: dict[str, CohortGroupResult],
-        suppression_rules: Iterable[rules.IterationRule],
+        suppression_rules: Iterable[IterationRule],
     ) -> None:
         is_actionable: bool = True
         priority_getter = attrgetter("priority")
@@ -379,7 +375,7 @@ def evaluate_suppression_rules(
                 )
 
     def evaluate_rules_priority_group(
-        self, rules_group: Iterator[rules.IterationRule]
+        self, rules_group: Iterator[IterationRule]
     ) -> tuple[eligibility_status.Status, list[eligibility_status.Reason], bool]:
         is_rule_stop = False
         exclusion_reasons = []

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -6,7 +6,8 @@
 
 from hamcrest.core.string_description import StringDescription
 
-from eligibility_signposting_api.model import eligibility_status, rules
+from eligibility_signposting_api.model import eligibility_status
+from eligibility_signposting_api.model.campaign_config import IterationRule, RuleAttributeLevel, RuleType
 from eligibility_signposting_api.services.operators.operators import OperatorRegistry
 from eligibility_signposting_api.services.processors.person_data_reader import PersonDataReader
 
@@ -16,7 +17,7 @@
 @dataclass
 class RuleCalculator:
     person_data: Row
-    rule: rules.IterationRule
+    rule: IterationRule
 
     person_data_reader: PersonDataReader = field(default_factory=PersonDataReader)
 
@@ -36,12 +37,12 @@ def evaluate_exclusion(self) -> tuple[eligibility_status.Status, eligibility_sta
     def get_attribute_value(self) -> str | None:
         """Pull out the correct attribute for a rule from the person's data."""
         match self.rule.attribute_level:
-            case rules.RuleAttributeLevel.PERSON:
+            case RuleAttributeLevel.PERSON:
                 person: Mapping[str, str | None] | None = next(
                     (r for r in self.person_data if r.get("ATTRIBUTE_TYPE", "") == "PERSON"), None
                 )
                 attribute_value = person.get(str(self.rule.attribute_name)) if person else None
-            case rules.RuleAttributeLevel.COHORT:
+            case RuleAttributeLevel.COHORT:
                 cohorts: Mapping[str, str | None] | None = next(
                     (r for r in self.person_data if r.get("ATTRIBUTE_TYPE", "") == "COHORTS"), None
                 )
@@ -51,7 +52,7 @@ def get_attribute_value(self) -> str | None:
                 else:
                     attribute_value = None
 
-            case rules.RuleAttributeLevel.TARGET:
+            case RuleAttributeLevel.TARGET:
                 target: Mapping[str, str | None] | None = next(
                     (r for r in self.person_data if r.get("ATTRIBUTE_TYPE", "") == self.rule.attribute_target), None
                 )
@@ -71,11 +72,11 @@ def evaluate_rule(self, attribute_value: str | None) -> tuple[eligibility_status
         if matcher_matched:
             matcher.describe_match(attribute_value, reason)
             status = {
-                rules.RuleType.filter: eligibility_status.Status.not_eligible,
-                rules.RuleType.suppression: eligibility_status.Status.not_actionable,
-                rules.RuleType.redirect: eligibility_status.Status.actionable,
-                rules.RuleType.not_eligible_actions: eligibility_status.Status.not_eligible,
-                rules.RuleType.not_actionable_actions: eligibility_status.Status.not_actionable,
+                RuleType.filter: eligibility_status.Status.not_eligible,
+                RuleType.suppression: eligibility_status.Status.not_actionable,
+                RuleType.redirect: eligibility_status.Status.actionable,
+                RuleType.not_eligible_actions: eligibility_status.Status.not_eligible,
+                RuleType.not_actionable_actions: eligibility_status.Status.not_actionable,
             }[self.rule.type]
             return status, str(reason), matcher_matched
         matcher.describe_mismatch(attribute_value, reason)

src/eligibility_signposting_api/services/calculators/rule_calculator.py

@@ -11,7 +11,7 @@
 from hamcrest.core.base_matcher import BaseMatcher
 from hamcrest.core.description import Description
 
-from eligibility_signposting_api.model.rules import RuleOperator
+from eligibility_signposting_api.model.campaign_config import RuleOperator
 
 logger = logging.getLogger(__name__)
 

src/eligibility_signposting_api/services/operators/operators.py

@@ -4,19 +4,20 @@
 
 from wireup import service
 
-from eligibility_signposting_api.model import eligibility_status, rules
+from eligibility_signposting_api.model import eligibility_status
+from eligibility_signposting_api.model.campaign_config import CampaignConfig
 
 
 @service
 class CampaignEvaluator:
     """Filters and groups campaign configurations."""
 
-    def get_active_campaigns(self, campaign_configs: Collection[rules.CampaignConfig]) -> list[rules.CampaignConfig]:
+    def get_active_campaigns(self, campaign_configs: Collection[CampaignConfig]) -> list[CampaignConfig]:
         return [cc for cc in campaign_configs if cc.campaign_live]
 
     def get_requested_grouped_campaigns(
-        self, campaign_configs: Collection[rules.CampaignConfig], conditions: list[str], category: str
-    ) -> Iterator[tuple[eligibility_status.ConditionName, list[rules.CampaignConfig]]]:
+        self, campaign_configs: Collection[CampaignConfig], conditions: list[str], category: str
+    ) -> Iterator[tuple[eligibility_status.ConditionName, list[CampaignConfig]]]:
         mapping = {
             "ALL": {"V", "S"},
             "VACCINATIONS": {"V"},