Extract config

 - Instead of dictionary, create ARDConfig that encapsulates the configuration properties

Author: pbashyal-nmdp

pyard/__init__.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-
 #
 #    py-ard
 #    Copyright (c) 2023 Be The Match operated by National Marrow Donor Program. All Rights Reserved.
@@ -21,10 +20,11 @@
 #    > http://www.fsf.org/licensing/licenses/lgpl.html
 #    > http://www.opensource.org/licenses/lgpl-license.php
 #
-from .constants import DEFAULT_CACHE_SIZE
 
 # exports for `pyard`
 from .blender import blender as dr_blender
+from .config import ARDConfig
+from .constants import DEFAULT_CACHE_SIZE
 from .misc import get_imgt_db_versions as db_versions
 
 __author__ = """NMDP Bioinformatics"""

pyard/ard.py

@@ -26,21 +26,7 @@
 )
 from .misc import get_2field_allele, is_2_field_allele
 from .serology import SerologyMapping
-
-default_config = {
-    "reduce_serology": True,
-    "reduce_v2": True,
-    "reduce_3field": True,
-    "reduce_P": True,
-    "reduce_XX": True,
-    "reduce_MAC": True,
-    "reduce_shortnull": True,
-    "ping": True,
-    "verbose_log": False,
-    "ARS_as_lg": False,
-    "strict": True,
-    "ignore_allele_with_suffixes": (),
-}
+from .config import ARDConfig
 
 
 class ARD(object):
@@ -57,9 +43,7 @@ def __init__(
         config: dict = None,
     ):
         self._data_dir = data_dir
-        self._config = default_config.copy()
-        if config:
-            self._config.update(config)
+        self.config = ARDConfig.from_dict(config)
 
         # Initialize specialized handlers
         self._initialize_handlers()
@@ -160,15 +144,15 @@ def _redux_allele(
         self, allele: str, redux_type: VALID_REDUCTION_TYPE, re_ping=True
     ) -> str:
         """Core allele reduction with ping logic"""
-        if not self._config["strict"]:
+        if not self.config.strict:
             allele = self._get_non_strict_allele(allele)
 
         # Handle P/G suffixes
         if allele.endswith(("P", "G")) and redux_type in ["lg", "lgx", "G"]:
             allele = allele[:-1]
 
         # Handle ping mode
-        if self._config["ping"] and re_ping and redux_type in ("lg", "lgx", "U2"):
+        if self.config.ping and re_ping and redux_type in ("lg", "lgx", "U2"):
             if allele in self.ars_mappings.p_not_g:
                 not_g_allele = self.ars_mappings.p_not_g[allele]
                 if redux_type == "lg":
