def setUp(self) -> None: setup_server.setup_data() self.instance = Instance( a_instance.IDENTIFIER, Orthanc(setup_server.ORTHANC_URL) )
def setUp(self) -> None: setup_server.setup_data() self.study = Study( a_study.IDENTIFIER, Orthanc(setup_server.ORTHANC_URL) )
class TestOrthancPatientSetters(unittest.TestCase): @classmethod def setUpClass(cls) -> None: global orthanc_subprocess orthanc_subprocess = setup_server.setup_orthanc_server() @classmethod def tearDownClass(cls) -> None: global orthanc_subprocess setup_server.stop_orthanc_server_and_remove_data_directory( orthanc_subprocess) del orthanc_subprocess def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) def tearDown(self) -> None: self.orthanc = None setup_server.clear_data() def given_patient_in_orthanc_server(self): setup_server.setup_data() def test_givenOrthancWithAnUnprotectedPatient_whenSettingPatientToProtected_thenPatientIsProtected( self): self.given_patient_in_orthanc_server() self.orthanc.set_patient_to_protected(a_patient.IDENTIFIER) self.assertTrue( self.orthanc.get_if_patient_is_protected(a_patient.IDENTIFIER)) def test_givenOrthancWithAnUnprotectedPatient_whenSettingPatientToNotProtected_thenPatientIsUnprotected( self): self.given_patient_in_orthanc_server() self.orthanc.set_patient_to_not_protected(a_patient.IDENTIFIER) self.assertFalse( self.orthanc.get_if_patient_is_protected(a_patient.IDENTIFIER)) def test_givenOrthancWithoutPatient_whenSettingPatientToProtected_thenRaiseHTTPError( self): self.assertRaises( HTTPError, lambda: self.orthanc.set_patient_to_protected( a_patient.IDENTIFIER)) def test_givenOrthancWithoutPatient_whenSettingPatientToNotProtected_thenRaiseHTTPError( self): self.assertRaises( HTTPError, lambda: self.orthanc.set_patient_to_not_protected( a_patient.IDENTIFIER))
class TestOrthancPatientDeleters(unittest.TestCase): @classmethod def setUpClass(cls) -> None: global orthanc_subprocess orthanc_subprocess = setup_server.setup_orthanc_server() @classmethod def tearDownClass(cls) -> None: global orthanc_subprocess setup_server.stop_orthanc_server_and_remove_data_directory( orthanc_subprocess) del orthanc_subprocess def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) def tearDown(self) -> None: self.orthanc = None setup_server.clear_data() def given_patient_in_orthanc_server(self): setup_server.setup_data() def test_givenOrthancWithPatient_whenDeletingPatientData_thenResultIsTrue( self): self.given_patient_in_orthanc_server() result = self.orthanc.delete_patient(a_patient.IDENTIFIER) self.assertTrue(result) def test_givenOrthancWithoutPatient_whenDeletingPatientData_thenResultIsFalse( self): result = self.orthanc.delete_patient(a_patient.IDENTIFIER) self.assertFalse(result)
def retrieve_image( server: Orthanc, series_id: str, name: list = None, slice_idx=None, norm_range=True, convert_to_uint=None, ): if convert_to_uint is None: convert_to_uint = not norm_range zfile = zipfile.ZipFile(BytesIO(server.get_series_archives(series_id))) # return all elements if no name is given if name is None: name = zfile.namelist() try: name.remove("DICOMDIR") except ValueError: pass imgs = [] for _name in name: with zfile.open(_name) as f: img = pydicom.read_file(f).pixel_array if norm_range: img = img - img.min() img = img / img.max() if convert_to_uint: img = ((img + 32768) / (32767 * 2 + 1)) * 255 img = img.astype(np.uint8) if slice_idx is not None: img = img[slice_idx] imgs.append(img) if len(imgs) == 1: return imgs[0] else: return imgs
def setUp(self) -> None: setup_server.setup_data() self.series = Series(a_series.IDENTIFIER, Orthanc(setup_server.ORTHANC_URL))
tqdm.write("Finished Patient %s" % pid) except Exception as e: return str(e) if __name__ == "__main__": import sys base_out_dir = "/work/scratch/schock/Temp/FromOrthanc" valid_ids = ["0000000001"] series_number_mapping = {"00": "img", "01": "left", "02": "right"} instance_frame_mapping = {"femur": 0, "tibia": 1} orthanc = Orthanc("http://orthanc:8043") orthanc.setup_credentials(sys.argv[1], sys.argv[2]) # If needed patient_ids = [] tqdm.write("Retrieve Patient IDs") for study_identifier in orthanc.get_studies(): study_information = orthanc.get_study_information(study_identifier) study_id = study_information["MainDicomTags"]["StudyID"] patient_id = study_information["PatientMainDicomTags"]["PatientID"] if study_id in valid_ids: # Add Unique Patient ID and Readable (but possibly ambiguous) # Patient ID patient_ids.append( (study_information["ParentPatient"], patient_id)) tqdm.write("Start Processing Patients")
def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) self.remote = RemoteModality(self.orthanc, MODALITY)
class TestRemoteModality(unittest.TestCase): @classmethod def setUpClass(cls) -> None: global orthanc_subprocess global second_orthanc_subprocess orthanc_subprocess = setup_server.setup_orthanc_server() second_orthanc_subprocess = setup_server.setup_second_orthanc_server() @classmethod def tearDownClass(cls) -> None: global orthanc_subprocess global second_orthanc_subprocess setup_server.stop_orthanc_server_and_remove_data_directory( orthanc_subprocess) setup_server.stop_second_orthanc_server_and_remove_data_directory( second_orthanc_subprocess) del orthanc_subprocess del second_orthanc_subprocess def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) self.remote = RemoteModality(self.orthanc, MODALITY) def tearDown(self) -> None: self.orthanc = None self.remote = None setup_server.clear_data() setup_server.clear_data_of_second_orthanc() def given_patient_in_second_orthanc_server(self): setup_server.setup_data_for_second_orthanc() def test_whenDoingAnEcho_thenResultIsTrue(self): result = self.remote.echo() self.assertTrue(result) def test_givenDataInSecondServerAndPayload_whenQuerying_thenQueryHasExpectingContent( self): self.given_patient_in_second_orthanc_server() expected_query_answer_content = { '0008,0005': { 'Name': 'SpecificCharacterSet', 'Type': 'String', 'Value': 'ISO_IR 100' }, '0008,0050': { 'Name': 'AccessionNumber', 'Type': 'String', 'Value': '20090926001' }, '0008,0052': { 'Name': 'QueryRetrieveLevel', 'Type': 'String', 'Value': 'STUDY' }, '0010,0020': { 'Name': 'PatientID', 'Type': 'String', 'Value': 'MP15-067' }, '0020,000d': { 'Name': 'StudyInstanceUID', 'Type': 'String', 'Value': '1.3.6.1.4.1.22213.2.6291.2.1' } } result = self.remote.query(PAYLOAD) self.assertIn('ID', result.keys()) self.assertIn('Path', result.keys()) self.assertEqual( expected_query_answer_content, self.orthanc.get_content_of_specified_query_answer( result['ID'], 0)) def test_givenDataInSecondServerAndQuery_whenMoving_thenDataInSecondServerIsInFirstOrthancServer( self): self.given_patient_in_second_orthanc_server() cmove_data = {'TargetAet': 'FirstOrthanc'} expected_move_answer = { 'Description': 'REST API', 'LocalAet': 'FIRSTORTHANC', 'RemoteAet': 'SECONDORTHANC' } query_result = self.remote.query(PAYLOAD) result = self.remote.move(query_result['ID'], cmove_data) try: del result[ 'Query'] # On some version of Orthanc, A Query field is there except KeyError: pass self.assertDictEqual(expected_move_answer, result) resulting_patient_information = self.orthanc.get_patient_information( self.orthanc.get_patients()[0]) self.assertEqual( { k: v for k, v in PATIENT_INFORMATION.items() if k != 'LastUpdate' }, { k: v for k, v in resulting_patient_information.items() if k != 'LastUpdate' })
def __init__(self): self.orthanc = Orthanc(Config.get('pacs_adres')) self.orthanc.setup_credentials(Config.get('pacs_login'), Config.get('pacs_password'))
# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. import tkinter as tk from tkinter import filedialog, ttk from pathlib import Path from distutils.dir_util import copy_tree import subprocess, json, threading, time, datetime, zipfile, os import concurrent.futures from pyorthanc import Orthanc orthanc = Orthanc('http://localhost:8042') name = "genii" # helper class for common gui widgets class Elements: def __init__(self, master): self.master = master # method for all button processes def button(self, char, funct, lambdaVal, x_, y_, algn, rows): if lambdaVal == '': self.b = tk.Button(self.master, text=char, command=funct) else: self.b = tk.Button(self.master,
from pyorthanc import Orthanc orthanc = Orthanc('http://localhost:8042') # To get patients identifier and main information patients_identifiers = orthanc.get_patients() for patient_identifier in patients_identifiers: patient = orthanc.get_patient_information(patient_identifier) patient_name = patient['MainDicomTags']['PatientID'] study_identifiers = patient['Studies'] fName = patient_name+'.zip' print(fName) bytes_content = orthanc.archive_patient(patient['ID']) with open(fName, 'wb') as file_handler: file_handler.write(bytes_content)
class TestOrthancPatientPosts(unittest.TestCase): @classmethod def setUpClass(cls) -> None: global orthanc_subprocess orthanc_subprocess = setup_server.setup_orthanc_server() @classmethod def tearDownClass(cls) -> None: global orthanc_subprocess setup_server.stop_orthanc_server_and_remove_data_directory( orthanc_subprocess) del orthanc_subprocess def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) def tearDown(self) -> None: self.orthanc = None setup_server.clear_data() def given_patient_in_orthanc_server(self): setup_server.setup_data() def test_givenOrthancWithAPatient_whenAnonymizeAPatient_thenResultIsIdentifiersOfNewAnonymousPatientAndANewAnonymousPatientIsCreated( self): self.given_patient_in_orthanc_server() result = self.orthanc.anonymize_patient(a_patient.IDENTIFIER) self.assertIsInstance(result, dict) self.assertIn('ID', result.keys()) self.assertIn('Path', result.keys()) self.assertIn('PatientID', result.keys()) self.assertIn(result['ID'], self.orthanc.get_patients()) self.assertEqual( 'Anonymized1', self.orthanc.get_patient_information( result['ID'])['MainDicomTags']['PatientName']) def test_givenOrthancWithoutAPatient_whenAnonymizeAPatient_thenRaiseHTTPError( self): self.assertRaises( HTTPError, lambda: self.orthanc.anonymize_patient(a_patient.IDENTIFIER)) def test_givenOrthancWithAPatient_whenArchivingAPatient_thenResultIsBytesOfAValidZipFile( self): self.given_patient_in_orthanc_server() result = self.orthanc.archive_patient(a_patient.IDENTIFIER) self.assertIsInstance(result, bytes) with open(a_patient.ZIP_FILE_PATH, 'wb') as file_handler: file_handler.write(result) a_zip_file = zipfile.ZipFile(a_patient.ZIP_FILE_PATH) self.assertIsNone(a_zip_file.testzip()) os.remove(a_patient.ZIP_FILE_PATH) def test_givenOrthancWithoutAPatient_whenArchivingAPatient_thenRaiseHTTPError( self): self.assertRaises( HTTPError, lambda: self.orthanc.archive_patient(a_patient.IDENTIFIER))
def setUp(self) -> None: setup_server.setup_data() self.patient = Patient(a_patient.IDENTIFIER, Orthanc(setup_server.ORTHANC_URL))
class TestOrthancPatientGetters(unittest.TestCase): @classmethod def setUpClass(cls) -> None: global orthanc_subprocess orthanc_subprocess = setup_server.setup_orthanc_server() @classmethod def tearDownClass(cls) -> None: global orthanc_subprocess setup_server.stop_orthanc_server_and_remove_data_directory(orthanc_subprocess) del orthanc_subprocess def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) def tearDown(self) -> None: self.orthanc = None setup_server.clear_data() def given_patient_in_orthanc_server(self): setup_server.setup_data() def test_givenOrthancWithPatient_whenGettingPatients_thenResultIsANonEmptyListOfPatientIdentifier(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patients() self.assertIsInstance(result, list) self.assertIn(a_patient.IDENTIFIER, result) def test_givenOrthancWithoutPatient_whenGettingPatients_thenResultIsAnEmptyList(self): result = self.orthanc.get_patients() self.assertIsInstance(result, list) self.assertEqual(len(result), 0) def test_givenOrthancWithPatient_whenGettingPatientInformation_thenResultIsADictionaryOfPatientInformation(self): self.given_patient_in_orthanc_server() keys_to_remove = ['LastUpdate'] # Removing keys that are never the same result = self.orthanc.get_patient_information(a_patient.IDENTIFIER) self.assertIsInstance(result, dict) result = {key: value for key, value in result.items() if key not in keys_to_remove} expected = {key: value for key, value in a_patient.INFORMATION.items() if key not in keys_to_remove} self.assertDictEqual(result, expected) def test_givenOrthancWithoutPatient_whenGettingPatientInformation_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_information(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientZip_thenResultIsBytesOfAValidZipFile(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_zip(a_patient.IDENTIFIER) self.assertIsInstance(result, bytes) with open(a_patient.ZIP_FILE_PATH, 'wb') as file_handler: file_handler.write(result) a_zip_file = zipfile.ZipFile(a_patient.ZIP_FILE_PATH) self.assertIsNone(a_zip_file.testzip()) os.remove(a_patient.ZIP_FILE_PATH) def test_givenOrthancWithoutPatient_whenGettingPatientZip_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_zip(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientInstances_thenResultIsAListOfPatientInstanceInformation(self): self.given_patient_in_orthanc_server() keys_to_remove = {'FileUuid'} # Removing keys that are never the same result = self.orthanc.get_patient_instances(a_patient.IDENTIFIER) self.assertIsInstance(result, list) result = [{key: value for key, value in i.items() if key not in keys_to_remove} for i in result] expected = [{key: value for key, value in i.items() if key not in keys_to_remove} for i in a_patient.INSTANCES] self.assertCountEqual(result, expected) def test_givenOrthancWithoutPatient_whenGettingPatientInstances_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_instances(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientInstancesTags_thenResultIsADictOfPatientInstancesTags(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_instances_tags(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.INSTANCE_TAGS) def test_givenOrthancWithoutPatient_whenGettingPatientInstancesTags_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_instances_tags(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientInstancesTagsInSimplifiedVersion_thenResultIsADictOfPatientInstancesTagsInSimplifiedVersion(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_instances_tags_in_simplified_version(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.INSTANCE_TAGS_IN_SIMPLIFIED_VERSION) def test_givenOrthancWithoutPatient_whenGettingPatientInstancesTagsInSimplifiedVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_instances_tags_in_simplified_version(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientInstancesTagsInShorterVersion_thenResultIsADictOfPatientInstancesTagsInShorterVersion(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_instances_tags_in_shorter_version(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.INSTANCE_TAGS_IN_SHORTER_VERSION) def test_givenOrthancWithoutPatient_whenGettingPatientInstancesTagsInShorterVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_instances_tags_in_shorter_version(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientArchive_thenResultIsBytesOfAValidZipFileOfPatientArchive(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_archive(a_patient.IDENTIFIER) with open(a_patient.ZIP_FILE_PATH, 'wb') as file_handler: file_handler.write(result) a_zip_file = zipfile.ZipFile(a_patient.ZIP_FILE_PATH) self.assertIsNone(a_zip_file.testzip()) os.remove(a_patient.ZIP_FILE_PATH) def test_givenOrthancWithoutPatient_whenGettingPatientArchive_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_archive(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientModule_thenResultIsExpectedTagInExpectedFormat(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_module(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.MODULE) def test_givenOrthancWithoutPatient_whenGettingPatientModule_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_module(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientModuleInSimplifiedVersion_thenResultIsExpectedTagInExpectedFormat(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_module_in_simplified_version(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.MODULE_IN_SIMPLIFIED_VERSION) def test_givenOrthancWithoutPatient_whenGettingPatientModuleInSimplifiedVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_module_in_simplified_version(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientModuleInShorterVersion_thenResultIsExpectedTagInExpectedFormat(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_module_in_shorter_version(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.MODULE_IN_SHORTER_VERSION) def test_givenOrthancWithoutPatient_whenGettingPatientModuleInShorterVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_module_in_shorter_version(a_patient.IDENTIFIER) ) def test_givenOrthancWithUnprotectedPatient_whenGettingIfPatientIsProtected_thenResultIsFalse(self): self.given_patient_in_orthanc_server() self.orthanc.set_patient_to_not_protected(a_patient.IDENTIFIER) result = self.orthanc.get_if_patient_is_protected(a_patient.IDENTIFIER) self.assertFalse(result) def test_givenOrthancWithProtectedPatient_whenGettingIfPatientIsProtected_thenResultIsTrue(self): self.given_patient_in_orthanc_server() self.orthanc.set_patient_to_protected(a_patient.IDENTIFIER) result = self.orthanc.get_if_patient_is_protected(a_patient.IDENTIFIER) self.assertTrue(result) def test_givenOrthancWithAPatient_whenGettingPatientSeries_thenResultIsAListOfPatientSeriesMainInformation(self): self.given_patient_in_orthanc_server() keys_to_remove = ['LastUpdate'] # Removing keys that are never the same result = self.orthanc.get_patient_series(a_patient.IDENTIFIER) self.assertIsInstance(result, list) result = [{key: value for key, value in i.items() if key not in keys_to_remove} for i in result] expected = [{key: value for key, value in i.items() if key not in keys_to_remove} for i in a_patient.SERIES] self.assertCountEqual(result, expected) def test_givenOrthancWithoutPatient_whenGettingPatientSeries_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_series(a_patient.IDENTIFIER) ) def test_givenOrthancWithAPatient_whenGettingPatientSharedTags_thenResultIsExpectedTagsInExpectedFormat(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_shared_tags(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.SHARED_TAGS) def test_givenOrthancWithoutPatient_whenGettingPatientSharedTags_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_shared_tags(a_patient.IDENTIFIER) ) def test_givenOrthancWithAPatient_whenGettingPatientSharedTagsInSimplifiedVersion_thenResultIsExpectedTagsInExpectedFormat(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_shared_tags_in_simplified_version(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.SHARED_TAGS_IN_SIMPLIFIED_VERSION) def test_givenOrthancWithoutPatient_whenGettingPatientSharedTagsInSimplifiedVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_shared_tags_in_simplified_version(a_patient.IDENTIFIER) ) def test_givenOrthancWithAPatient_whenGettingPatientSharedTagsInShorterVersion_thenResultIsExpectedTagsInExpectedFormat(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_shared_tags_in_shorter_version(a_patient.IDENTIFIER) self.assertEqual(result, a_patient.SHARED_TAGS_IN_SHORTER_VERSION) def test_givenOrthancWithoutPatient_whenGettingPatientSharedTagsInShorterVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_shared_tags_in_shorter_version(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientStatistics_thenResultIsExpectedPatientStatistics(self): self.given_patient_in_orthanc_server() keys_to_remove = ['DiskSize', 'UncompressedSize'] # Removing keys that are never the same result = self.orthanc.get_patient_statistics(a_patient.IDENTIFIER) self.assertIsInstance(result, dict) result = {key: value for key, value in result.items() if key not in keys_to_remove} expected = {key: value for key, value in a_patient.STATISTICS.items() if key not in keys_to_remove} self.assertDictEqual(result, expected) def test_givenOrthancWithoutPatient_whenGettingPatientStatistics_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_statistics(a_patient.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingPatientStudiesInformation_thenResultIsExpectedPatientStudiesInformation(self): self.given_patient_in_orthanc_server() keys_to_remove = ['LastUpdate'] # Removing keys that are never the same result = self.orthanc.get_patient_studies_information(a_patient.IDENTIFIER) self.assertIsInstance(result, list) result = [self._sort_dictionary_element({key: value for key, value in i.items() if key not in keys_to_remove}) for i in result] expected = [self._sort_dictionary_element({key: value for key, value in i.items() if key not in keys_to_remove}) for i in a_patient.STUDIES] self.assertCountEqual(result, expected) def test_givenOrthancWithoutPatient_whenGettingPatientStudiesInformation_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_studies_information(a_patient.IDENTIFIER) ) def _sort_dictionary_element(self, dictionary: Dict) -> Dict: for key, value in dictionary.items(): if type(value) == list: dictionary[key] = value.sort() elif type(value) == dict: dictionary[key] = self._sort_dictionary_element(value) return dictionary
class TestOrthancStudyGetters(unittest.TestCase): @classmethod def setUpClass(cls) -> None: global orthanc_subprocess orthanc_subprocess = setup_server.setup_orthanc_server() @classmethod def tearDownClass(cls) -> None: global orthanc_subprocess setup_server.stop_orthanc_server_and_remove_data_directory(orthanc_subprocess) del orthanc_subprocess def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL) def tearDown(self) -> None: self.orthanc = None setup_server.clear_data() def given_patient_in_orthanc_server(self): setup_server.setup_data() def test_givenOrthancWithPatient_whenGettingStudies_thenResultIsANonEmptyListOfStudyIdentifiers(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_studies() self.assertIsInstance(result, list) self.assertIn(a_study.IDENTIFIER, result) def test_givenOrthancWithoutPatient_whenGettingStudies_thenResultIsAnEmptyList(self): result = self.orthanc.get_studies() self.assertIsInstance(result, list) self.assertEqual(len(result), 0) def test_givenOrthancWithAPatient_whenGettingStudies_thenResultIsExpectedStudyInformation(self): self.given_patient_in_orthanc_server() keys_to_exclude = {'LastUpdate'} result = self.orthanc.get_study_information(a_study.IDENTIFIER) self.assertIsInstance(result, dict) self.assertDictEqual( {key: value.sort() if type(value) == list else value for key, value in result.items() if key not in keys_to_exclude}, {key: value.sort() if type(value) == list else value for key, value in a_study.INFORMATION.items() if key not in keys_to_exclude}, ) def test_givenOrthancWithoutPatient_whenGettingStudies_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_study_information(a_study.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingStudyZip_thenResultIsBytesOfAValidZipFile(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_study_zip_file(a_study.IDENTIFIER) self.assertIsInstance(result, bytes) with open(a_study.ZIP_FILE_PATH, 'wb') as file_handler: file_handler.write(result) a_zip_file = zipfile.ZipFile(a_study.ZIP_FILE_PATH) self.assertIsNone(a_zip_file.testzip()) os.remove(a_study.ZIP_FILE_PATH) def test_givenOrthancWithoutPatient_whenGettingStudyZip_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_study_zip_file(a_study.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingStudyInstances_thenResultIsAListOfStudyInstanceInformation(self): self.given_patient_in_orthanc_server() keys_to_exclude = {'FileUuid', 'FileSize'} # Removing keys that are never the same result = self.orthanc.get_study_instances(a_study.IDENTIFIER) self.assertIsInstance(result, list) result = [{key: value for key, value in i.items() if key not in keys_to_exclude} for i in result] expected = [{key: value for key, value in i.items() if key not in keys_to_exclude} for i in a_study.INSTANCES] self.assertCountEqual(result, expected) def test_givenOrthancWithoutPatient_whenGettingStudyInstances_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_study_instances(a_study.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingStudyInstancesTags_thenResultIsADictOfStudyInstancesTags(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_study_instances_tags(a_study.IDENTIFIER) self.assertEqual(result, a_study.INSTANCE_TAGS) def test_givenOrthancWithoutPatient_whenGettingStudyInstancesTags_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_study_instances_tags(a_study.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingStudyInstancesTagsInSimplifiedVersion_thenResultIsADictOfPatientInstancesTagsInSimplifiedVersion(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_study_instances_tags_in_simplified_version(a_study.IDENTIFIER) self.assertEqual(result, a_study.INSTANCE_TAGS_IN_SIMPLIFIED_VERSION) def test_givenOrthancWithoutPatient_whenGettingStudyInstancesTagsInSimplifiedVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_study_instances_tags_in_simplified_version( a_study.IDENTIFIER ) ) def test_givenOrthancWithPatient_whenGettingStudyInstancesTagsInShorterVersion_thenResultIsADictOfPatientInstancesTagsInShorterVersion(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_study_instances_tags_in_shorter_version(a_study.IDENTIFIER) self.assertEqual(result, a_study.INSTANCE_TAGS_IN_SHORTER_VERSION) def test_givenOrthancWithoutPatient_whenGettingStudyInstancesTagsInShorterVersion_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_study_instances_tags_in_shorter_version(a_study.IDENTIFIER) ) def test_givenOrthancWithPatient_whenGettingStudyArchive_thenResultIsBytesOfAValidZipFileOfStudyArchive(self): self.given_patient_in_orthanc_server() result = self.orthanc.get_patient_archive(a_study.IDENTIFIER) with open(a_study.ZIP_FILE_PATH, 'wb') as file_handler: file_handler.write(result) a_zip_file = zipfile.ZipFile(a_study.ZIP_FILE_PATH) self.assertIsNone(a_zip_file.testzip()) os.remove(a_study.ZIP_FILE_PATH) def test_givenOrthancWithoutPatient_whenGettingStudyArchive_thenRaiseHTTPError(self): self.assertRaises( HTTPError, lambda: self.orthanc.get_patient_archive(a_study.IDENTIFIER) )
def setUp(self) -> None: self.orthanc = Orthanc(setup_server.ORTHANC_URL)
class PACS_OrthancServerCtrl(PACS_ServerCtrl): def __init__(self): self.orthanc = Orthanc(Config.get('pacs_adres')) self.orthanc.setup_credentials(Config.get('pacs_login'), Config.get('pacs_password')) def isConnect(self) -> bool: return True def find(self): result = [] patients_identifiers = self.orthanc.get_patients() for patient_identifier in patients_identifiers: patient_information = self.orthanc.get_patient_information( patient_identifier) id = patient_information['ID'] patient_id = patient_information['MainDicomTags'].get( 'PatientID', '---') patient_name = patient_information['MainDicomTags'].get( 'PatientName', '---') patient_sex = patient_information['MainDicomTags'].get( 'PatientSex', '---') result.append([id, patient_id, patient_name, patient_sex]) return result def find_study(self, patient_id): result = [] patient_information = self.orthanc.get_patient_information(patient_id) study_identifiers = patient_information['Studies'] for study_identifier in study_identifiers: study_information = self.orthanc.get_study_information( study_identifier) id = study_information['ID'] study_date = study_information['MainDicomTags'].get( 'StudyDate', ' --- ') describe = study_information['MainDicomTags'].get( 'StudyDescription', '---') institution = study_information['MainDicomTags'].get( 'InstitutionName', '----') result.append([id, study_date, describe, institution]) return result def find_series(self, study_id) -> list: result = [] study_information = self.orthanc.get_study_information(study_id) series_identifiers = study_information['Series'] for series_identifier in series_identifiers: series_information = self.orthanc.get_series_information( series_identifier) id = series_information['ID'] modality = series_information['MainDicomTags'].get( 'Modality', '---') protocol = series_information['MainDicomTags'].get( 'ProtocolName', '---') imagesAmount = series_information['MainDicomTags'].get( 'ImagesInAcquisition', '---') result.append([id, modality, protocol, imagesAmount]) return result def find_instance(self, series_id: str) -> list: result = [] series_information = self.orthanc.get_series_information(series_id) instance_identifiers = series_information['Instances'] for instance_identifier in instance_identifiers: instance_information = self.orthanc.get_instance_information( instance_identifier) result.append({ 'ID': instance_information['ID'], 'ParentSeries': instance_information['ParentSeries'], 'IndexInSeries': instance_information['IndexInSeries'] }) return result def move(self, instance_id: str, path: str): instance = Instance(instance_id, self.orthanc) dicom = instance.get_dicom_file_content() with open(path + '.dcm', 'wb+') as file_handler: file_handler.write(dicom) def store(self): pass