示例#1
0
def rp(psa_dates, psa_vals, rp_date):
    rp_date = filter(None, rp_date)
    result = []

    if len(psa_dates) > 0:

        for date in rp_date:
            psd = equal_or_after(psa_dates, date)
            if len(psd) != 0:
                for j in range(psa_dates.index(psd), len(psa_dates)):
                    cur = psa_vals[j]
                    if (j + 1) < len(psa_dates):
                        nex = psa_vals[j + 1]
                    else:
                        break

                    if float(cur) >= 0.2 and float(nex) >= 0.2:
                        result.append([
                            'Radical Prostatectomy', 'Curative',
                            psa_dates[j + 1], nex
                        ])
                        break

    if len(result) > 0:
        return result
    else:
        return [['NULL', 'NULL', 'NULL', 'NULL']]
示例#2
0
def chemo(psa_dates, psa_vals, chemo_start, chemo_intent):
    result = []

    if len(psa_dates) > 0:

        #intent_dic = {'2': 'Curative', '3': 'Life prolonging', '4': 'Symptom control', '5': 'Adjuvant'}
        #chemo_intent = [intent_dic[x] if x in intent_dic.keys() else '' for x in chemo_intent]
        #indices = [i for i, x in enumerate(chemo_intent) if x in intent_dic.values()]

        indices = [
            i for i, x in enumerate(chemo_intent)
            if (x == "Curative" or x == "2")
        ]

        for i in indices:
            date = chemo_start[i]
            psd = equal_or_after(psa_dates, date)

            if len(psd) != 0:
                j = psa_dates.index(psd)
                while j < len(psa_dates):
                    cur = psa_vals[j]
                    if (j + 1) < len(psa_dates):
                        nex = psa_vals[j + 1]
                    else:
                        break

                    if float(nex) > float(cur):
                        nadir = float(cur)
                        zenith = float(cur) * 1.25

                        for k in range((j + 1), len(psa_dates)):
                            p = psa_vals[k]

                            if float(p) <= nadir:
                                j = k
                                break
                            elif float(p) >= zenith:
                                result.append([
                                    'Chemotherapy', 'Curative', psa_dates[k], p
                                ])
                                break
                        if j != k:
                            break
                    else:
                        j = j + 1

    if len(result) > 0:
        return result
    else:
        return [['NULL', 'NULL', 'NULL', 'NULL']]
示例#3
0
def cryo(psa_dates, psa_vals, cryo_start, cryo_intent):
    result = []

    if len(psa_dates) > 0:

        indices = [
            i for i, x in enumerate(cryo_intent)
            if (x == "Primary" or x == "1")
        ]

        for i in indices:
            date = cryo_start[i]
            psd = equal_or_after(psa_dates, date)

            if len(psd) != 0:
                j = psa_dates.index(psd)
                while j < len(psa_dates):
                    cur = psa_vals[j]
                    if (j + 1) < len(psa_dates):
                        nex = psa_vals[j + 1]
                    else:
                        break

                    if float(nex) > float(cur):
                        nadir = float(cur)
                        zenith = float(cur) + 2

                        for k in range((j + 1), len(psa_dates)):
                            p = psa_vals[k]

                            if float(p) <= nadir:
                                j = k
                                break
                            elif float(p) >= zenith:
                                result.append([
                                    'Cryotherapy', 'Primary', psa_dates[k], p
                                ])
                                break
                        if j != k:
                            break
                    else:
                        j = j + 1

    if len(result) > 0:
        return result
    else:
        return [['NULL', 'NULL', 'NULL', 'NULL']]
