Module Gnumed.business.gmClinicalCalculator

GNUmed clinical calculator(s)

THIS IS NOT A VERIFIED CALCULATOR. DO NOT USE FOR ACTUAL CARE.

Classes

class cClinicalCalculator (patient=None)

Expand source code

class cClinicalCalculator(object):

        def __init__(self, patient=None):
                self.__cache = {}
                self.__patient = patient

        #--------------------------------------------------------
        def _get_patient(self):
                return self.__patient

        def _set_patient(self, patient):
                if patient == self.__patient:
                        return
                self.__patient = patient
                self.remove_from_cache()                        # uncache all values

        patient = property(lambda x:x, _set_patient)

        #--------------------------------------------------------
        def remove_from_cache(self, key=None):
                if key is None:
                        self.__cache = {}
                        return True
                try:
                        del self.__cache[key]
                        return True
                except KeyError:
                        _log.error('key [%s] does not exist in cache', key)
                        return False

        #--------------------------------------------------------
        # formulae
        #--------------------------------------------------------
        def get_EDC(self, lmp=None, nullipara=True):

                result = cClinicalResult(_('unknown EDC'))
                result.formula_name = 'EDC (Mittendorf 1990)'
                result.formula_source = 'Mittendorf, R. et al., "The length of uncomplicated human gestation," OB/GYN, Vol. 75, No., 6 June, 1990, pp. 907-932.'

                if lmp is None:
                        result.message = _('EDC: unknown LMP')
                        return result

                result.variables['LMP'] = lmp
                result.variables['nullipara'] = nullipara
                if nullipara:
                        result.variables['parity_offset'] = 15          # days
                else:
                        result.variables['parity_offset'] = 10          # days

                now = gmDateTime.pydt_now_here()
                if lmp > now:
                        result.warnings.append(_('LMP in the future'))

                if self.__patient is None:
                        result.warnings.append(_('cannot run sanity checks, no patient'))
                else:
                        if self.__patient['dob'] is None:
                                result.warnings.append(_('cannot run sanity checks, no DOB'))
                        else:
                                years, months, days, hours, minutes, seconds = gmDateTime.calculate_apparent_age(start = self.__patient['dob'])
                                # 5 years -- Myth ?
                                # http://www.mirror.co.uk/news/uk-news/top-10-crazy-amazing-and-world-789842
                                if years < 10:
                                        result.warnings.append(_('patient less than 10 years old'))
                        if self.__patient['gender'] in [None, 'm']:
                                result.warnings.append(_('atypical gender for pregnancy: %s') % self.__patient.gender_string)
                        if self.__patient['deceased'] is not None:
                                result.warnings.append(_('patient already passed away'))

                if lmp.month > 3:
                        edc_month = lmp.month - 3
                        edc_year = lmp.year + 1
                else:
                        edc_month = lmp.month + 9
                        edc_year = lmp.year

                result.numeric_value = gmDateTime.pydt_replace(dt = lmp, year = edc_year, month = edc_month, strict = False) + pydt.timedelta(days = result.variables['parity_offset'])
                result.message = _('EDC: %s') % result.numeric_value.strftime('%Y %b %d')
                result.date_valid = now
                _log.debug('%s' % result)

                return result

        #--------------------------------------------------------
        def _get_egfrs(self):
                egfrs = [
                        self.eGFR_MDRD_short,
                        self.eGFR_Cockcroft_Gault,
                        self.eGFR_CKD_EPI,
                        self.eGFR_Schwartz
                ]
                return egfrs

        eGFRs = property(_get_egfrs)

        #--------------------------------------------------------
        def _get_egfr(self):

                # < 18 ?
                Schwartz = self.eGFR_Schwartz
                if Schwartz.numeric_value is not None:
                        return Schwartz

                # this logic is based on "KVH aktuell 2/2014 Seite 10-15"
                # expect normal GFR
                CKD = self.eGFR_CKD_EPI
                if CKD.numeric_value is not None:
                        if CKD.numeric_value > self.d(60):
                                return CKD

                # CKD at or below 60
                if self.__patient['dob'] is None:
                        return CKD                      # no method will work, so return CKD anyway

                CG = self.eGFR_Cockcroft_Gault
                MDRD = self.eGFR_MDRD_short
                age = None
                if age is None:
                        try:
                                age = CKD.variables['age@crea']
                        except KeyError:
                                _log.warning('CKD-EPI: no age@crea')
                if age is None:
                        try:
                                age = CG.variables['age@crea']
                        except KeyError:
                                _log.warning('CG: no age@crea')
                if age is None:
                        try:
                                age = MDRD.variables['age@crea']
                        except KeyError:
                                _log.warning('MDRD: no age@crea')
                if age is None:
                        age = gmDateTime.calculate_apparent_age(start = self.__patient['dob'])[0]

                # geriatric ?
                if age > self.d(65):
                        if CG.numeric_value is not None:
                                return CG

                # non-geriatric or CG not computable
                if MDRD.numeric_value is None:
                        if (CKD.numeric_value is not None) or (CG.numeric_value is None):
                                return CKD
                        return CG

                if MDRD.numeric_value > self.d(60):
                        if CKD.numeric_value is not None:
                                # probably normal after all (>60) -> use CKD-EPI
                                return CKD

                return MDRD

        eGFR = property(_get_egfr)

        #--------------------------------------------------------
        def _get_gfr_mdrd_short(self):

                try:
                        return self.__cache['MDRD_short']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown MDRD (4 vars/IDMS)'))
                result.formula_name = 'eGFR from 4-variables IDMS-MDRD'
                result.formula_source = '1/2013: http://en.wikipedia.org/Renal_function / http://www.ganfyd.org/index.php?title=Estimated_glomerular_filtration_rate (NHS)'
                result.hints.append(_('best @ 30 < GFR < 60 ml/min'))

                if self.__patient is None:
                        result.message = _('MDRD (4 vars/IDMS): no patient')
                        return result

                if self.__patient['dob'] is None:
                        result.message = _('MDRD (4 vars/IDMS): no DOB (no age)')
                        return result

                # 1) gender
                result.variables['gender'] = self.__patient['gender']
                result.variables['gender_mf'] = map_gender2mf[self.__patient['gender']]
                if result.variables['gender_mf'] == 'm':
                        result.variables['gender_multiplier'] = self.d(1)
                elif result.variables['gender_mf'] == 'f':
                        result.variables['gender_multiplier'] = self.d('0.742')
                else:
                        result.message = _('MDRD (4 vars/IDMS): neither male nor female')
                        return result

                # 2) creatinine
                creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
                result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
                if result.variables['serum_crea'] is None:
                        result.message = _('MDRD (4 vars/IDMS): serum creatinine value not found (LOINC: %s)') % gmLOINC.LOINC_creatinine_quantity
                        return result
                if result.variables['serum_crea']['val_num'] is None:
                        result.message = _('MDRD (4 vars/IDMS): creatinine value not numeric')
                        return result
                result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                        result.variables['unit_multiplier'] = self.d(175)                                               # older: 186
                elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                        result.variables['unit_multiplier'] = self.d(30849)                                     # older: 32788
                else:
                        result.message = _('MDRD (4 vars/IDMS): unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                        return result

                # 3) age (at creatinine evaluation)
                result.variables['dob'] = self.__patient['dob']
                result.variables['age@crea'] = self.d (
                        gmDateTime.calculate_apparent_age (
                                start = result.variables['dob'],
                                end = result.variables['serum_crea']['clin_when']
                        )[0]
                )
                if (result.variables['age@crea'] > 84) or (result.variables['age@crea'] < 18):
                        result.message = _('MDRD (4 vars/IDMS): formula does not apply at age [%s] (17 < age < 85)') % result.variables['age@crea']
                        return result

                # 4) ethnicity
                result.variables['ethnicity_multiplier'] = self.d(1)                    # non-black
                result.warnings.append(_('ethnicity: GNUmed does not know patient ethnicity, ignoring correction factor'))

                # calculate
                result.numeric_value =  result.variables['unit_multiplier'] * \
                        pow(result.variables['serum_crea_val'], self.d('-1.154')) * \
                        pow(result.variables['age@crea'], self.d('-0.203')) * \
                        result.variables['ethnicity_multiplier'] * \
                        result.variables['gender_multiplier']
                result.unit = 'ml/min/1.73m²'

                BSA = self.body_surface_area
                result.sub_results.append(BSA)
                if BSA.numeric_value is None:
                        result.warnings.append(_('NOT corrected for non-average body surface (average = 1.73m²)'))
                else:
                        result.variables['BSA'] = BSA.numeric_value
                        result.numeric_value = result.numeric_value / BSA.numeric_value

                result.message = _('eGFR(MDRD): %.1f %s (%s) [4-vars, IDMS]') % (
                        result.numeric_value,
                        result.unit,
                        result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
                )
                result.date_valid = result.variables['serum_crea']['clin_when']

                self.__cache['MDRD_short'] = result
                _log.debug('%s' % result)

                return result

        eGFR_MDRD_short = property(_get_gfr_mdrd_short)

        #--------------------------------------------------------
        def _get_gfr_ckd_epi(self):

                try:
                        return self.__cache['CKD-EPI']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown CKD-EPI'))
                result.formula_name = 'eGFR from CKD-EPI'
                result.formula_source = '8/2014: http://en.wikipedia.org/Renal_function'
                result.hints.append(_('best @ GFR > 60 ml/min'))

                if self.__patient is None:
                        result.message = _('CKD-EPI: no patient')
                        return result

                if self.__patient['dob'] is None:
                        result.message = _('CKD-EPI: no DOB (no age)')
                        return result

                # 1) gender
                result.variables['gender'] = self.__patient['gender']
                result.variables['gender_mf'] = map_gender2mf[self.__patient['gender']]
                if result.variables['gender_mf'] == 'm':
                        result.variables['gender_multiplier'] = self.d(1)
                        result.variables['k:gender_divisor'] = self.d('0.9')
                        result.variables['a:gender_power'] = self.d('-0.411')
                elif result.variables['gender_mf'] == 'f':
                        result.variables['gender_multiplier'] = self.d('1.018')
                        result.variables['k:gender_divisor'] = self.d('0.7')
                        result.variables['a:gender_power'] = self.d('-0.329')
                else:
                        result.message = _('CKD-EPI: neither male nor female')
                        return result

                # 2) creatinine
                creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
                result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
                if result.variables['serum_crea'] is None:
                        result.message = _('CKD-EPI: serum creatinine value not found (LOINC: %s)') % gmLOINC.LOINC_creatinine_quantity
                        return result
                if result.variables['serum_crea']['val_num'] is None:
                        result.message = _('CKD-EPI: creatinine value not numeric')
                        return result
                result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num']) / self.d('88.4')
                else:
                        result.message = _('CKD-EPI: unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                        return result

                # 3) age (at creatinine evaluation)
                result.variables['dob'] = self.__patient['dob']
                result.variables['age@crea'] = self.d (
                        gmDateTime.calculate_apparent_age (
                                start = result.variables['dob'],
                                end = result.variables['serum_crea']['clin_when']
                        )[0]
                )
#               if (result.variables['age@crea'] > 84) or (result.variables['age@crea'] < 18):
#                       result.message = _('CKD-EPI: formula does not apply at age [%s] (17 < age < 85)') % result.variables['age@crea']
#                       return result

                # 4) ethnicity
                result.variables['ethnicity_multiplier'] = self.d(1)                    # non-black
                result.warnings.append(_('ethnicity: GNUmed does not know patient ethnicity, ignoring correction factor of 1.519 for "black"'))

                # calculate
                result.numeric_value = (
                        self.d(141) * \
                        pow(min((result.variables['serum_crea_val'] / result.variables['k:gender_divisor']), self.d(1)), result.variables['a:gender_power']) * \
                        pow(max((result.variables['serum_crea_val'] / result.variables['k:gender_divisor']), self.d(1)), self.d('-1.209')) * \
                        pow(self.d('0.993'), result.variables['age@crea']) * \
                        result.variables['gender_multiplier'] * \
                        result.variables['ethnicity_multiplier']
                )
                result.unit = 'ml/min/1.73m²'

                result.message = _('eGFR(CKD-EPI): %.1f %s (%s)') % (
                        result.numeric_value,
                        result.unit,
                        result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
                )
                result.date_valid = result.variables['serum_crea']['clin_when']

                self.__cache['CKD-EPI'] = result
                _log.debug('%s' % result)

                return result

        eGFR_CKD_EPI = property(_get_gfr_ckd_epi)

        #--------------------------------------------------------
        def _get_gfr_cockcroft_gault(self):

                try:
                        return self.__cache['cockcroft_gault']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown Cockcroft-Gault'))
                result.formula_name = 'eGFR from Cockcroft-Gault'
                result.formula_source = '8/2014: http://en.wikipedia.org/Renal_function'
                result.hints.append(_('best @ age >65'))

                if self.__patient is None:
                        result.message = _('Cockcroft-Gault: no patient')
                        return result

                if self.__patient['dob'] is None:
                        result.message = _('Cockcroft-Gault: no DOB (no age)')
                        return result

                # 1) gender
                result.variables['gender'] = self.__patient['gender']
                result.variables['gender_mf'] = map_gender2mf[self.__patient['gender']]
                if result.variables['gender_mf'] not in ['m', 'f']:
                        result.message = _('Cockcroft-Gault: neither male nor female')
                        return result

                # 2) creatinine
                creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
                result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
                if result.variables['serum_crea'] is None:
                        result.message = _('Cockcroft-Gault: serum creatinine value not found (LOINC: %s)') % gmLOINC.LOINC_creatinine_quantity
                        return result
                if result.variables['serum_crea']['val_num'] is None:
                        result.message = _('Cockcroft-Gault: creatinine value not numeric')
                        return result
                result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                        result.variables['unit_multiplier'] = self.d(72)
                        if result.variables['gender_mf'] == 'm':
                                result.variables['gender_multiplier'] = self.d('1')
                        else: #result.variables['gender_mf'] == 'f'
                                result.variables['gender_multiplier'] = self.d('0.85')
                elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                        result.variables['unit_multiplier'] = self.d(1)
                        if result.variables['gender_mf'] == 'm':
                                result.variables['gender_multiplier'] = self.d('1.23')
                        else: #result.variables['gender_mf'] == 'f'
                                result.variables['gender_multiplier'] = self.d('1.04')
                else:
                        result.message = _('Cockcroft-Gault: unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                        return result

                # 3) age (at creatinine evaluation)
                result.variables['dob'] = self.__patient['dob']
                result.variables['age@crea'] = self.d (
                        gmDateTime.calculate_apparent_age (
                                start = result.variables['dob'],
                                end = result.variables['serum_crea']['clin_when']
                        )[0]
                )
                if (result.variables['age@crea'] < 18):
                        result.message = _('Cockcroft-Gault: formula does not apply at age [%s] (17 < age)') % result.variables['age@crea']
                        return result

                weights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_weight, max_no_of_results = 1)
                result.variables['weight'] = weights[0] if len(weights) > 0 else None
                if result.variables['weight'] is None:
                        result.message = _('Cockcroft-Gault: weight not found')
                        return result
                if result.variables['weight']['val_num'] is None:
                        result.message = _('Cockcroft-Gault: weight not numeric')
                        return result
                if result.variables['weight']['val_unit'] == 'kg':
                        result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
                elif result.variables['weight']['val_unit'] == 'g':
                        result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
                else:
                        result.message = _('Cockcroft-Gault: weight not in kg or g')
                        return result

                # calculate
                result.numeric_value = ((
                        (140 - result.variables['age@crea']) * result.variables['weight_kg'] * result.variables['gender_multiplier']) \
                                        /                                                               \
                        (result.variables['unit_multiplier'] * result.variables['serum_crea_val'])
                )
                result.unit = 'ml/min'          #/1.73m²

                result.message = _('eGFR(CG): %.1f %s (%s)') % (
                        result.numeric_value,
                        result.unit,
                        result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
                )
                result.date_valid = result.variables['serum_crea']['clin_when']

                self.__cache['cockroft_gault'] = result
                _log.debug('%s' % result)

                return result

        eGFR_Cockcroft_Gault = property(_get_gfr_cockcroft_gault)

        #--------------------------------------------------------
        def _get_gfr_schwartz(self):

                try:
                        return self.__cache['gfr_schwartz']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown eGFR (Schwartz)'))
                result.formula_name = 'eGFR from updated Schwartz "bedside" formula (age < 19yrs)'
                result.formula_source = '1/2013: http://en.wikipedia.org/Renal_function / http://www.ganfyd.org/index.php?title=Estimated_glomerular_filtration_rate (NHS) / doi 10.1681/ASN.2008030287 / doi: 10.2215/CJN.01640309'
                result.hints.append(_('only applies @ age <18'))

                if self.__patient is None:
                        result.message = _('eGFR (Schwartz): no patient')
                        return result

                if self.__patient['dob'] is None:
                        result.message = _('eGFR (Schwartz): DOB needed for age')
                        return result

                result.variables['dob'] = self.__patient['dob']

                # creatinine
                creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
                result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
                if result.variables['serum_crea'] is None:
                        result.message = _('eGFR (Schwartz): serum creatinine value not found (LOINC: %s') % gmLOINC.LOINC_creatinine_quantity
                        return result
                if result.variables['serum_crea']['val_num'] is None:
                        result.message = _('eGFR (Schwartz): creatinine value not numeric')
                        return result
                result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                        result.variables['unit_multiplier'] = self.d(1)
                elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                        result.variables['unit_multiplier'] = self.d('0.00113')
                else:
                        result.message = _('eGFR (Schwartz): unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                        return result

                # age
                result.variables['age@crea'] = self.d (
                        gmDateTime.calculate_apparent_age (
                                start = result.variables['dob'],
                                end = result.variables['serum_crea']['clin_when']
                        )[0]
                )
                if result.variables['age@crea'] > 17:
                        result.message = _('eGFR (Schwartz): formula does not apply at age [%s] (age must be <18)') % result.variables['age@crea']
                        return result

                # age-dependant constant
                if result.variables['age@crea'] < 1:
                        # first year pre-term: k = 0.33
                        # first year full-term: k = (0.45)              0.41 (updated)
                        result.variables['constant_for_age'] = self.d('0.41')
                        result.warnings.append(_('eGFR (Schwartz): not known whether pre-term birth, applying full-term formula'))
                else:
                        result.variables['constant_for_age'] = self.d('0.41')

                # height
                result.variables['height'] = self.__patient.emr.get_result_at_timestamp (
                        timestamp = result.variables['serum_crea']['clin_when'],
                        loinc = gmLOINC.LOINC_height,
                        tolerance_interval = '7 days'
                )
                if result.variables['height'] is None:
                        result.message = _('eGFR (Schwartz): height not found')
                        return result
                if result.variables['height']['val_num'] is None:
                        result.message = _('eGFR (Schwartz): height not numeric')
                        return result
                if result.variables['height']['val_unit'] == 'cm':
                        result.variables['height_cm'] = self.d(result.variables['height']['val_num'])
                elif result.variables['height']['val_unit'] == 'mm':
                        result.variables['height_cm'] = self.d(result.variables['height']['val_num'] / self.d(10))
                elif result.variables['height']['val_unit'] == 'm':
                        result.variables['height_cm'] = self.d(result.variables['height']['val_num'] * 100)
                else:
                        result.message = _('eGFR (Schwartz): height not in m, cm, or mm')
                        return result

                # calculate
                result.numeric_value = (
                        result.variables['constant_for_age'] * result.variables['height_cm']
                ) / (
                        result.variables['unit_multiplier'] * result.variables['serum_crea_val']
                )
                result.unit = 'ml/min/1.73m²'

                result.message = _('eGFR (Schwartz): %.1f %s (%s)') % (
                        result.numeric_value,
                        result.unit,
                        result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
                )
                result.date_valid = result.variables['serum_crea']['clin_when']

                self.__cache['gfr_schwartz'] = result
                _log.debug('%s' % result)

                return result

        eGFR_Schwartz = property(_get_gfr_schwartz)

        #--------------------------------------------------------
        def _get_body_surface_area(self):

                try:
                        return self.__cache['body_surface_area']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown body surface area'))
                result.formula_name = 'Du Bois Body Surface Area'
                result.formula_source = '12/2012: http://en.wikipedia.org/wiki/Body_surface_area'

                if self.__patient is None:
                        result.message = _('Body Surface Area: no patient')
                        return result

                heights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_height, max_no_of_results = 1)
                result.variables['height'] = heights[0] if len(heights) > 0 else None
                if result.variables['height'] is None:
                        result.message = _('Body Surface Area: height not found')
                        return result

                if result.variables['height']['val_num'] is None:
                        result.message = _('Body Surface Area: height not numeric')
                        return result

                if result.variables['height']['val_unit'] == 'cm':
                        result.variables['height_cm'] = self.d(result.variables['height']['val_num'])
                elif result.variables['height']['val_unit'] == 'mm':
                        result.variables['height_cm'] = self.d(result.variables['height']['val_num'] / self.d(10))
                elif result.variables['height']['val_unit'] == 'm':
                        result.variables['height_cm'] = self.d(result.variables['height']['val_num'] * 100)
                else:
                        result.message = _('Body Surface Area: height not in m, cm, or mm')
                        return result

                result.variables['weight'] = self.__patient.emr.get_result_at_timestamp (
                        timestamp = result.variables['height']['clin_when'],
                        loinc = gmLOINC.LOINC_weight,
                        tolerance_interval = '10 days'
                )
                if result.variables['weight'] is None:
                        result.message = _('Body Surface Area: weight not found')
                        return result

                if result.variables['weight']['val_num'] is None:
                        result.message = _('Body Surface Area: weight not numeric')
                        return result

                if result.variables['weight']['val_unit'] == 'kg':
                        result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
                elif result.variables['weight']['val_unit'] == 'g':
                        result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
                else:
                        result.message = _('Body Surface Area: weight not in kg or g')
                        return result

                result.numeric_value = self.d('0.007184') * \
                        pow(result.variables['weight_kg'], self.d('0.425')) * \
                        pow(result.variables['height_cm'], self.d('0.725'))
                result.unit = 'm²'
                result.message = _('BSA (DuBois): %.2f %s') % (
                        result.numeric_value,
                        result.unit
                )
                result.date_valid = gmDateTime.pydt_now_here()
                self.__cache['body_surface_area'] = result
                _log.debug('%s' % result)
                return result

        body_surface_area = property(_get_body_surface_area)

        #--------------------------------------------------------
        def _get_body_mass_index(self):

                try:
                        return self.__cache['body_mass_index']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown BMI'))
                result.formula_name = 'BMI/Quetelet Index'
                result.formula_source = '08/2014: https://en.wikipedia.org/wiki/Body_mass_index'

                if self.__patient is None:
                        result.message = _('BMI: no patient')
                        return result

                heights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_height, max_no_of_results = 1)
                result.variables['height'] = heights[0] if len(heights) > 0 else None
                if result.variables['height'] is None:
                        result.message = _('BMI: height not found')
                        return result

                if result.variables['height']['val_num'] is None:
                        result.message = _('BMI: height not numeric')
                        return result

                if result.variables['height']['val_unit'] == 'cm':
                        result.variables['height_m'] = self.d(result.variables['height']['val_num'] / self.d(100))
                elif result.variables['height']['val_unit'] == 'mm':
                        result.variables['height_m'] = self.d(result.variables['height']['val_num'] / self.d(1000))
                elif result.variables['height']['val_unit'] == 'm':
                        result.variables['height_m'] = self.d(result.variables['height']['val_num'])
                else:
                        result.message = _('BMI: height not in m, cm, or mm')
                        return result

                result.variables['weight'] = self.__patient.emr.get_result_at_timestamp (
                        timestamp = result.variables['height']['clin_when'],
                        loinc = gmLOINC.LOINC_weight,
                        tolerance_interval = '10 days'
                )
                if result.variables['weight'] is None:
                        result.message = _('BMI: weight not found')
                        return result

                if result.variables['weight']['val_num'] is None:
                        result.message = _('BMI: weight not numeric')
                        return result

                if result.variables['weight']['val_unit'] == 'kg':
                        result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
                elif result.variables['weight']['val_unit'] == 'g':
                        result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
                else:
                        result.message = _('BMI: weight not in kg or g')
                        return result

                result.variables['dob'] = self.__patient['dob']
                start = result.variables['dob']
                end = result.variables['height']['clin_when']
                multiplier = 1
                if end < start:
                        start = result.variables['height']['clin_when']
                        end = result.variables['dob']
                        multiplier = -1
                result.variables['age@height'] = multiplier * self.d(gmDateTime.calculate_apparent_age(start, end)[0])
                if (result.variables['age@height'] < 18):
                        result.message = _('BMI (Quetelet): formula does not apply at age [%s] (0 < age < 18)') % result.variables['age@height']
                        return result

                # bmi = mass kg / height m2
                result.numeric_value = result.variables['weight_kg'] / (result.variables['height_m'] * result.variables['height_m'])
                result.unit = 'kg/m²'

                result.message = _('BMI (Quetelet): %.2f %s') % (
                        result.numeric_value,
                        result.unit
                )
                result.date_valid = max(result.variables['height']['clin_when'], result.variables['weight']['clin_when'])

                self.__cache['body_mass_index'] = result
                _log.debug('%s' % result)
                return result

        body_mass_index = property(_get_body_mass_index)
        bmi = property(_get_body_mass_index)

        #--------------------------------------------------------
        # helper functions
        #--------------------------------------------------------
        def d(self, initial):
                if isinstance(initial, decimal.Decimal):
                        return initial

                val = initial

                # float ? -> to string first
                if type(val) == type(float(1.4)):
                        val = str(val)

                # string ? -> "," to "."
                if isinstance(val, str):
                        val = val.replace(',', '.', 1)
                        val = val.strip()

                try:
                        d = decimal.Decimal(val)
                        return d
                except (TypeError, decimal.InvalidOperation):
                        return None

Instance variables

prop bmi

Expand source code

def _get_body_mass_index(self):

        try:
                return self.__cache['body_mass_index']
        except KeyError:
                pass

        result = cClinicalResult(_('unknown BMI'))
        result.formula_name = 'BMI/Quetelet Index'
        result.formula_source = '08/2014: https://en.wikipedia.org/wiki/Body_mass_index'

        if self.__patient is None:
                result.message = _('BMI: no patient')
                return result

        heights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_height, max_no_of_results = 1)
        result.variables['height'] = heights[0] if len(heights) > 0 else None
        if result.variables['height'] is None:
                result.message = _('BMI: height not found')
                return result

        if result.variables['height']['val_num'] is None:
                result.message = _('BMI: height not numeric')
                return result

        if result.variables['height']['val_unit'] == 'cm':
                result.variables['height_m'] = self.d(result.variables['height']['val_num'] / self.d(100))
        elif result.variables['height']['val_unit'] == 'mm':
                result.variables['height_m'] = self.d(result.variables['height']['val_num'] / self.d(1000))
        elif result.variables['height']['val_unit'] == 'm':
                result.variables['height_m'] = self.d(result.variables['height']['val_num'])
        else:
                result.message = _('BMI: height not in m, cm, or mm')
                return result

        result.variables['weight'] = self.__patient.emr.get_result_at_timestamp (
                timestamp = result.variables['height']['clin_when'],
                loinc = gmLOINC.LOINC_weight,
                tolerance_interval = '10 days'
        )
        if result.variables['weight'] is None:
                result.message = _('BMI: weight not found')
                return result

        if result.variables['weight']['val_num'] is None:
                result.message = _('BMI: weight not numeric')
                return result

        if result.variables['weight']['val_unit'] == 'kg':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
        elif result.variables['weight']['val_unit'] == 'g':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
        else:
                result.message = _('BMI: weight not in kg or g')
                return result

        result.variables['dob'] = self.__patient['dob']
        start = result.variables['dob']
        end = result.variables['height']['clin_when']
        multiplier = 1
        if end < start:
                start = result.variables['height']['clin_when']
                end = result.variables['dob']
                multiplier = -1
        result.variables['age@height'] = multiplier * self.d(gmDateTime.calculate_apparent_age(start, end)[0])
        if (result.variables['age@height'] < 18):
                result.message = _('BMI (Quetelet): formula does not apply at age [%s] (0 < age < 18)') % result.variables['age@height']
                return result

        # bmi = mass kg / height m2
        result.numeric_value = result.variables['weight_kg'] / (result.variables['height_m'] * result.variables['height_m'])
        result.unit = 'kg/m²'

        result.message = _('BMI (Quetelet): %.2f %s') % (
                result.numeric_value,
                result.unit
        )
        result.date_valid = max(result.variables['height']['clin_when'], result.variables['weight']['clin_when'])

        self.__cache['body_mass_index'] = result
        _log.debug('%s' % result)
        return result