@@ -206,8 +190,8 @@ def _redux_non_glstring(
         if "*" in allele:
             locus, fields = allele.split("*")
             # Handle ignored allele suffixes
-            if self._config["ignore_allele_with_suffixes"]:
-                if fields in self._config["ignore_allele_with_suffixes"]:
+            if self.config.ignore_allele_with_suffixes:
+                if fields in self.config.ignore_allele_with_suffixes:
                     return allele
             if locus not in G_GROUP_LOCI:
                 return allele
@@ -218,9 +202,7 @@ def _redux_non_glstring(
             return self.redux(allele, redux_type)
 
         # Handle Serology
-        if self._config["reduce_serology"] and self.serology_handler.is_serology(
-            allele
-        ):
+        if self.config.reduce_serology and self.serology_handler.is_serology(allele):
             alleles = self.serology_handler.get_alleles_from_serology(allele)
             if alleles:
                 return self.redux("/".join(alleles), redux_type)
@@ -246,7 +228,7 @@ def _redux_non_glstring(
 
         # Handle XX codes
         if (
-            self._config["reduce_XX"]
+            self.config.reduce_XX
             and code == "XX"
             and self.xx_handler.is_xx(allele, loc_antigen, code)
         ):
@@ -256,17 +238,15 @@ def _redux_non_glstring(
             return reduced_alleles
 
         # Handle MAC
-        if self._config["reduce_MAC"] and code.isalpha():
+        if self.config.reduce_MAC and code.isalpha():
             if self.mac_handler.is_mac(allele):
                 alleles = self.mac_handler.get_alleles(code, loc_antigen)
                 return self.redux("/".join(alleles), redux_type)
             else:
                 raise InvalidMACError(f"{glstring} is an invalid MAC.")
 
         # Handle short nulls
-        if self._config["reduce_shortnull"] and self.shortnull_handler.is_shortnull(
-            allele
-        ):
+        if self.config.reduce_shortnull and self.shortnull_handler.is_shortnull(allele):
             return self.redux("/".join(self.shortnulls[allele]), redux_type)
 
         redux_allele = self._redux_allele(allele, redux_type)
@@ -349,7 +329,7 @@ def _get_non_strict_allele(self, allele: str) -> str:
         if not self._is_allele_in_db(allele):
             for expr_char in expression_chars:
                 if self._is_allele_in_db(allele + expr_char):
-                    if self._config["verbose_log"]:
+                    if self.config.verbose_log:
                         print(f"{allele} is not valid. Using {allele}{expr_char}")
                     allele = allele + expr_char
                     break
@@ -387,12 +367,12 @@ def _is_valid(self, allele: str) -> bool:
             if not alphanum_allele.isalnum():
                 return False
 
-            if self._config["ignore_allele_with_suffixes"]:
+            if self.config.ignore_allele_with_suffixes:
                 locus, fields = allele.split("*")
-                if fields in self._config["ignore_allele_with_suffixes"]:
+                if fields in self.config.ignore_allele_with_suffixes:
                     return True
 
-        if not self._config["strict"]:
+        if not self.config.strict:
             allele = self._get_non_strict_allele(allele)
 
         if (

pyard/config.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass
+class ARDConfig:
+    """Configuration class for ARD reduction settings"""
+
+    reduce_serology: bool = True
+    reduce_v2: bool = True
+    reduce_3field: bool = True
+    reduce_P: bool = True
+    reduce_XX: bool = True
+    reduce_MAC: bool = True
+    reduce_shortnull: bool = True
+    ping: bool = True
+    verbose_log: bool = False
+    ARS_as_lg: bool = False
+    strict: bool = True
+    ignore_allele_with_suffixes: Tuple[str, ...] = ()
+
+    @classmethod
+    def from_dict(cls, config_dict: dict) -> "ARDConfig":
+        """Create ARDConfig from dictionary"""
+        if not config_dict:
+            return cls()
+
+        # Filter only valid fields
+        valid_fields = {f.name for f in cls.__dataclass_fields__.values()}
+        filtered_config = {k: v for k, v in config_dict.items() if k in valid_fields}
+
+        return cls(**filtered_config)
+
+    def to_dict(self) -> dict:
+        """Convert ARDConfig to dictionary"""
+        return {
+            "reduce_serology": self.reduce_serology,
+            "reduce_v2": self.reduce_v2,
+            "reduce_3field": self.reduce_3field,
+            "reduce_P": self.reduce_P,
+            "reduce_XX": self.reduce_XX,
+            "reduce_MAC": self.reduce_MAC,
+            "reduce_shortnull": self.reduce_shortnull,
+            "ping": self.ping,
+            "verbose_log": self.verbose_log,
+            "ARS_as_lg": self.ARS_as_lg,
+            "strict": self.strict,
+            "ignore_allele_with_suffixes": self.ignore_allele_with_suffixes,
+        }
+
+    @property
+    def serology_enabled(self) -> bool:
+        return self.reduce_serology
+
+    @property
+    def v2_enabled(self) -> bool:
+        return self.reduce_v2
+
+    @property
+    def field3_enabled(self) -> bool:
+        return self.reduce_3field
+
+    @property
+    def p_enabled(self) -> bool:
+        return self.reduce_P
+
+    @property
+    def xx_enabled(self) -> bool:
+        return self.reduce_XX
+
+    @property
+    def mac_enabled(self) -> bool:
+        return self.reduce_MAC
+
+    @property
+    def shortnull_enabled(self) -> bool:
+        return self.reduce_shortnull
+
+    @property
+    def ping_enabled(self) -> bool:
+        return self.ping
+
+    @property
+    def verbose_enabled(self) -> bool:
+        return self.verbose_log
+
+    @property
+    def ars_as_lg_enabled(self) -> bool:
+        return self.ARS_as_lg
+
+    @property
+    def strict_enabled(self) -> bool:
+        return self.strict

pyard/handlers/allele_handler.py

@@ -68,6 +68,6 @@ def add_lg_suffix(self, redux_allele):
                 [self.add_lg_suffix(allele) for allele in redux_allele.split("/")]
             )
         # Use 'ARS' suffix if configured, otherwise use 'g' suffix
-        if self.ard._config["ARS_as_lg"]:
+        if self.ard.config.ars_as_lg_enabled:
             return redux_allele + "ARS"
         return redux_allele + "g"

pyard/handlers/gl_string_processor.py

@@ -50,7 +50,7 @@ def process_gl_string(
         validate_reduction_type(redux_type)
 
         # Validate GL string structure if strict mode is enabled
-        if self.ard._config["strict"]:
+        if self.ard.config.strict_enabled:
             self.validate_gl_string(glstring)
 
         # Handle GL string delimiters in order of precedence
@@ -115,7 +115,7 @@ def _sorted_unique_gl(self, gls: List[str], delim: str) -> str:
                     non_empty_gls,
                     key=functools.cmp_to_key(
                         lambda a, b: self.ard.smart_sort_comparator(
-                            a, b, self.ard._config["ignore_allele_with_suffixes"]
+                            a, b, self.ard.config.ignore_allele_with_suffixes
                         )
                     ),
                 )
@@ -131,7 +131,7 @@ def _sorted_unique_gl(self, gls: List[str], delim: str) -> str:
                 unique_gls,
                 key=functools.cmp_to_key(
                     lambda a, b: self.ard.smart_sort_comparator(
-                        a, b, self.ard._config["ignore_allele_with_suffixes"]
+                        a, b, self.ard.config.ignore_allele_with_suffixes
                     )
                 ),
             )

pyard/handlers/shortnull_handler.py

@@ -38,7 +38,7 @@ def is_shortnull(self, allele: str) -> bool:
             True if the allele is a valid short null and short null reduction
             is enabled in configuration, False otherwise
         """
-        return allele in self.ard.shortnulls and self.ard._config["reduce_shortnull"]
+        return allele in self.ard.shortnulls and self.ard.config.shortnull_enabled
 
     def is_null(self, allele: str) -> bool:
         """Check if allele is a null allele

pyard/handlers/v2_handler.py

@@ -44,7 +44,7 @@ def is_v2(self, allele: str) -> bool:
         """
         # Check basic V2 format criteria
         matches_v2_format = (
-            self.ard._config["reduce_v2"]  # V2 reduction must be enabled
+            self.ard.config.v2_enabled  # V2 reduction must be enabled
             and "*" in allele  # Must have locus separator
             and ":" not in allele  # Must not have field separators (V3 feature)
             and allele.split("*")[0]

pyard/reducers/lg_reducer.py

@@ -129,6 +129,6 @@ def _add_lg_suffix(self, redux_allele: str) -> str:
             )
 
         # Add suffix based on configuration
-        if self.ard._config["ARS_as_lg"]:
+        if self.ard.config.ars_as_lg_enabled:
             return redux_allele + "ARS"
         return redux_allele + "g"

tests/unit/handlers/test_allele_handler.py

@@ -3,6 +3,7 @@
 import pytest
 from unittest.mock import Mock, MagicMock
 
+from pyard import ARDConfig
 from pyard.handlers.allele_handler import AlleleHandler
 
 
@@ -13,7 +14,7 @@ class TestAlleleHandler:
     def mock_ard(self):
         """Create mock ARD instance"""
         ard = Mock()
-        ard._config = {"ARS_as_lg": False}
+        ard.config = ARDConfig.from_dict({"ARS_as_lg": False})
         return ard
 
     @pytest.fixture
@@ -55,7 +56,7 @@ def test_add_lg_suffix_single_allele_default(self, allele_handler):
 
     def test_add_lg_suffix_single_allele_ars(self, mock_ard):
         """Test add_lg_suffix with single allele using ARS suffix"""
-        mock_ard._config = {"ARS_as_lg": True}
+        mock_ard.config = ARDConfig.from_dict({"ARS_as_lg": True})
         handler = AlleleHandler(mock_ard)
         result = handler.add_lg_suffix("A*01:01")
         assert result == "A*01:01ARS"
@@ -67,7 +68,7 @@ def test_add_lg_suffix_multiple_alleles(self, allele_handler):
 
     def test_add_lg_suffix_multiple_alleles_ars(self, mock_ard):
         """Test add_lg_suffix with multiple alleles using ARS suffix"""
-        mock_ard._config = {"ARS_as_lg": True}
+        mock_ard.config = ARDConfig.from_dict({"ARS_as_lg": True})
         handler = AlleleHandler(mock_ard)
         result = handler.add_lg_suffix("A*01:01/A*01:02")
         assert result == "A*01:01ARS/A*01:02ARS"

tests/unit/handlers/test_shortnull_handler.py

@@ -3,6 +3,7 @@
 import pytest
 from unittest.mock import Mock
 
+from pyard import ARDConfig
 from pyard.handlers.shortnull_handler import ShortNullHandler
 
 
@@ -13,7 +14,7 @@ class TestShortNullHandler:
     def mock_ard(self):
         """Create mock ARD instance"""
         ard = Mock()
-        ard._config = {"reduce_shortnull": True}
+        ard.config = ARDConfig.from_dict({"reduce_shortnull": True})
         ard.shortnulls = {"A*01:01N", "B*07:02N"}
         ard.is_mac.return_value = False
         return ard
@@ -35,7 +36,7 @@ def test_is_shortnull_valid_with_config_enabled(self, shortnull_handler):
 
     def test_is_shortnull_valid_with_config_disabled(self, mock_ard):
         """Test is_shortnull with valid short null but config disabled"""
-        mock_ard._config["reduce_shortnull"] = False
+        mock_ard.config = ARDConfig.from_dict({"reduce_shortnull": False})
         handler = ShortNullHandler(mock_ard)
 
         result = handler.is_shortnull("A*01:01N")
@@ -95,7 +96,7 @@ def test_is_shortnull_combinations(
         self, mock_ard, allele, in_shortnulls, config_enabled, expected
     ):
         """Test is_shortnull with various combinations of conditions"""
-        mock_ard._config["reduce_shortnull"] = config_enabled
+        mock_ard.config = ARDConfig.from_dict({"reduce_shortnull": config_enabled})
         mock_ard.shortnulls = {allele} if in_shortnulls else set()
         handler = ShortNullHandler(mock_ard)