Create a new column in serology mapping table that has the lgx version of the allele list lgx_allele_list

Author: pbashyal-nmdp

pyard/ard.py

@@ -123,6 +123,9 @@ def __init__(
         dr.generate_serology_mapping(
             self.db_connection, self.serology_mapping, imgt_version
         )
+        dr.generate_serology_mapping(
+            self.db_connection, imgt_version, self.serology_mapping, self._redux_allele
+        )
         # Load V2 to V3 mappings
         dr.generate_v2_to_v3_mapping(self.db_connection, imgt_version)
         # Save IMGT database version
@@ -271,6 +274,11 @@ def _redux_allele(
                 return self._redux_allele(allele, "lgx")
         elif redux_type == "S":
             # find serology equivalent in serology_mapping
+            if is_2_field_allele(allele):
+                serology_mapping = db.find_serology_for_allele(
+                    self.db_connection,
+                    allele,
+                )
             serology_mapping = db.find_serology_for_allele(self.db_connection, allele)
             serology_set = set()
             for serology, allele_list in serology_mapping.items():

pyard/data_repository.py

@@ -356,7 +356,7 @@ def to_serological_name(locus_name: str):
 
 
 def generate_serology_mapping(
-    db_connection: sqlite3.Connection, serology_mapping, imgt_version
+    db_connection: sqlite3.Connection, imgt_version, serology_mapping, redux_function
 ):
     if not db.table_exists(db_connection, "serology_mapping"):
         df_sero = load_serology_mappings(imgt_version)
@@ -390,10 +390,12 @@ def generate_serology_mapping(
         sero_mapping_combined["Sero"] = sero_mapping_combined["Sero"].apply(
             to_serological_name
         )
-
+        sero_mapping_combined["lgx"] = sero_mapping_combined["Allele"].apply(
+            lambda allele: redux_function(allele, "lgx")
+        )
         sero_mapping = (
             sero_mapping_combined.groupby("Sero")
-            .apply(lambda x: "/".join(sorted(x["Allele"])))
+            .apply(lambda x: (set(x["Allele"]), set(x["lgx"])))
             .to_dict()
         )
 
@@ -402,20 +404,29 @@ def generate_serology_mapping(
         for broad, splits in serology_mapping.broad_splits_map.items():
             for split in splits:
                 try:
-                    sero_mapping[broad] = "/".join(
-                        [sero_mapping[broad], sero_mapping[split]]
+                    sero_mapping[broad] = (
+                        sero_mapping[broad][0].union(sero_mapping[split][0]),
+                        sero_mapping[broad][1].union(sero_mapping[split][1]),
                     )
                 except KeyError:
                     if split in sero_mapping:
                         sero_mapping[broad] = sero_mapping[split]
 
         # re-sort allele lists into smartsort order
         for sero in sero_mapping.keys():
-            sero_mapping[sero] = "/".join(
-                sorted(
-                    sero_mapping[sero].split("/"),
-                    key=functools.cmp_to_key(smart_sort_comparator),
-                )
+            sero_mapping[sero] = (
+                "/".join(
+                    sorted(
+                        sero_mapping[sero][0],
+                        key=functools.cmp_to_key(smart_sort_comparator),
+                    )
+                ),
+                "/".join(
+                    sorted(
+                        sero_mapping[sero][1],
+                        key=functools.cmp_to_key(smart_sort_comparator),
+                    ),
+                ),
             )
 
         db.save_serology_mappings(db_connection, sero_mapping)

pyard/db.py

@@ -393,18 +393,17 @@ def similar_mac(connection: sqlite3.Connection, mac_prefix: str) -> Set[str]:
 
 
 def find_serology_for_allele(
-    connection: sqlite3.Connection, allele_name: str
+    connection: sqlite3.Connection, allele_name: str, column: str = "allele_list"
 ) -> Dict[str, str]:
     """
     Find similar alleles starting with the provided allele_name.
 
     :param connection: db connection of type sqlite.Connection
     :param allele_name: Allele name to use as a prefix to find similar alleles
+    :param column: Column to look for allele
     :return: list of similar alleles
     """
-    query = (
-        "SELECT serology, allele_list FROM serology_mapping WHERE allele_list LIKE ?"
-    )
+    query = f"SELECT serology, {column} FROM serology_mapping WHERE {column} LIKE ?"
     cursor = connection.execute(query, (f"%{allele_name}%",))
     results = cursor.fetchall()
     # fetchall() returns a list of tuples of results
@@ -574,12 +573,26 @@ def save_mac_codes(db_connection, mac, mac_table_name):
 
 def save_serology_mappings(db_connection, sero_mapping):
     # Save the serology mapping to db
-    save_dict(
-        db_connection,
-        table_name="serology_mapping",
-        dictionary=sero_mapping,
-        columns=("serology", "allele_list"),
-    )
+    cursor = db_connection.cursor()
+    # Drop the table first
+    cursor.execute("DROP TABLE IF EXISTS serology_mapping")
+    # Create table
+    create_table_sql = f"""CREATE TABLE serology_mapping (
+                            serology TEXT PRIMARY KEY,
+                            allele_list TEXT NOT NULL,
+                            lgx_allele_list TEXT NOT NULL
+                    )"""
+    cursor.execute(create_table_sql)
+
+    rows = ((k, v[0], v[1]) for k, v in sero_mapping.items())
+
+    # insert
+    cursor.executemany(f"INSERT INTO serology_mapping VALUES (?, ?, ?)", rows)
+
+    # commit transaction - writes to the db
+    db_connection.commit()
+    # close the cursor
+    cursor.close()
 
 
 def load_v2_v3_mappings(db_connection):