hccinfhir 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

hccinfhir/datamodels.py

@@ -23,6 +23,45 @@ DxCCMappingFilename = Literal[
     "ra_dx_to_cc_2026.csv"
 ]
 
+PrefixOverride = Literal[
+    # CMS-HCC Community prefixes
+    "CNA_",  # Community, Non-Dual, Aged
+    "CND_",  # Community, Non-Dual, Disabled
+    "CFA_",  # Community, Full Benefit Dual, Aged
+    "CFD_",  # Community, Full Benefit Dual, Disabled
+    "CPA_",  # Community, Partial Benefit Dual, Aged
+    "CPD_",  # Community, Partial Benefit Dual, Disabled
+    # CMS-HCC Institutional
+    "INS_",  # Long-Term Institutionalized
+    # CMS-HCC New Enrollee
+    "NE_",   # New Enrollee
+    "SNPNE_",  # Special Needs Plan New Enrollee
+    # ESRD Dialysis
+    "DI_",   # Dialysis
+    "DNE_",  # Dialysis New Enrollee
+    # ESRD Graft
+    "GI_",   # Graft, Institutionalized
+    "GNE_",  # Graft, New Enrollee
+    "GFPA_", # Graft, Full Benefit Dual, Aged
+    "GFPN_", # Graft, Full Benefit Dual, Non-Aged
+    "GNPA_", # Graft, Non-Dual, Aged
+    "GNPN_", # Graft, Non-Dual, Non-Aged
+    # ESRD Transplant
+    "TRANSPLANT_KIDNEY_ONLY_1M",  # 1 month post-transplant
+    "TRANSPLANT_KIDNEY_ONLY_2M",  # 2 months post-transplant
+    "TRANSPLANT_KIDNEY_ONLY_3M",  # 3 months post-transplant
+    # RxHCC Community Enrollee
+    "Rx_CE_LowAged_",     # Community Enrollee, Low Income, Aged
+    "Rx_CE_LowNoAged_",   # Community Enrollee, Low Income, Non-Aged
+    "Rx_CE_NoLowAged_",   # Community Enrollee, Not Low Income, Aged
+    "Rx_CE_NoLowNoAged_", # Community Enrollee, Not Low Income, Non-Aged
+    "Rx_CE_LTI_",         # Community Enrollee, Long-Term Institutionalized
+    # RxHCC New Enrollee
+    "Rx_NE_Lo_",   # New Enrollee, Low Income
+    "Rx_NE_NoLo_", # New Enrollee, Not Low Income
+    "Rx_NE_LTI_",  # New Enrollee, Long-Term Institutionalized
+]
+
 class ServiceLevelData(BaseModel):
     """
     Represents standardized service-level data extracted from healthcare claims.
@@ -93,8 +132,9 @@ class RAFResult(BaseModel):
     """Risk adjustment calculation results"""
     risk_score: float = Field(..., description="Final RAF score")
     risk_score_demographics: float = Field(..., description="Demographics-only risk score")
-    risk_score_chronic_only: float = Field(..., description="Chronic conditions risk score") 
+    risk_score_chronic_only: float = Field(..., description="Chronic conditions risk score")
     risk_score_hcc: float = Field(..., description="HCC conditions risk score")
+    risk_score_payment: float = Field(..., description="Payment RAF score (adjusted for MACI, normalization, and frailty)")
     hcc_list: List[str] = Field(default_factory=list, description="List of active HCC categories")
     cc_to_dx: Dict[str, Set[str]] = Field(default_factory=dict, description="Condition categories mapped to diagnosis codes")
     coefficients: Dict[str, float] = Field(default_factory=dict, description="Applied model coefficients")

hccinfhir/extractor_fhir.py

@@ -162,8 +162,8 @@ def extract_sld_fhir(eob_data: dict) -> List[ServiceLevelData]:
                                eob.billablePeriod.get_service_date() if eob.billablePeriod else None),
                 'place_of_service': item.locationCodeableConcept.get_code(SYSTEMS['context']['place'])
                                   if item.locationCodeableConcept else None,
-                'modifiers': [m.get_code(SYSTEMS['procedures']['hcpcs']) 
-                            for m in (item.modifier or []) if m],
+                'modifiers': [code for m in (item.modifier or [])
+                              if m and (code := m.get_code(SYSTEMS['procedures']['hcpcs'])) is not None],
                 'allowed_amount': next((adj.get('amount', {}).get('value')
                                       for adj in (item.adjudication or [])
                                       if any(c.get('code') == 'eligible'

hccinfhir/hccinfhir.py

@@ -1,8 +1,8 @@
-from typing import List, Dict, Any, Union
+from typing import List, Dict, Any, Union, Optional
 from hccinfhir.extractor import extract_sld_list
 from hccinfhir.filter import apply_filter
 from hccinfhir.model_calculate import calculate_raf
-from hccinfhir.datamodels import Demographics, ServiceLevelData, RAFResult, ModelName, ProcFilteringFilename, DxCCMappingFilename
+from hccinfhir.datamodels import Demographics, ServiceLevelData, RAFResult, ModelName, ProcFilteringFilename, DxCCMappingFilename, PrefixOverride
 from hccinfhir.utils import load_proc_filtering, load_dx_to_cc_mapping
 
 class HCCInFHIR:
@@ -41,8 +41,12 @@ class HCCInFHIR:
             return Demographics(**demographics)
         return demographics
     
-    def _calculate_raf_from_demographics(self, diagnosis_codes: List[str], 
-                                       demographics: Demographics) -> RAFResult:
+    def _calculate_raf_from_demographics_and_dx_codes(self, diagnosis_codes: List[str],
+                                                      demographics: Demographics,
+                                                      prefix_override: Optional[PrefixOverride] = None,
+                                                      maci: float = 0.0,
+                                                      norm_factor: float = 1.0,
+                                                      frailty_score: float = 0.0) -> RAFResult:
         """Calculate RAF score using demographics data."""
         return calculate_raf(
             diagnosis_codes=diagnosis_codes,
@@ -55,22 +59,36 @@ class HCCInFHIR:
             new_enrollee=demographics.new_enrollee,
             snp=demographics.snp,
             low_income=demographics.low_income,
+            lti=demographics.lti,
             graft_months=demographics.graft_months,
-            dx_to_cc_mapping=self.dx_to_cc_mapping
+            dx_to_cc_mapping=self.dx_to_cc_mapping,
+            prefix_override=prefix_override,
+            maci=maci,
+            norm_factor=norm_factor,
+            frailty_score=frailty_score
         )
 
     def _get_unique_diagnosis_codes(self, service_data: List[ServiceLevelData]) -> List[str]:
         """Extract unique diagnosis codes from service level data."""
         return list({code for sld in service_data for code in sld.claim_diagnosis_codes})
 
-    def run(self, eob_list: List[Dict[str, Any]], 
-            demographics: Union[Demographics, Dict[str, Any]]) -> RAFResult:
+    def run(self, eob_list: List[Dict[str, Any]],
+            demographics: Union[Demographics, Dict[str, Any]],
+            prefix_override: Optional[PrefixOverride] = None,
+            maci: float = 0.0,
+            norm_factor: float = 1.0,
+            frailty_score: float = 0.0) -> RAFResult:
         """Process EOB resources and calculate RAF scores.