prop body_mass_index

Expand source code

def _get_body_mass_index(self):

        try:
                return self.__cache['body_mass_index']
        except KeyError:
                pass

        result = cClinicalResult(_('unknown BMI'))
        result.formula_name = 'BMI/Quetelet Index'
        result.formula_source = '08/2014: https://en.wikipedia.org/wiki/Body_mass_index'

        if self.__patient is None:
                result.message = _('BMI: no patient')
                return result

        heights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_height, max_no_of_results = 1)
        result.variables['height'] = heights[0] if len(heights) > 0 else None
        if result.variables['height'] is None:
                result.message = _('BMI: height not found')
                return result

        if result.variables['height']['val_num'] is None:
                result.message = _('BMI: height not numeric')
                return result

        if result.variables['height']['val_unit'] == 'cm':
                result.variables['height_m'] = self.d(result.variables['height']['val_num'] / self.d(100))
        elif result.variables['height']['val_unit'] == 'mm':
                result.variables['height_m'] = self.d(result.variables['height']['val_num'] / self.d(1000))
        elif result.variables['height']['val_unit'] == 'm':
                result.variables['height_m'] = self.d(result.variables['height']['val_num'])
        else:
                result.message = _('BMI: height not in m, cm, or mm')
                return result

        result.variables['weight'] = self.__patient.emr.get_result_at_timestamp (
                timestamp = result.variables['height']['clin_when'],
                loinc = gmLOINC.LOINC_weight,
                tolerance_interval = '10 days'
        )
        if result.variables['weight'] is None:
                result.message = _('BMI: weight not found')
                return result

        if result.variables['weight']['val_num'] is None:
                result.message = _('BMI: weight not numeric')
                return result

        if result.variables['weight']['val_unit'] == 'kg':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
        elif result.variables['weight']['val_unit'] == 'g':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
        else:
                result.message = _('BMI: weight not in kg or g')
                return result

        result.variables['dob'] = self.__patient['dob']
        start = result.variables['dob']
        end = result.variables['height']['clin_when']
        multiplier = 1
        if end < start:
                start = result.variables['height']['clin_when']
                end = result.variables['dob']
                multiplier = -1
        result.variables['age@height'] = multiplier * self.d(gmDateTime.calculate_apparent_age(start, end)[0])
        if (result.variables['age@height'] < 18):
                result.message = _('BMI (Quetelet): formula does not apply at age [%s] (0 < age < 18)') % result.variables['age@height']
                return result

        # bmi = mass kg / height m2
        result.numeric_value = result.variables['weight_kg'] / (result.variables['height_m'] * result.variables['height_m'])
        result.unit = 'kg/m²'

        result.message = _('BMI (Quetelet): %.2f %s') % (
                result.numeric_value,
                result.unit
        )
        result.date_valid = max(result.variables['height']['clin_when'], result.variables['weight']['clin_when'])

        self.__cache['body_mass_index'] = result
        _log.debug('%s' % result)
        return result

