Rename score to hla_compatibility_score in compatibility_graph

tests/database/services/test_file_upload.py

@@ -148,7 +148,7 @@ def test_saving_patients_from_obfuscated_excel(self):
             for recipient_enum, recipient, expected_score in zip(
                     recipient_enums, txm_event.active_and_valid_recipients_dict.values(), expected_score_row):
                 if expected_score >= 0:
-                    calculated_score = calculated_scores[(donor_enum, recipient_enum)]["score"]
+                    calculated_score = calculated_scores[(donor_enum, recipient_enum)]["hla_compatibility_score"]
                     self.assertEqual(expected_score, calculated_score,
                                      f'Not true for expected {expected_score} vs real {calculated_score} '
                                      f'{[code.raw_code for code in donor.parameters.hla_typing.hla_types_raw_list]} and '

tests/solvers/all_solutions_solver/test_solver_from_compatibility_graph.py

@@ -48,8 +48,9 @@ def test_solve(self):
         )
         all_scores = []
         for solution in all_solutions:
-            solution_score = sum([scorer.score_transplant_ij(pair.donor_idx, pair.recipient_idx)['score']
-                                  for pair in solution])
+            solution_score = sum(
+                [scorer.score_transplant_ij(pair.donor_idx, pair.recipient_idx)['hla_compatibility_score']
+                 for pair in solution])
             all_scores.append(solution_score)
         self.assertEqual(len(all_solutions[0]), 9)
         self.assertEqual(self._expected_max_score, max(all_scores))
@@ -89,7 +90,8 @@ def test_handling_correctly_multiple_donors_with_the_same_recipient(self):
 
         original_donor_idx_to_recipient_idx = {0: 0, 1: 0, 2: 1, 3: 2}
 