-        
+
         Args:
             eob_list: List of EOB resources
             demographics: Demographics information
-            
+            prefix_override: Optional prefix to override auto-detected demographic prefix.
+                Use when demographic categorization is incorrect (e.g., ESRD patients with orec=0).
+            maci: Major Adjustment to Coding Intensity (0.0-1.0, default 0.0)
+            norm_factor: Normalization factor (default 1.0)
+            frailty_score: Frailty adjustment score (default 0.0)
+
         Returns:
             RAFResult object containing calculated scores and processed data
         """
@@ -84,16 +102,36 @@ class HCCInFHIR:
 
         if self.filter_claims:
             sld_list = apply_filter(sld_list, professional_cpt=self.professional_cpt)
-            
+
         # Calculate RAF score
         unique_dx_codes = self._get_unique_diagnosis_codes(sld_list)
-        raf_result = self._calculate_raf_from_demographics(unique_dx_codes, demographics)
-        
+        raf_result = self._calculate_raf_from_demographics_and_dx_codes(
+            unique_dx_codes, demographics, prefix_override, maci, norm_factor, frailty_score
+        )
+
         # Create new result with service data included
         return raf_result.model_copy(update={'service_level_data': sld_list})
     
-    def run_from_service_data(self, service_data: List[Union[ServiceLevelData, Dict[str, Any]]], 
-                             demographics: Union[Demographics, Dict[str, Any]]) -> RAFResult:
+    def run_from_service_data(self, service_data: List[Union[ServiceLevelData, Dict[str, Any]]],
+                             demographics: Union[Demographics, Dict[str, Any]],
+                             prefix_override: Optional[PrefixOverride] = None,
+                             maci: float = 0.0,
+                             norm_factor: float = 1.0,
+                             frailty_score: float = 0.0) -> RAFResult:
+        """Process service-level data and calculate RAF scores.
+
+        Args:
+            service_data: List of ServiceLevelData objects or dictionaries
+            demographics: Demographics information
+            prefix_override: Optional prefix to override auto-detected demographic prefix.
+                Use when demographic categorization is incorrect (e.g., ESRD patients with orec=0).
+            maci: Major Adjustment to Coding Intensity (0.0-1.0, default 0.0)
+            norm_factor: Normalization factor (default 1.0)
+            frailty_score: Frailty adjustment score (default 0.0)
+
+        Returns:
+            RAFResult object containing calculated scores and processed data
+        """
         demographics = self._ensure_demographics(demographics)
         
         if not isinstance(service_data, list):
@@ -116,25 +154,36 @@ class HCCInFHIR:
                 )
         
         if self.filter_claims:
-            standardized_data = apply_filter(standardized_data, 
+            standardized_data = apply_filter(standardized_data,
                                              professional_cpt=self.professional_cpt)
 
-        
+
         # Calculate RAF score
         unique_dx_codes = self._get_unique_diagnosis_codes(standardized_data)
-        raf_result = self._calculate_raf_from_demographics(unique_dx_codes, demographics)
-        
+        raf_result = self._calculate_raf_from_demographics_and_dx_codes(
+            unique_dx_codes, demographics, prefix_override, maci, norm_factor, frailty_score
+        )
+
         # Create new result with service data included
         return raf_result.model_copy(update={'service_level_data': standardized_data})
         
     def calculate_from_diagnosis(self, diagnosis_codes: List[str],
-                               demographics: Union[Demographics, Dict[str, Any]]) -> RAFResult:
+                               demographics: Union[Demographics, Dict[str, Any]],
+                               prefix_override: Optional[PrefixOverride] = None,
+                               maci: float = 0.0,
+                               norm_factor: float = 1.0,
+                               frailty_score: float = 0.0) -> RAFResult:
         """Calculate RAF scores from a list of diagnosis codes.