prop body_surface_area

Expand source code

def _get_body_surface_area(self):

        try:
                return self.__cache['body_surface_area']
        except KeyError:
                pass

        result = cClinicalResult(_('unknown body surface area'))
        result.formula_name = 'Du Bois Body Surface Area'
        result.formula_source = '12/2012: http://en.wikipedia.org/wiki/Body_surface_area'

        if self.__patient is None:
                result.message = _('Body Surface Area: no patient')
                return result

        heights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_height, max_no_of_results = 1)
        result.variables['height'] = heights[0] if len(heights) > 0 else None
        if result.variables['height'] is None:
                result.message = _('Body Surface Area: height not found')
                return result

        if result.variables['height']['val_num'] is None:
                result.message = _('Body Surface Area: height not numeric')
                return result

        if result.variables['height']['val_unit'] == 'cm':
                result.variables['height_cm'] = self.d(result.variables['height']['val_num'])
        elif result.variables['height']['val_unit'] == 'mm':
                result.variables['height_cm'] = self.d(result.variables['height']['val_num'] / self.d(10))
        elif result.variables['height']['val_unit'] == 'm':
                result.variables['height_cm'] = self.d(result.variables['height']['val_num'] * 100)
        else:
                result.message = _('Body Surface Area: height not in m, cm, or mm')
                return result

        result.variables['weight'] = self.__patient.emr.get_result_at_timestamp (
                timestamp = result.variables['height']['clin_when'],
                loinc = gmLOINC.LOINC_weight,
                tolerance_interval = '10 days'
        )
        if result.variables['weight'] is None:
                result.message = _('Body Surface Area: weight not found')
                return result

        if result.variables['weight']['val_num'] is None:
                result.message = _('Body Surface Area: weight not numeric')
                return result

        if result.variables['weight']['val_unit'] == 'kg':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
        elif result.variables['weight']['val_unit'] == 'g':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
        else:
                result.message = _('Body Surface Area: weight not in kg or g')
                return result

        result.numeric_value = self.d('0.007184') * \
                pow(result.variables['weight_kg'], self.d('0.425')) * \
                pow(result.variables['height_cm'], self.d('0.725'))
        result.unit = 'm²'
        result.message = _('BSA (DuBois): %.2f %s') % (
                result.numeric_value,
                result.unit
        )
        result.date_valid = gmDateTime.pydt_now_here()
        self.__cache['body_surface_area'] = result
        _log.debug('%s' % result)
        return result

