def test_convert_patient_name():
last_name = "Jones"
first_name = "Davy"
middle_initial = "L"
honorific = "Dr"
degree_suffix = "PhD"
full_name_as_list = [
last_name,
first_name,
middle_initial,
honorific,
degree_suffix,
]
expected_patient_name = (
f"{str(last_name).upper()}, {str(first_name).lower().capitalize()}")
# dog fooding
resulting_patient_name = convert_patient_name(expected_patient_name)
assert resulting_patient_name == expected_patient_name
for separator in ["^", ", "]:
for num_components in range(2, 6):
single_string_name = separator.join(
full_name_as_list[0:num_components])
resulting_patient_name = convert_patient_name(single_string_name)
assert resulting_patient_name == expected_patient_name
def test_convert_exceptional_patient_name():
last_name = "De La Cruz"
first_name = "Immanuel"
full_name_as_list = [last_name, first_name]
expected_patient_name = (
f"{str(last_name).upper()}, {str(first_name).lower().capitalize()}")
for separator in [":", ";"]:
single_string_name = separator.join(full_name_as_list)
with pytest.raises(ValueError):
resulting_patient_name = convert_patient_name(single_string_name)
assert resulting_patient_name == expected_patient_name
resulting_patient_name = convert_patient_name("^".join(full_name_as_list))
assert resulting_patient_name == expected_patient_name
def dicom_input_method( # pylint: disable = too-many-return-statements
key_namespace="",
patient_id="",
**_):
FILE_UPLOAD = "File upload"
MONACO_SEARCH = "Search Monaco file export location"
dicom_export_locations = get_dicom_export_locations()
import_method = st.radio(
"DICOM import method",
[FILE_UPLOAD, MONACO_SEARCH],
key=f"{key_namespace}_dicom_file_import_method",
)
if import_method == FILE_UPLOAD:
dicom_plan_bytes = st.file_uploader(
"Upload DICOM RT Plan File",
key=f"{key_namespace}_dicom_plan_uploader")
if dicom_plan_bytes is None:
return {}
try:
dicom_plan = pydicom.read_file(dicom_plan_bytes, force=True)
except: # pylint: disable = bare-except
st.write(WrongFileType("Does not appear to be a DICOM file"))
return {}
if dicom_plan.SOPClassUID != DICOM_PLAN_UID:
st.write(
WrongFileType(
"The DICOM type needs to be an RT DICOM Plan file"))
return {}
data_paths = ["Uploaded DICOM file"]
if import_method == MONACO_SEARCH:
site_options = list(dicom_export_locations.keys())
monaco_site = st.radio("Monaco Export Location",
site_options,
key=f"{key_namespace}_monaco_site")
monaco_export_directory = dicom_export_locations[monaco_site]
st.write(monaco_export_directory.resolve())
patient_id = st.text_input("Patient ID",
patient_id,
key=f"{key_namespace}_patient_id")
found_dicom_files = list(
monaco_export_directory.glob(f"{patient_id}_*.dcm"))
dicom_plans = {}
for path in found_dicom_files:
dcm = load_dicom_file_if_plan(path)
if dcm is not None:
dicom_plans[path.name] = dcm
dicom_plan_options = list(dicom_plans.keys())
if len(dicom_plan_options) == 0 and patient_id != "":
st.write(
NoRecordsFound(
f"No exported DICOM RT plans found for Patient ID {patient_id} "
f"within the directory {monaco_export_directory}"))
return {"patient_id": patient_id}
if len(dicom_plan_options) == 1:
selected_plan = dicom_plan_options[0]
else:
selected_plan = st.radio(
"Select DICOM Plan",
dicom_plan_options,
key=f"{key_namespace}_select_monaco_export_plan",
)
f"DICOM file being used: `{selected_plan}`"
dicom_plan = dicom_plans[selected_plan]
data_paths = [monaco_export_directory.joinpath(selected_plan)]
patient_id = str(dicom_plan.PatientID)
f"Patient ID: `{patient_id}`"
patient_name = str(dicom_plan.PatientName)
patient_name = utl_patient.convert_patient_name(patient_name)
f"Patient Name: `{patient_name}`"
rt_plan_name = str(dicom_plan.RTPlanName)
f"Plan Name: `{rt_plan_name}`"
try:
deliveries_all_fractions = pymedphys.Delivery.from_dicom(
dicom_plan, fraction_number="all")
except AttributeError:
st.write(WrongFileType("Does not appear to be a photon DICOM plan"))
return {}
fractions = list(deliveries_all_fractions.keys())
if len(fractions) == 1:
delivery = deliveries_all_fractions[fractions[0]]
else:
fraction_choices = {}
for fraction, delivery in deliveries_all_fractions.items():
rounded_mu = round(delivery.mu[-1], 1)
fraction_choices[
f"Perscription {fraction} with {rounded_mu} MU"] = fraction
fraction_selection = st.radio(
"Select relevant perscription",
list(fraction_choices.keys()),
key=f"{key_namespace}_dicom_perscription_chooser",
)
fraction_number = fraction_choices[fraction_selection]
delivery = deliveries_all_fractions[fraction_number]
deliveries = [delivery]
identifier = f"DICOM ({rt_plan_name})"
return {
"patient_id": patient_id,
"patient_name": patient_name,
"data_paths": data_paths,
"identifier": identifier,
"deliveries": deliveries,
}