Closes #9.

Author: Richard Liang

src/hla_algorithm/hla_algorithm.py

@@ -23,8 +23,10 @@
     BIN2NUC,
     HLA_LOCUS,
     StoredHLAStandards,
+    allele_coordinates_sort_key,
     count_strict_mismatches,
     nuc2bin,
+    sort_allele_pairs,
 )
 
 DATE_FORMAT = "%a %b %d %H:%M:%S %Z %Y"
@@ -277,7 +279,13 @@ def combine_standards_stepper(
                 # that looks like what you get when you sequence HLA.
                 std_bin = np.array(std_b.sequence) | np.array(std_a.sequence)
                 allele_pair: tuple[str, str] = cast(
-                    tuple[str, str], tuple(sorted((std_a.allele, std_b.allele)))
+                    tuple[str, str],
+                    tuple(
+                        sorted(
+                            (std_a.allele, std_b.allele),
+                            key=allele_coordinates_sort_key,
+                        )
+                    ),
                 )
 
                 # There could be more than one combined standard with the
@@ -363,7 +371,7 @@ def combine_standards(
             if mismatch_count <= cutoff:
                 combined_std: HLACombinedStandard = HLACombinedStandard(
                     standard_bin=combined_std_bin,
-                    possible_allele_pairs=tuple(sorted(pair_list)),
+                    possible_allele_pairs=tuple(sort_allele_pairs(pair_list)),
                 )
                 result[combined_std] = mismatch_count
 

src/hla_algorithm/interpret_from_json_lib.py

@@ -18,6 +18,7 @@
     check_bases,
     check_length,
     nuc2bin,
+    sort_allele_pairs,
 )
 
 
@@ -143,7 +144,7 @@ def build_from_interpretation(
 
         return HLAResult(
             seqs=seqs,
-            alleles_all=[f"{x[0]} - {x[1]}" for x in aps.sort_pairs()],
+            alleles_all=[f"{x[0]} - {x[1]}" for x in sort_allele_pairs(aps.allele_pairs)],
             alleles_clean=alleles_clean,
             alleles_for_mismatches=f"{rep_ap[0]} - {rep_ap[1]}",
             mismatches=[str(x) for x in match_details.mismatches],

src/hla_algorithm/models.py

@@ -10,10 +10,10 @@
     HLA_LOCUS,
     HLARawStandard,
     allele_coordinates,
-    allele_coordinates_sort_key,
     bin2nuc,
     count_forgiving_mismatches,
     nuc2bin,
+    sort_allele_pairs,
 )
 
 
@@ -389,20 +389,6 @@ def best_common_allele_pair_str(
         clean_allele_pair_str: str = " - ".join(clean_allele)
         return (clean_allele_pair_str, set(unambiguous_aps.allele_pairs))
 
-    def sort_pairs(self) -> list[tuple[str, str]]:
-        """
-        Sort the pairs according to "coordinate order".
-
-        If there's a tie, a last letter is used to attempt to break the tie.
-        """
-        return sorted(
-            self.allele_pairs,
-            key=lambda pair: (
-                allele_coordinates_sort_key(pair[0]),
-                allele_coordinates_sort_key(pair[1]),
-            ),
-        )
-
     def stringify(self, sorted=True, max_length: int = 3900) -> str:
         """
         Produce a final outputtable string.
@@ -415,7 +401,7 @@ def stringify(self, sorted=True, max_length: int = 3900) -> str:
         """
         allele_pairs: list[tuple[str, str]] = self.allele_pairs
         if sorted:
-            allele_pairs = self.sort_pairs()
+            allele_pairs = sort_allele_pairs(self.allele_pairs)
         summary_str: str = ";".join([f"{_a[0]} - {_a[1]}" for _a in allele_pairs])
         if len(summary_str) > max_length:
             summary_str = re.sub(
@@ -441,7 +427,7 @@ def get_allele_pairs(
         all_allele_pairs: list[tuple[str, str]] = []
         for combined_std in combined_standards:
             all_allele_pairs.extend(combined_std.possible_allele_pairs)
-        all_allele_pairs.sort()
+        all_allele_pairs = sort_allele_pairs(all_allele_pairs)
         return cls(allele_pairs=all_allele_pairs)
 
     def contains_allele(self, allele_name: str) -> bool:

src/hla_algorithm/utils.py

@@ -368,6 +368,28 @@ def allele_coordinates_sort_key(allele: str) -> tuple[tuple[int, ...], str]:
     return (integer_part, letters_at_end)
 
 
+def allele_pair_sort_key(pair: tuple[str, str]) -> tuple[
+    tuple[int, ...], str, tuple[int, ...], str
+]:
+    """
+    Produce a sortable key for an allele pair.
+
+    Pairs should be sorted according to "coordinate order".
+    If there's a tie, a last letter is used to attempt to break the tie.
+    """
+    return (
+        allele_coordinates_sort_key(pair[0])
+        + allele_coordinates_sort_key(pair[1])
+    )
+
+
+def sort_allele_pairs(allele_pairs: Iterable[tuple[str, str]]) -> list[tuple[str, str]]:
+    """
+    Sort the pairs according to "coordinate order".
+    """
+    return sorted(allele_pairs, key=allele_pair_sort_key)
+
+
 class HLARawStandard(BaseModel):
     allele: str
     exon2: str