prop eGFR

Expand source code

def _get_egfr(self):

        # < 18 ?
        Schwartz = self.eGFR_Schwartz
        if Schwartz.numeric_value is not None:
                return Schwartz

        # this logic is based on "KVH aktuell 2/2014 Seite 10-15"
        # expect normal GFR
        CKD = self.eGFR_CKD_EPI
        if CKD.numeric_value is not None:
                if CKD.numeric_value > self.d(60):
                        return CKD

        # CKD at or below 60
        if self.__patient['dob'] is None:
                return CKD                      # no method will work, so return CKD anyway

        CG = self.eGFR_Cockcroft_Gault
        MDRD = self.eGFR_MDRD_short
        age = None
        if age is None:
                try:
                        age = CKD.variables['age@crea']
                except KeyError:
                        _log.warning('CKD-EPI: no age@crea')
        if age is None:
                try:
                        age = CG.variables['age@crea']
                except KeyError:
                        _log.warning('CG: no age@crea')
        if age is None:
                try:
                        age = MDRD.variables['age@crea']
                except KeyError:
                        _log.warning('MDRD: no age@crea')
        if age is None:
                age = gmDateTime.calculate_apparent_age(start = self.__patient['dob'])[0]

        # geriatric ?
        if age > self.d(65):
                if CG.numeric_value is not None:
                        return CG

        # non-geriatric or CG not computable
        if MDRD.numeric_value is None:
                if (CKD.numeric_value is not None) or (CG.numeric_value is None):
                        return CKD
                return CG

        if MDRD.numeric_value > self.d(60):
                if CKD.numeric_value is not None:
                        # probably normal after all (>60) -> use CKD-EPI
                        return CKD

        return MDRD