-        compatibility_graph_test = {(0, 1): {"score": 11}, (1, 2): {"score": 10}, (2, 0): {"score": 10}, (3, 0): {"score": 10}}
+        compatibility_graph_test = {(0, 1): {"hla_compatibility_score": 11}, (1, 2): {"hla_compatibility_score": 10},
+                                    (2, 0): {"hla_compatibility_score": 10}, (3, 0): {"hla_compatibility_score": 10}}
 
         solutions = list(find_optimal_paths(
             compatibility_graph_test,
@@ -125,7 +127,7 @@ def test_handling_correctly_multiple_donors_with_the_same_recipient_at_the_end_o
 
         original_donor_idx_to_recipient_idx = {0: 0, 1: 0, 2: -1}
 
-        compatibility_graph_test = {(2, 0): {"score": 15}}
+        compatibility_graph_test = {(2, 0): {"hla_compatibility_score": 15}}
 
         solutions = list(find_optimal_paths(
             compatibility_graph_test,
@@ -146,15 +148,14 @@ def test_handling_correctly_multiple_donors_with_the_same_recipient_at_the_end_o
 
         self.assertEqual(len(solutions), 1)
 
-
     def test_works_with_one_cycle_only(self):
         """
         This simple case with one sequence has to work and it had initially some issue, so we added this test.
         """
 
         original_donor_idx_to_recipient_idx = {0: -1, 1: 0}
 
-        compatibility_graph_test = {(0, 0): {'score': 0}}
+        compatibility_graph_test = {(0, 0): {'hla_compatibility_score': 0}}
 
         solutions = list(find_optimal_paths(
             compatibility_graph_test,
@@ -209,7 +210,7 @@ def _get_compatibility_graph_from_score_matrix(score_matrix: np.array) -> Compat
     for row_enum, row in enumerate(score_matrix):
         for score_enum, score in enumerate(row):
             if score >= 0:
-                compatibility_graph[(row_enum, score_enum)] = {"score": score}
+                compatibility_graph[(row_enum, score_enum)] = {"hla_compatibility_score": score}
     return compatibility_graph
 
 

txmatching/database/services/matching_service.py

@@ -67,9 +67,9 @@ def get_matchings_detailed_for_pairing_result_model(
                                                                              txm_event.active_and_valid_donors_dict,
                                                                              compatibility_graph)
 
-    number_of_possible_transplants = len([weights['score']
+    number_of_possible_transplants = len([weights['hla_compatibility_score']
                                           for weights in compatibility_graph_of_db_ids.values() if
-                                          weights["score"] >= 0])
+                                          weights["hla_compatibility_score"] >= 0])
 
     number_of_possible_recipients = len([
         recipient_db_id for recipient_db_id in txm_event.active_and_valid_recipients_dict.keys()
@@ -148,7 +148,8 @@ def _create_transplant_dto(pair: DonorRecipientPair):
         )
 
         return TransplantDTOOut(
-            score=latest_matchings_detailed.scores_tuples[(pair.donor.db_id, pair.recipient.db_id)]['score'],
+            score=latest_matchings_detailed.scores_tuples[(pair.donor.db_id, pair.recipient.db_id)][
+                'hla_compatibility_score'],
             max_score=latest_matchings_detailed.max_transplant_score,
             compatible_blood=latest_matchings_detailed.blood_compatibility_tuples[
                 (pair.donor.db_id, pair.recipient.db_id)],
@@ -246,5 +247,6 @@ def recipient_has_at_least_one_donor(score_dict, recipient_db_id, active_and_val
     """
     Returns true if the recipient has at least one donor, otherwise returns false.
     """
-    return sum(score_dict.get((item, recipient_db_id), -1)['score'] >= 0 for item in active_and_valid_donors_dict.keys()
+    return sum(score_dict.get((item, recipient_db_id), -1)['hla_compatibility_score'] >= 0 for item in
+               active_and_valid_donors_dict.keys()
                if isinstance(score_dict.get((item, recipient_db_id), -1), dict)) > 0

txmatching/database/services/scorer_service.py

@@ -14,12 +14,13 @@ class CompatibilityGraphDto:
 
 
 def compatibility_graph_to_dict(compatibility_graph: CompatibilityGraph) -> Dict[str, List[List[int]]]:
-    return {"compatibility_graph_dto": [[int(pair[0]), int(pair[1]), weighths["score"]]
+    return {"compatibility_graph_dto": [[int(pair[0]), int(pair[1]), weighths["hla_compatibility_score"]]
                                         for pair, weighths in compatibility_graph.items()]}
 
 
 def compatibility_graph_from_dict(compatibility_graph_dict: Dict[str, List[List[int]]]) -> CompatibilityGraph:
-    return {(pair[0], pair[1]): {"score": pair[2]} for pair in compatibility_graph_dict["compatibility_graph_dto"]}
+    return {(pair[0], pair[1]): {"hla_compatibility_score": pair[2]} for pair in
+            compatibility_graph_dict["compatibility_graph_dto"]}
 
 
 def matchings_model_from_dict(calculated_matchings_dict: Dict[str, any]) -> MatchingsModel:

txmatching/optimizer/optimizer_functions.py

@@ -262,7 +262,7 @@ def get_optimizer_configuration(config: ConfigParameters) -> OptimizerConfigurat
 
 def get_compatibility_graph_for_optimizer_api(donors_dict: Dict[DonorDbId, Donor],
                                               recipients_dict: Dict[
-                                              RecipientDbId, Recipient]) -> OptimizerCompatibilityGraph:
+                                                  RecipientDbId, Recipient]) -> OptimizerCompatibilityGraph:
     scorer = SplitScorer()
 
     compatibility_graph_from_scorer = scorer.get_compatibility_graph(recipients_dict, donors_dict)
@@ -275,7 +275,8 @@ def get_compatibility_graph_for_optimizer_api(donors_dict: Dict[DonorDbId, Donor
                     donor_id=donor_id,
                     recipient_id=recipient_id,
                     weights={
-                        "hla_compatibility_score": int(compatibility_graph_from_scorer[(i, j)]['score'])
+                        "hla_compatibility_score": int(
+                            compatibility_graph_from_scorer[(i, j)]['hla_compatibility_score'])
                     }
                 )
                 compatibility_graph.append(comp_graph_entry)

txmatching/scorers/additive_scorer.py

@@ -76,7 +76,7 @@ def get_compatibility_graph(self,
                                                                                         recipient.related_donors_db_ids
                                                                                         if donor_db_id in donors_dict])
                 if score >= 0:
-                    compatibility_graph[(donor_enum, recipient_enum)] = {"score": int(score)}
+                    compatibility_graph[(donor_enum, recipient_enum)] = {"hla_compatibility_score": int(score)}
 
         return compatibility_graph
 

txmatching/solvers/all_solutions_solver/scoring_utils.py

@@ -7,4 +7,4 @@
 
 def get_score_for_idx_pairs(compatibility_graph: CompatibilityGraph,
                             pairs: Iterable[DonorRecipientPairIdxOnly]):
-    return sum(compatibility_graph[(pair.donor_idx, pair.recipient_idx)]["score"] for pair in pairs)
+    return sum(compatibility_graph[(pair.donor_idx, pair.recipient_idx)]["hla_compatibility_score"] for pair in pairs)