示例#4
0
def rt(psa_dates, psa_vals, rt_start, rt_intent, all_tx):
    all_tx = filter(None, all_tx)
    result = []

    if len(psa_dates) > 0:

        indices = [
            i for i, x in enumerate(rt_intent) if (x == "Curative" or x == "2")
        ]

        # Add non-curative RT txs to all_tx
        all_tx.extend(
            [rt_start[i] for i in range(len(rt_start)) if i not in indices])
        all_tx = sorted(
            all_tx, key=lambda x: datetime.datetime.strptime(x, date_match))

        for i in indices:
            date = rt_start[i]
            psd = equal_or_after(psa_dates, date)

            if len(psd) != 0:
                terminus = ''
                if len(all_tx) != 0:
                    terminus = equal_or_after(all_tx, date)
                if len(terminus) == 0:
                    terminus = datetime.datetime.strftime(
                        (datetime.datetime.strptime(psa_dates[-1], date_match)
                         + datetime.timedelta(days=1)), date_match)

                bounce = False
                nadir_set = False
                j = psa_dates.index(psd)
                while j < len(psa_dates):
                    cur = psa_vals[j]
                    if (j + 1) < len(psa_dates):
                        nex = psa_vals[j + 1]
                    else:
                        break

                    if float(nex) > float(cur):

                        nadir = float(cur)
                        zenith = nadir + 2

                        for k in range((j + 1), len(psa_dates)):

                            p = psa_vals[k]

                            if float(p) <= nadir:
                                if nadir_set:
                                    bounce = True
                                    nadir_set = False
                                    #print 'Benign bounce'

                                j = k
                                break
                            elif float(p) >= zenith:
                                if not bounce and not nadir_set:
                                    break_val = p
                                    break_date = psa_dates[k]
                                    nadir = 0.5
                                    zenith = nadir + 2
                                    nadir_set = True

                                if bounce or (k == len(psa_vals) - 1) or (
                                        datetime.datetime.strptime(
                                            psa_dates[k + 1], date_match) >=
                                        datetime.datetime.strptime(
                                            terminus, date_match)):
                                    if bounce:
                                        result.append([
                                            'Radiation Therapy', 'Curative',
                                            psa_dates[k], p
                                        ])
                                    else:
                                        result.append([
                                            'Radiation Therapy', 'Curative',
                                            break_date, break_val
                                        ])
                                    break
                        if j != k:
                            break
                    else:
                        j = j + 1

    if len(result) > 0:
        return result
    else:
        return [['NULL', 'NULL', 'NULL', 'NULL']]
示例#5
0
def lhrh(psa_dates, psa_vals, lhrh_start, lhrh_stop, lhrh_intent):
    result = []

    if len(psa_dates) > 0:

        intent_dic = {
            '1': 'Neo-adjuvant',
            '2': 'Curative',
            '3': 'Salvage',
            '4': 'Metastatic',
            '5': 'Life prolonging',
            '6': 'Symptom control',
            '7': 'Adjuvant'
        }

        # this line allows tx periods to have no stop date, IE, tx periods which may be in process.
        lhrh_stop = [psa_dates[-1] if x == '' else x for x in lhrh_stop]

        for i, date in enumerate(lhrh_start):
            start = equal_or_after(psa_dates, date)
            stop = equal_or_before(psa_dates,
                                   lhrh_stop[lhrh_start.index(date)])
            if len(start) != 0 and len(stop) != 0 and psa_dates.index(
                    start) < psa_dates.index(stop):
                j = psa_dates.index(start)

                while j < len(psa_dates) and equal_or_before([psa_dates[j]],
                                                             stop) != '':
                    cur = psa_vals[j]
                    if (j + 1) < len(psa_dates) and equal_or_before(
                        [psa_dates[j + 1]], stop) != '':
                        nex = psa_vals[j + 1]
                    else:
                        break

                    if float(nex) > float(cur):
                        nadir = float(cur)
                        zenith = float(nex)
                        zenith_date = datetime.datetime.strptime(
                            psa_dates[j + 1], date_match)

                        for k in range((j + 1), len(psa_dates)):

                            if equal_or_before([psa_dates[k]], stop) == '':
                                break

                            p = psa_vals[k]
                            p_date = datetime.datetime.strptime(
                                psa_dates[k], date_match)

                            if float(p) <= nadir:
                                j = k
                                break
                            elif float(p) > zenith and (p_date -
                                                        zenith_date).days >= 7:
                                result.append([
                                    'LHRH',
                                    intent_dic.get(lhrh_intent[i], 'NULL'),
                                    psa_dates[k], p
                                ])
                                break
                        if j != k:
                            break
                    else:
                        j = j + 1

    if len(result) > 0:
        return result
    else:
        return [['NULL', 'NULL', 'NULL', 'NULL']]