-        
+
         Args:
             diagnosis_codes: List of diagnosis codes
             demographics: Demographics information
-            
+            prefix_override: Optional prefix to override auto-detected demographic prefix.
+                Use when demographic categorization is incorrect (e.g., ESRD patients with orec=0).
+            maci: Major Adjustment to Coding Intensity (0.0-1.0, default 0.0)
+            norm_factor: Normalization factor (default 1.0)
+            frailty_score: Frailty adjustment score (default 0.0)
+
         Raises:
             ValueError: If diagnosis_codes is empty or not a list
         """
@@ -142,7 +191,9 @@ class HCCInFHIR:
             raise ValueError("diagnosis_codes must be a list")
         if not diagnosis_codes:
             raise ValueError("diagnosis_codes list cannot be empty")
-        
+
         demographics = self._ensure_demographics(demographics)
-        raf_result = self._calculate_raf_from_demographics(diagnosis_codes, demographics)
+        raf_result = self._calculate_raf_from_demographics_and_dx_codes(
+            diagnosis_codes, demographics, prefix_override, maci, norm_factor, frailty_score
+        )
         return raf_result

hccinfhir/model_calculate.py

@@ -1,5 +1,5 @@
-from typing import List, Union, Dict, Tuple, Set
-from hccinfhir.datamodels import ModelName, RAFResult
+from typing import List, Union, Dict, Tuple, Set, Optional
+from hccinfhir.datamodels import ModelName, RAFResult, PrefixOverride
 from hccinfhir.model_demographics import categorize_demographics
 from hccinfhir.model_dx_to_cc import apply_mapping
 from hccinfhir.model_hierarchies import apply_hierarchies
@@ -17,17 +17,22 @@ is_chronic_default = load_is_chronic(mapping_file_default)
 
 def calculate_raf(diagnosis_codes: List[str],
                   model_name: ModelName = "CMS-HCC Model V28",
-                  age: Union[int, float] = 65, 
-                  sex: str = 'F', 
+                  age: Union[int, float] = 65,
+                  sex: str = 'F',
                   dual_elgbl_cd: str = 'NA',
-                  orec: str = '0', 
+                  orec: str = '0',
                   crec: str = '0',
-                  new_enrollee: bool = False,   
+                  new_enrollee: bool = False,
                   snp: bool = False,
                   low_income: bool = False,
+                  lti: bool = False,
                   graft_months: int =  None,
                   dx_to_cc_mapping: Dict[Tuple[str, ModelName], Set[str]] = dx_to_cc_default,
-                  is_chronic_mapping: Dict[Tuple[str, ModelName], bool] = is_chronic_default) -> RAFResult:
+                  is_chronic_mapping: Dict[Tuple[str, ModelName], bool] = is_chronic_default,
+                  prefix_override: Optional[PrefixOverride] = None,
+                  maci: float = 0.0,
+                  norm_factor: float = 1.0,
+                  frailty_score: float = 0.0) -> RAFResult:
     """
     Calculate Risk Adjustment Factor (RAF) based on diagnosis codes and demographic information.
 
