wip-3

Author: Karthikeyannhs

src/eligibility_signposting_api/model/eligibility.py

@@ -71,14 +71,14 @@ class Condition:
     status: Status
     reasons: list[Reason]
 
+
 @dataclass
 class CohortStatus:
     cohort: rules.IterationCohort
     status: Status
     reasons: list[Reason]
 
 
-
 @dataclass
 class EligibilityStatus:
     """Represents a person's eligibility for vaccination."""

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-from _operator import attrgetter
+from _operator import add, attrgetter
 from collections import defaultdict
 from collections.abc import Collection, Iterator, Mapping
 from dataclasses import dataclass, field
-from functools import cached_property
+from functools import cached_property, reduce
 from itertools import groupby
 from typing import Any
 
 from wireup import service
 
 from eligibility_signposting_api.model import eligibility, rules
-from eligibility_signposting_api.model.eligibility import Status, CohortStatus, Condition, ConditionName
+from eligibility_signposting_api.model.eligibility import CohortStatus, Condition, ConditionName, Status
 from eligibility_signposting_api.services.calculators.rule_calculator import RuleCalculator
 
 Row = Collection[Mapping[str, Any]]
@@ -72,18 +72,15 @@ def evaluate_eligibility_back_up(self) -> eligibility.EligibilityStatus:
     from collections import defaultdict
 
     # Assuming cohort_results contains tuples of (IterationCohort, Status, list[Reason])
-    def get_best_cohort(
-        self, cohort_results: dict[str, CohortStatus]
-    ) -> tuple[Status, list[CohortStatus]]:
-
+    def get_best_cohort(self, cohort_results: dict[str, CohortStatus]) -> tuple[Status, list[CohortStatus]]:
         # Find the best status across cohorts
         best_status = eligibility.Status.best(*[result.status for result in cohort_results.values()])
 
         # Filter cohorts that match the best status
-        best_cohorts = [result for result in cohort_results.values() if result[1] == best_status]
+        best_cohorts = [result for result in cohort_results.values() if result.status == best_status]
         return best_status, best_cohorts
 
-    def evaluate_eligibility(self):
+    def evaluate_eligibility(self) -> eligibility.EligibilityStatus:
         """Iterates over campaign groups, evaluates eligibility, and returns a consolidated status."""
         priority_getter = attrgetter("priority")
         results: dict[ConditionName, tuple[Status, list[CohortStatus]]] = defaultdict()
@@ -132,23 +129,22 @@ def evaluate_eligibility(self):
                 # Determine Result between cohorts - get the best
                 iteration_results[active_iteration.name] = self.get_best_cohort(cohort_results)  # multiple
             # Determine results between iterations - get the best
-            best_so_far:Status = eligibility.Status.not_eligible
-            for name, iteration_result in iteration_results.items():
+            best_so_far: Status = eligibility.Status.not_eligible
+            for iteration_result in iteration_results.values():
                 best_so_far = eligibility.Status.best(best_so_far, iteration_result[0])
-            for name, iteration_result in iteration_results.items():
+            for iteration_result in iteration_results.values():
                 if iteration_result[0] is best_so_far:
                     results[condition_name] = iteration_result
-                    break # if the status is the same, we can break out of the loop - we are picking the first one
+                    break  # if the status is the same, we can break out of the loop - we are picking the first one
         # Consolidate all the results and return
         final_result = [
             Condition(
                 condition_name=condition_name,
                 status=status,
-                reasons=sum((cohort.reasons for cohort in cohort_status_list), [])
+                reasons=reduce(add, [cohort.reasons for cohort in cohort_status_list], []),
             )
             for condition_name, (status, cohort_status_list) in results.items()
         ]
-
         return eligibility.EligibilityStatus(conditions=final_result)
 
     def get_the_base_eligible_campaigns(self, campaign_group: list[rules.CampaignConfig]) -> list[rules.CampaignConfig]:
@@ -238,7 +234,7 @@ def evaluate_priority_group(
             is_rule_stop = any(rule.rule_stop for rule in exclude_capable_rules)
         return worst_group_status, actionable_reasons, exclusion_reasons, is_rule_stop
 
-    def evaluate_rules_priority_group(  # TODO refractor
+    def evaluate_rules_priority_group(
         self, iteration_rule_group: Iterator[rules.IterationRule]
     ) -> tuple[eligibility.Status, list[eligibility.Reason], list[eligibility.Reason]]:
         status = Status.not_eligible