prop eGFR_CKD_EPI

Expand source code

        def _get_gfr_ckd_epi(self):

                try:
                        return self.__cache['CKD-EPI']
                except KeyError:
                        pass

                result = cClinicalResult(_('unknown CKD-EPI'))
                result.formula_name = 'eGFR from CKD-EPI'
                result.formula_source = '8/2014: http://en.wikipedia.org/Renal_function'
                result.hints.append(_('best @ GFR > 60 ml/min'))

                if self.__patient is None:
                        result.message = _('CKD-EPI: no patient')
                        return result

                if self.__patient['dob'] is None:
                        result.message = _('CKD-EPI: no DOB (no age)')
                        return result

                # 1) gender
                result.variables['gender'] = self.__patient['gender']
                result.variables['gender_mf'] = map_gender2mf[self.__patient['gender']]
                if result.variables['gender_mf'] == 'm':
                        result.variables['gender_multiplier'] = self.d(1)
                        result.variables['k:gender_divisor'] = self.d('0.9')
                        result.variables['a:gender_power'] = self.d('-0.411')
                elif result.variables['gender_mf'] == 'f':
                        result.variables['gender_multiplier'] = self.d('1.018')
                        result.variables['k:gender_divisor'] = self.d('0.7')
                        result.variables['a:gender_power'] = self.d('-0.329')
                else:
                        result.message = _('CKD-EPI: neither male nor female')
                        return result

                # 2) creatinine
                creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
                result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
                if result.variables['serum_crea'] is None:
                        result.message = _('CKD-EPI: serum creatinine value not found (LOINC: %s)') % gmLOINC.LOINC_creatinine_quantity
                        return result
                if result.variables['serum_crea']['val_num'] is None:
                        result.message = _('CKD-EPI: creatinine value not numeric')
                        return result
                result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
                elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num']) / self.d('88.4')
                else:
                        result.message = _('CKD-EPI: unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                        return result

                # 3) age (at creatinine evaluation)
                result.variables['dob'] = self.__patient['dob']
                result.variables['age@crea'] = self.d (
                        gmDateTime.calculate_apparent_age (
                                start = result.variables['dob'],
                                end = result.variables['serum_crea']['clin_when']
                        )[0]
                )
#               if (result.variables['age@crea'] > 84) or (result.variables['age@crea'] < 18):
#                       result.message = _('CKD-EPI: formula does not apply at age [%s] (17 < age < 85)') % result.variables['age@crea']
#                       return result

                # 4) ethnicity
                result.variables['ethnicity_multiplier'] = self.d(1)                    # non-black
                result.warnings.append(_('ethnicity: GNUmed does not know patient ethnicity, ignoring correction factor of 1.519 for "black"'))

                # calculate
                result.numeric_value = (
                        self.d(141) * \
                        pow(min((result.variables['serum_crea_val'] / result.variables['k:gender_divisor']), self.d(1)), result.variables['a:gender_power']) * \
                        pow(max((result.variables['serum_crea_val'] / result.variables['k:gender_divisor']), self.d(1)), self.d('-1.209')) * \
                        pow(self.d('0.993'), result.variables['age@crea']) * \
                        result.variables['gender_multiplier'] * \
                        result.variables['ethnicity_multiplier']
                )
                result.unit = 'ml/min/1.73m²'

                result.message = _('eGFR(CKD-EPI): %.1f %s (%s)') % (
                        result.numeric_value,
                        result.unit,
                        result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
                )
                result.date_valid = result.variables['serum_crea']['clin_when']

                self.__cache['CKD-EPI'] = result
                _log.debug('%s' % result)

                return result

prop eGFR_Cockcroft_Gault

Expand source code

def _get_gfr_cockcroft_gault(self):

        try:
                return self.__cache['cockcroft_gault']
        except KeyError:
                pass

        result = cClinicalResult(_('unknown Cockcroft-Gault'))
        result.formula_name = 'eGFR from Cockcroft-Gault'
        result.formula_source = '8/2014: http://en.wikipedia.org/Renal_function'
        result.hints.append(_('best @ age >65'))

        if self.__patient is None:
                result.message = _('Cockcroft-Gault: no patient')
                return result

        if self.__patient['dob'] is None:
                result.message = _('Cockcroft-Gault: no DOB (no age)')
                return result

        # 1) gender
        result.variables['gender'] = self.__patient['gender']
        result.variables['gender_mf'] = map_gender2mf[self.__patient['gender']]
        if result.variables['gender_mf'] not in ['m', 'f']:
                result.message = _('Cockcroft-Gault: neither male nor female')
                return result

        # 2) creatinine
        creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
        result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
        if result.variables['serum_crea'] is None:
                result.message = _('Cockcroft-Gault: serum creatinine value not found (LOINC: %s)') % gmLOINC.LOINC_creatinine_quantity
                return result
        if result.variables['serum_crea']['val_num'] is None:
                result.message = _('Cockcroft-Gault: creatinine value not numeric')
                return result
        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
        if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                result.variables['unit_multiplier'] = self.d(72)
                if result.variables['gender_mf'] == 'm':
                        result.variables['gender_multiplier'] = self.d('1')
                else: #result.variables['gender_mf'] == 'f'
                        result.variables['gender_multiplier'] = self.d('0.85')
        elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                result.variables['unit_multiplier'] = self.d(1)
                if result.variables['gender_mf'] == 'm':
                        result.variables['gender_multiplier'] = self.d('1.23')
                else: #result.variables['gender_mf'] == 'f'
                        result.variables['gender_multiplier'] = self.d('1.04')
        else:
                result.message = _('Cockcroft-Gault: unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                return result

        # 3) age (at creatinine evaluation)
        result.variables['dob'] = self.__patient['dob']
        result.variables['age@crea'] = self.d (
                gmDateTime.calculate_apparent_age (
                        start = result.variables['dob'],
                        end = result.variables['serum_crea']['clin_when']
                )[0]
        )
        if (result.variables['age@crea'] < 18):
                result.message = _('Cockcroft-Gault: formula does not apply at age [%s] (17 < age)') % result.variables['age@crea']
                return result

        weights = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_weight, max_no_of_results = 1)
        result.variables['weight'] = weights[0] if len(weights) > 0 else None
        if result.variables['weight'] is None:
                result.message = _('Cockcroft-Gault: weight not found')
                return result
        if result.variables['weight']['val_num'] is None:
                result.message = _('Cockcroft-Gault: weight not numeric')
                return result
        if result.variables['weight']['val_unit'] == 'kg':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'])
        elif result.variables['weight']['val_unit'] == 'g':
                result.variables['weight_kg'] = self.d(result.variables['weight']['val_num'] / self.d(1000))
        else:
                result.message = _('Cockcroft-Gault: weight not in kg or g')
                return result

        # calculate
        result.numeric_value = ((
                (140 - result.variables['age@crea']) * result.variables['weight_kg'] * result.variables['gender_multiplier']) \
                                /                                                               \
                (result.variables['unit_multiplier'] * result.variables['serum_crea_val'])
        )
        result.unit = 'ml/min'          #/1.73m²

        result.message = _('eGFR(CG): %.1f %s (%s)') % (
                result.numeric_value,
                result.unit,
                result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
        )
        result.date_valid = result.variables['serum_crea']['clin_when']

        self.__cache['cockroft_gault'] = result
        _log.debug('%s' % result)

        return result

prop eGFR_MDRD_short

Expand source code

def _get_gfr_mdrd_short(self):

        try:
                return self.__cache['MDRD_short']
        except KeyError:
                pass

        result = cClinicalResult(_('unknown MDRD (4 vars/IDMS)'))
        result.formula_name = 'eGFR from 4-variables IDMS-MDRD'
        result.formula_source = '1/2013: http://en.wikipedia.org/Renal_function / http://www.ganfyd.org/index.php?title=Estimated_glomerular_filtration_rate (NHS)'
        result.hints.append(_('best @ 30 < GFR < 60 ml/min'))

        if self.__patient is None:
                result.message = _('MDRD (4 vars/IDMS): no patient')
                return result

        if self.__patient['dob'] is None:
                result.message = _('MDRD (4 vars/IDMS): no DOB (no age)')
                return result

        # 1) gender
        result.variables['gender'] = self.__patient['gender']
        result.variables['gender_mf'] = map_gender2mf[self.__patient['gender']]
        if result.variables['gender_mf'] == 'm':
                result.variables['gender_multiplier'] = self.d(1)
        elif result.variables['gender_mf'] == 'f':
                result.variables['gender_multiplier'] = self.d('0.742')
        else:
                result.message = _('MDRD (4 vars/IDMS): neither male nor female')
                return result

        # 2) creatinine
        creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
        result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
        if result.variables['serum_crea'] is None:
                result.message = _('MDRD (4 vars/IDMS): serum creatinine value not found (LOINC: %s)') % gmLOINC.LOINC_creatinine_quantity
                return result
        if result.variables['serum_crea']['val_num'] is None:
                result.message = _('MDRD (4 vars/IDMS): creatinine value not numeric')
                return result
        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
        if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                result.variables['unit_multiplier'] = self.d(175)                                               # older: 186
        elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                result.variables['unit_multiplier'] = self.d(30849)                                     # older: 32788
        else:
                result.message = _('MDRD (4 vars/IDMS): unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                return result

        # 3) age (at creatinine evaluation)
        result.variables['dob'] = self.__patient['dob']
        result.variables['age@crea'] = self.d (
                gmDateTime.calculate_apparent_age (
                        start = result.variables['dob'],
                        end = result.variables['serum_crea']['clin_when']
                )[0]
        )
        if (result.variables['age@crea'] > 84) or (result.variables['age@crea'] < 18):
                result.message = _('MDRD (4 vars/IDMS): formula does not apply at age [%s] (17 < age < 85)') % result.variables['age@crea']
                return result

        # 4) ethnicity
        result.variables['ethnicity_multiplier'] = self.d(1)                    # non-black
        result.warnings.append(_('ethnicity: GNUmed does not know patient ethnicity, ignoring correction factor'))

        # calculate
        result.numeric_value =  result.variables['unit_multiplier'] * \
                pow(result.variables['serum_crea_val'], self.d('-1.154')) * \
                pow(result.variables['age@crea'], self.d('-0.203')) * \
                result.variables['ethnicity_multiplier'] * \
                result.variables['gender_multiplier']
        result.unit = 'ml/min/1.73m²'

        BSA = self.body_surface_area
        result.sub_results.append(BSA)
        if BSA.numeric_value is None:
                result.warnings.append(_('NOT corrected for non-average body surface (average = 1.73m²)'))
        else:
                result.variables['BSA'] = BSA.numeric_value
                result.numeric_value = result.numeric_value / BSA.numeric_value

        result.message = _('eGFR(MDRD): %.1f %s (%s) [4-vars, IDMS]') % (
                result.numeric_value,
                result.unit,
                result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
        )
        result.date_valid = result.variables['serum_crea']['clin_when']

        self.__cache['MDRD_short'] = result
        _log.debug('%s' % result)

        return result

prop eGFR_Schwartz

Expand source code

def _get_gfr_schwartz(self):

        try:
                return self.__cache['gfr_schwartz']
        except KeyError:
                pass

        result = cClinicalResult(_('unknown eGFR (Schwartz)'))
        result.formula_name = 'eGFR from updated Schwartz "bedside" formula (age < 19yrs)'
        result.formula_source = '1/2013: http://en.wikipedia.org/Renal_function / http://www.ganfyd.org/index.php?title=Estimated_glomerular_filtration_rate (NHS) / doi 10.1681/ASN.2008030287 / doi: 10.2215/CJN.01640309'
        result.hints.append(_('only applies @ age <18'))

        if self.__patient is None:
                result.message = _('eGFR (Schwartz): no patient')
                return result

        if self.__patient['dob'] is None:
                result.message = _('eGFR (Schwartz): DOB needed for age')
                return result

        result.variables['dob'] = self.__patient['dob']

        # creatinine
        creas = self.__patient.emr.get_most_recent_results_in_loinc_group(loincs = gmLOINC.LOINC_creatinine_quantity, max_no_of_results = 1)
        result.variables['serum_crea'] = creas[0] if len(creas) > 0 else None
        if result.variables['serum_crea'] is None:
                result.message = _('eGFR (Schwartz): serum creatinine value not found (LOINC: %s') % gmLOINC.LOINC_creatinine_quantity
                return result
        if result.variables['serum_crea']['val_num'] is None:
                result.message = _('eGFR (Schwartz): creatinine value not numeric')
                return result
        result.variables['serum_crea_val'] = self.d(result.variables['serum_crea']['val_num'])
        if result.variables['serum_crea']['val_unit'] in ['mg/dl', 'mg/dL']:
                result.variables['unit_multiplier'] = self.d(1)
        elif result.variables['serum_crea']['val_unit'] in ['µmol/L', 'µmol/l']:
                result.variables['unit_multiplier'] = self.d('0.00113')
        else:
                result.message = _('eGFR (Schwartz): unknown serum creatinine unit (%s)') % result.variables['serum_crea']['val_unit']
                return result

        # age
        result.variables['age@crea'] = self.d (
                gmDateTime.calculate_apparent_age (
                        start = result.variables['dob'],
                        end = result.variables['serum_crea']['clin_when']
                )[0]
        )
        if result.variables['age@crea'] > 17:
                result.message = _('eGFR (Schwartz): formula does not apply at age [%s] (age must be <18)') % result.variables['age@crea']
                return result

        # age-dependant constant
        if result.variables['age@crea'] < 1:
                # first year pre-term: k = 0.33
                # first year full-term: k = (0.45)              0.41 (updated)
                result.variables['constant_for_age'] = self.d('0.41')
                result.warnings.append(_('eGFR (Schwartz): not known whether pre-term birth, applying full-term formula'))
        else:
                result.variables['constant_for_age'] = self.d('0.41')

        # height
        result.variables['height'] = self.__patient.emr.get_result_at_timestamp (
                timestamp = result.variables['serum_crea']['clin_when'],
                loinc = gmLOINC.LOINC_height,
                tolerance_interval = '7 days'
        )
        if result.variables['height'] is None:
                result.message = _('eGFR (Schwartz): height not found')
                return result
        if result.variables['height']['val_num'] is None:
                result.message = _('eGFR (Schwartz): height not numeric')
                return result
        if result.variables['height']['val_unit'] == 'cm':
                result.variables['height_cm'] = self.d(result.variables['height']['val_num'])
        elif result.variables['height']['val_unit'] == 'mm':
                result.variables['height_cm'] = self.d(result.variables['height']['val_num'] / self.d(10))
        elif result.variables['height']['val_unit'] == 'm':
                result.variables['height_cm'] = self.d(result.variables['height']['val_num'] * 100)
        else:
                result.message = _('eGFR (Schwartz): height not in m, cm, or mm')
                return result

        # calculate
        result.numeric_value = (
                result.variables['constant_for_age'] * result.variables['height_cm']
        ) / (
                result.variables['unit_multiplier'] * result.variables['serum_crea_val']
        )
        result.unit = 'ml/min/1.73m²'

        result.message = _('eGFR (Schwartz): %.1f %s (%s)') % (
                result.numeric_value,
                result.unit,
                result.variables['serum_crea']['clin_when'].strftime('%Y %b %d')
        )
        result.date_valid = result.variables['serum_crea']['clin_when']

        self.__cache['gfr_schwartz'] = result
        _log.debug('%s' % result)

        return result

prop eGFRs

Expand source code

def _get_egfrs(self):
        egfrs = [
                self.eGFR_MDRD_short,
                self.eGFR_Cockcroft_Gault,
                self.eGFR_CKD_EPI,
                self.eGFR_Schwartz
        ]
        return egfrs

prop patient

Expand source code

patient = property(lambda x:x, _set_patient)

Methods

def d(self, initial)

Expand source code

def d(self, initial):
        if isinstance(initial, decimal.Decimal):
                return initial

        val = initial

        # float ? -> to string first
        if type(val) == type(float(1.4)):
                val = str(val)

        # string ? -> "," to "."
        if isinstance(val, str):
                val = val.replace(',', '.', 1)
                val = val.strip()

        try:
                d = decimal.Decimal(val)
                return d
        except (TypeError, decimal.InvalidOperation):
                return None

def get_EDC(self, lmp=None, nullipara=True)

Expand source code

def get_EDC(self, lmp=None, nullipara=True):

        result = cClinicalResult(_('unknown EDC'))
        result.formula_name = 'EDC (Mittendorf 1990)'
        result.formula_source = 'Mittendorf, R. et al., "The length of uncomplicated human gestation," OB/GYN, Vol. 75, No., 6 June, 1990, pp. 907-932.'

        if lmp is None:
                result.message = _('EDC: unknown LMP')
                return result

        result.variables['LMP'] = lmp
        result.variables['nullipara'] = nullipara
        if nullipara:
                result.variables['parity_offset'] = 15          # days
        else:
                result.variables['parity_offset'] = 10          # days

        now = gmDateTime.pydt_now_here()
        if lmp > now:
                result.warnings.append(_('LMP in the future'))

        if self.__patient is None:
                result.warnings.append(_('cannot run sanity checks, no patient'))
        else:
                if self.__patient['dob'] is None:
                        result.warnings.append(_('cannot run sanity checks, no DOB'))
                else:
                        years, months, days, hours, minutes, seconds = gmDateTime.calculate_apparent_age(start = self.__patient['dob'])
                        # 5 years -- Myth ?
                        # http://www.mirror.co.uk/news/uk-news/top-10-crazy-amazing-and-world-789842
                        if years < 10:
                                result.warnings.append(_('patient less than 10 years old'))
                if self.__patient['gender'] in [None, 'm']:
                        result.warnings.append(_('atypical gender for pregnancy: %s') % self.__patient.gender_string)
                if self.__patient['deceased'] is not None:
                        result.warnings.append(_('patient already passed away'))

        if lmp.month > 3:
                edc_month = lmp.month - 3
                edc_year = lmp.year + 1
        else:
                edc_month = lmp.month + 9
                edc_year = lmp.year

        result.numeric_value = gmDateTime.pydt_replace(dt = lmp, year = edc_year, month = edc_month, strict = False) + pydt.timedelta(days = result.variables['parity_offset'])
        result.message = _('EDC: %s') % result.numeric_value.strftime('%Y %b %d')
        result.date_valid = now
        _log.debug('%s' % result)

        return result

def remove_from_cache(self, key=None)

Expand source code

def remove_from_cache(self, key=None):
        if key is None:
                self.__cache = {}
                return True
        try:
                del self.__cache[key]
                return True
        except KeyError:
                _log.error('key [%s] does not exist in cache', key)
                return False

class cClinicalResult (message=None)

Expand source code

class cClinicalResult(object):

        def __init__(self, message=None):
                self.message = message
                self.numeric_value = None
                self.unit = None
                self.date_valid = None
                self.formula_name = None
                self.formula_source = None
                self.variables = {}
                self.sub_results = []
                self.warnings = [_('THIS IS NOT A VERIFIED MEASUREMENT. DO NOT USE FOR ACTUAL CARE.')]
                self.hints = []

        #--------------------------------------------------------
        def __str__(self):
                txt = '[cClinicalResult]: %s %s (%s)\n\n%s' % (
                        self.numeric_value,
                        self.unit,
                        self.date_valid,
                        self.format (
                                left_margin = 0,
                                width = 80,
                                eol = '\n',
                                with_formula = True,
                                with_warnings = True,
                                with_variables = True,
                                with_sub_results = True,
                                return_list = False
                        )
                )
                return txt

        #--------------------------------------------------------
        def format(self, left_margin=0, eol='\n', width=None, with_formula=False, with_warnings=True, with_variables=False, with_sub_results=False, with_hints=True, return_list=False):
                lines = []
                lines.append(self.message)

                if with_formula:
                        txt = gmTools.wrap (
                                text = '%s %s' % (
                                        _('Algorithm:'),
                                        self.formula_name
                                ),
                                width = width,
                                initial_indent = ' ',
                                subsequent_indent = ' ' * 2,
                                eol = eol
                        )
                        lines.append(txt)
                        txt = gmTools.wrap (
                                text = '%s %s' % (
                                        _('Source:'),
                                        self.formula_source
                                ),
                                width = width,
                                initial_indent = ' ',
                                subsequent_indent = ' ' * 2,
                                eol = eol
                        )
                        lines.append(txt)

                if with_warnings:
                        if len(self.warnings) > 0:
                                lines.append(' Caveat:')
                        for w in self.warnings:
                                txt = gmTools.wrap(text = w, width = width, initial_indent = '  %s ' % gmTools.u_arrow2right, subsequent_indent = '    ', eol = eol)
                                lines.append(txt)

                if with_hints:
                        if len(self.hints) > 0:
                                lines.append(' Hints:')
                        for h in self.hints:
                                txt = gmTools.wrap(text = h, width = width, initial_indent = '  %s ' % gmTools.u_arrow2right, subsequent_indent = '    ', eol = eol)
                                lines.append(txt)

                if with_variables:
                        if len(self.variables) > 0:
                                lines.append(' %s' % _('Variables:'))
                        for key in self.variables:
                                txt = '  %s %s: %s' % (
                                        gmTools.u_arrow2right,
                                        key,
                                        self.variables[key]
                                )
                                lines.append(txt)

                if with_sub_results:
                        if len(self.sub_results) > 0:
                                lines.append(' %s' % _('Intermediate results:'))
                        for r in self.sub_results:
                                lines.extend(r.format (
                                        left_margin = left_margin + 1,
                                        width = width,
                                        eol = eol,
                                        with_formula = with_formula,
                                        with_warnings = with_warnings,
                                        with_variables = with_variables,
                                        with_sub_results = False,                       # break cycles
                                        return_list = True
                                ))

                lines = gmTools.strip_trailing_empty_lines(lines = lines, eol = eol)
                if return_list:
                        return lines

                left_margin = ' ' * left_margin
                return left_margin + (eol + left_margin).join(lines) + eol

Methods

def format(self,
left_margin=0,
eol='\n',
width=None,
with_formula=False,
with_warnings=True,
with_variables=False,
with_sub_results=False,
with_hints=True,
return_list=False)

Expand source code

def format(self, left_margin=0, eol='\n', width=None, with_formula=False, with_warnings=True, with_variables=False, with_sub_results=False, with_hints=True, return_list=False):
        lines = []
        lines.append(self.message)

        if with_formula:
                txt = gmTools.wrap (
                        text = '%s %s' % (
                                _('Algorithm:'),
                                self.formula_name
                        ),
                        width = width,
                        initial_indent = ' ',
                        subsequent_indent = ' ' * 2,
                        eol = eol
                )
                lines.append(txt)
                txt = gmTools.wrap (
                        text = '%s %s' % (
                                _('Source:'),
                                self.formula_source
                        ),
                        width = width,
                        initial_indent = ' ',
                        subsequent_indent = ' ' * 2,
                        eol = eol
                )
                lines.append(txt)

        if with_warnings:
                if len(self.warnings) > 0:
                        lines.append(' Caveat:')
                for w in self.warnings:
                        txt = gmTools.wrap(text = w, width = width, initial_indent = '  %s ' % gmTools.u_arrow2right, subsequent_indent = '    ', eol = eol)
                        lines.append(txt)

        if with_hints:
                if len(self.hints) > 0:
                        lines.append(' Hints:')
                for h in self.hints:
                        txt = gmTools.wrap(text = h, width = width, initial_indent = '  %s ' % gmTools.u_arrow2right, subsequent_indent = '    ', eol = eol)
                        lines.append(txt)

        if with_variables:
                if len(self.variables) > 0:
                        lines.append(' %s' % _('Variables:'))
                for key in self.variables:
                        txt = '  %s %s: %s' % (
                                gmTools.u_arrow2right,
                                key,
                                self.variables[key]
                        )
                        lines.append(txt)

        if with_sub_results:
                if len(self.sub_results) > 0:
                        lines.append(' %s' % _('Intermediate results:'))
                for r in self.sub_results:
                        lines.extend(r.format (
                                left_margin = left_margin + 1,
                                width = width,
                                eol = eol,
                                with_formula = with_formula,
                                with_warnings = with_warnings,
                                with_variables = with_variables,
                                with_sub_results = False,                       # break cycles
                                return_list = True
                        ))

        lines = gmTools.strip_trailing_empty_lines(lines = lines, eol = eol)
        if return_list:
                return lines

        left_margin = ' ' * left_margin
        return left_margin + (eol + left_margin).join(lines) + eol