@@ -43,6 +48,10 @@ def calculate_raf(diagnosis_codes: List[str],
         snp: Special Needs Plan indicator
         low_income: Low income subsidy indicator
         graft_months: Number of months since transplant
+        prefix_override: Optional prefix to override auto-detected demographic prefix.
+            Use when demographic categorization from orec/crec is incorrect.
+            Common values: 'DI_' (ESRD Dialysis), 'DNE_' (ESRD Dialysis New Enrollee),
+            'INS_' (Institutionalized), 'CFA_' (Community Full Dual Aged), etc.
 
     Returns:
         Dictionary containing RAF score and coefficients used in calculation
@@ -63,29 +72,34 @@ def calculate_raf(diagnosis_codes: List[str],
     elif 'HHS-HCC' in model_name: # not implemented yet
         version = 'V6'
     
-    demographics = categorize_demographics(age, 
-                                           sex, 
-                                           dual_elgbl_cd, 
-                                           orec, 
-                                           crec, 
-                                           version, 
-                                           new_enrollee, 
-                                           snp, 
-                                           low_income, 
-                                           graft_months)
+    demographics = categorize_demographics(age,
+                                           sex,
+                                           dual_elgbl_cd,
+                                           orec,
+                                           crec,
+                                           version,
+                                           new_enrollee,
+                                           snp,
+                                           low_income,
+                                           lti,
+                                           graft_months,
+                                           prefix_override=prefix_override)
     
-    cc_to_dx = apply_mapping(diagnosis_codes, 
-                             model_name, 
+    cc_to_dx = apply_mapping(diagnosis_codes,
+                             model_name,
                              dx_to_cc_mapping=dx_to_cc_mapping)
     hcc_set = set(cc_to_dx.keys())
     hcc_set = apply_hierarchies(hcc_set, model_name)
     interactions = apply_interactions(demographics, hcc_set, model_name)
-    coefficients = apply_coefficients(demographics, hcc_set, interactions, model_name)
+    coefficients = apply_coefficients(demographics, hcc_set, interactions, model_name,
+                                     prefix_override=prefix_override)
 
     hcc_chronic = set()
+    interactions_chronic = {}
     for hcc in hcc_set:
         if is_chronic_mapping.get((hcc, model_name), False):
             hcc_chronic.add(hcc)
+        interactions_chronic = apply_interactions(demographics, hcc_chronic, model_name)
 
     demographic_interactions = {}
     for key, value in interactions.items():
@@ -98,26 +112,32 @@ def calculate_raf(diagnosis_codes: List[str],
         elif key.startswith('OriginallyDisabled_'):
             demographic_interactions[key] = value
 
-    coefficients_demographics = apply_coefficients(demographics, 
-                                                   set(), 
-                                                   demographic_interactions, 
-                                                   model_name)
-    coefficients_chronic_only = apply_coefficients(demographics, 
-                                                   hcc_chronic, 
-                                                   demographic_interactions, 
-                                                   model_name)
+    coefficients_demographics = apply_coefficients(demographics,
+                                                   set(),
+                                                   demographic_interactions,
+                                                   model_name,
+                                                   prefix_override=prefix_override)
+    coefficients_chronic_only = apply_coefficients(demographics,
+                                                   hcc_chronic,
+                                                   interactions_chronic,
+                                                   model_name,
+                                                   prefix_override=prefix_override)
     
     # Calculate risk scores
+    print(f"Coefficients: {coefficients}")
     risk_score = sum(coefficients.values())
+    print(f"Risk Score: {risk_score}")
     risk_score_demographics = sum(coefficients_demographics.values())
     risk_score_chronic_only = sum(coefficients_chronic_only.values()) - risk_score_demographics
     risk_score_hcc = risk_score - risk_score_demographics
+    risk_score_payment = risk_score * (1 - maci) / norm_factor + frailty_score
 
     return RAFResult(
         risk_score=risk_score,
         risk_score_demographics=risk_score_demographics,
         risk_score_chronic_only=risk_score_chronic_only,
         risk_score_hcc=risk_score_hcc,
+        risk_score_payment=risk_score_payment,
         hcc_list=list(hcc_set),
         cc_to_dx=cc_to_dx,
         coefficients=coefficients,

hccinfhir/model_coefficients.py

@@ -1,6 +1,6 @@
-from typing import Dict, Tuple
+from typing import Dict, Tuple, Optional
 import importlib.resources
-from hccinfhir.datamodels import ModelName, Demographics
+from hccinfhir.datamodels import ModelName, Demographics, PrefixOverride
 
 # Load default mappings from csv file
 coefficients_file_default = 'ra_coefficients_2026.csv'
@@ -90,15 +90,16 @@ def get_coefficent_prefix(demographics: Demographics,
     return prefix + '_'
 
 
-def apply_coefficients(demographics: Demographics, 
-                      hcc_set: set[str], 
+def apply_coefficients(demographics: Demographics,
+                      hcc_set: set[str],
                       interactions: dict,
                       model_name: ModelName = "CMS-HCC Model V28",
-                      coefficients: Dict[Tuple[str, ModelName], float] = coefficients_default) -> dict:
+                      coefficients: Dict[Tuple[str, ModelName], float] = coefficients_default,
+                      prefix_override: Optional[PrefixOverride] = None) -> dict:
     """Apply risk adjustment coefficients to HCCs and interactions.
 
     This function takes demographic information, HCC codes, and interaction variables and returns
-    a dictionary mapping each variable to its corresponding coefficient value based on the 
+    a dictionary mapping each variable to its corresponding coefficient value based on the
     specified model.
 
     Args:
@@ -108,13 +109,16 @@ def apply_coefficients(demographics: Demographics,
         model_name: Name of the risk adjustment model to use (default: "CMS-HCC Model V28")
         coefficients: Dictionary mapping (variable, model) tuples to coefficient values
             (default: coefficients_default)
+        prefix_override: Optional prefix to override auto-detected demographic prefix.
+            Common values: 'DI_' (ESRD Dialysis), 'DNE_' (ESRD Dialysis New Enrollee),
+            'INS_' (Institutionalized), 'CFA_' (Community Full Dual Aged), etc.
 
     Returns:
         Dictionary mapping HCC codes and interaction variables to their coefficient values
         for variables that are present (HCC in hcc_set or interaction value = 1)
     """
     # Get the coefficient prefix
-    prefix = get_coefficent_prefix(demographics, model_name)
+    prefix = prefix_override if prefix_override is not None else get_coefficent_prefix(demographics, model_name)
     
     output = {}
 

hccinfhir/model_demographics.py

@@ -1,16 +1,18 @@
-from typing import Union
-from hccinfhir.datamodels import Demographics
+from typing import Union, Optional
+from hccinfhir.datamodels import Demographics, PrefixOverride
     
-def categorize_demographics(age: Union[int, float], 
-                       sex: str, 
+def categorize_demographics(age: Union[int, float],
+                       sex: str,
                        dual_elgbl_cd: str = None,
-                       orec: str = None, 
+                       orec: str = None,
                        crec: str = None,
                        version: str = 'V2',
                        new_enrollee: bool = False,
                        snp: bool = False,
                        low_income: bool = False,
-                       graft_months: int = None
+                       lti: bool = False,
+                       graft_months: int = None,
+                       prefix_override: Optional[PrefixOverride] = None
                        ) -> Demographics:
     """
     Categorize a beneficiary's demographics into risk adjustment categories.
@@ -23,10 +25,15 @@ def categorize_demographics(age: Union[int, float],
         sex: Beneficiary sex ('M'/'F' or '1'/'2')
         dual_elgbl_cd: Dual eligibility code ('00'-'10')
         orec: Original reason for entitlement code ('0'-'3')
-        crec: Current reason for entitlement code ('0'-'3') 
+        crec: Current reason for entitlement code ('0'-'3')
         version: Version of categorization to use ('V2', 'V4', 'V6')
         new_enrollee: Whether beneficiary is a new enrollee
         snp: Whether beneficiary is in a Special Needs Plan
+        low_income: Whether beneficiary is low income (RxHCC only)
+        lti: Whether beneficiary is long-term institutionalized
+        graft_months: Number of months since transplant (ESRD only)
+        prefix_override: Optional prefix to override demographic detection
+            (e.g., 'DI_', 'DNE_', 'INS_', 'CFA_', etc.)
 
     Returns:
         Demographics object containing derived fields like age/sex category,
@@ -82,6 +89,44 @@ def categorize_demographics(age: Union[int, float],
     esrd_crec = crec in {'2', '3'} if crec else False
     esrd = esrd_orec or esrd_crec
 
+    # Override demographics based on prefix_override
+    if prefix_override:
+        # ESRD model prefixes
+        esrd_prefixes = {'DI_', 'DNE_', 'GI_', 'GNE_', 'GFPA_', 'GFPN_', 'GNPA_', 'GNPN_'}
+        # CMS-HCC new enrollee prefixes
+        new_enrollee_prefixes = {'NE_', 'SNPNE_', 'DNE_', 'GNE_'}
+        # CMS-HCC community prefixes
+        community_prefixes = {'CNA_', 'CND_', 'CFA_', 'CFD_', 'CPA_', 'CPD_'}
+        # Institutionalized prefix
+        institutional_prefixes = {'INS_', 'GI_'}
+        
+        # TODO: RxHCC prefixes
+
+        # Set esrd flag
+        if prefix_override in esrd_prefixes:
+            esrd = True
+
+        # Set new_enrollee flag
+        if prefix_override in new_enrollee_prefixes:
+            new_enrollee = True
+        elif prefix_override in community_prefixes or prefix_override in institutional_prefixes:
+            new_enrollee = False
+
+        # Set dual eligibility flags based on prefix
+        if prefix_override in {'CFA_', 'CFD_', 'GFPA_', 'GFPN_'}:
+            is_fbd = True
+            is_pbd = False
+        elif prefix_override in {'CPA_', 'CPD_'}:
+            is_fbd = False
+            is_pbd = True
+        elif prefix_override in {'CNA_', 'CND_', 'GNPA_', 'GNPN_'}:
+            is_fbd = False
+            is_pbd = False
+
+        # Set lti flag based on prefix
+        if prefix_override in institutional_prefixes:
+            lti = True
+
     result_dict = {
         'version': version,
         'non_aged': non_aged,
@@ -97,6 +142,7 @@ def categorize_demographics(age: Union[int, float],
         'fbd': is_fbd,
         'pbd': is_pbd,
         'esrd': esrd,
+        'lti': lti,
         'graft_months': graft_months,
         'low_income': low_income
     }
@@ -131,10 +177,14 @@ def categorize_demographics(age: Union[int, float],
         if orec is None or orec == '':
             orec = '0' # Default to 0 if OREC is None
 
-        # New enrollee logic
+        # Determine prefix based on new_enrollee status
         if new_enrollee:
             prefix = 'NEF' if std_sex == '2' else 'NEM'
-            
+        else:
+            prefix = 'F' if std_sex == '2' else 'M'
+
+        # CMS-HCC new enrollee logic with detailed 65-69 categories
+        if new_enrollee and not esrd:
             if age <= 34:
                 category = f'{prefix}0_34'
             elif 34 < age <= 44:
@@ -167,9 +217,9 @@ def categorize_demographics(age: Union[int, float],
                 category = f'{prefix}90_94'
             else:
                 category = f'{prefix}95_GT'
-        
+
+        # Standard logic with grouped 65_69 (for non-new-enrollee OR ESRD)
         else:
-            prefix = 'F' if std_sex == '2' else 'M'
             age_ranges = [
                 (0, 34, '0_34'),
                 (34, 44, '35_44'),
@@ -184,7 +234,7 @@ def categorize_demographics(age: Union[int, float],
                 (89, 94, '90_94'),
                 (94, float('inf'), '95_GT')
             ]
-            
+
             for low, high, suffix in age_ranges:
                 if low < age <= high:
                     category = f'{prefix}{suffix}'