From 00f67c2875db4f21292eee6bd1134b78fb64a823 Mon Sep 17 00:00:00 2001 From: Jeff <138259519+jdotc1@users.noreply.github.com> Date: Wed, 21 Oct 2026 13:38:49 -0400 Subject: [PATCH 1/3] Restore pydicom reading validation mode after file validation --- CHANGES.md | 2 + .../validator/test_dicom_file_validator.py | 92 ++++++++++++++++++- .../validator/dicom_file_validator.py | 18 ++-- 3 files changed, 105 insertions(+), 7 deletions(-) diff --git a/CHANGES.md b/CHANGES.md index 2ffa99a..14324ac 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -5,6 +5,8 @@ The released versions correspond to PyPi releases. ## Unreleased ### Fixes +* File validation restores the caller's pydicom reading validation mode after + dataset validation and result handling, including when either raises an error. * DICOM filenames in HTML report headings are escaped so markup characters remain filename text. diff --git a/dicom_validator/tests/validator/test_dicom_file_validator.py b/dicom_validator/tests/validator/test_dicom_file_validator.py index 058f198..852ff20 100644 --- a/dicom_validator/tests/validator/test_dicom_file_validator.py +++ b/dicom_validator/tests/validator/test_dicom_file_validator.py @@ -3,10 +3,13 @@ import pydicom import pytest -from pydicom import dcmwrite +from pydicom import DataElement, config, dcmread, dcmwrite from pydicom.dataset import Dataset, FileDataset, FileMetaDataset from dicom_validator.validator.dicom_file_validator import DicomFileValidator +from dicom_validator.validator.dicom_info import DicomInfo +from dicom_validator.validator.error_handler import NullValidationResultHandler +from dicom_validator.validator.iod_validator import IODValidator from dicom_validator.validator.validation_result import DicomTag, ErrorCode, Status pytestmark = pytest.mark.usefixtures("disable_logging") @@ -107,3 +110,90 @@ def test_that_pixeldata_is_read(dicom_fixture_path, validator: DicomFileValidato assert oper_name_error.code == ErrorCode.TagMissing # if PixelData is not read, RT Dose will show errors assert "RT Dose" not in result.module_errors + + +@pytest.fixture(params=[config.IGNORE, config.WARN, config.RAISE]) +def reading_mode(request, monkeypatch): + monkeypatch.setattr(config.settings, "reading_validation_mode", request.param) + return request.param + + +@pytest.fixture +def mode_validator(): + return DicomFileValidator( + DicomInfo({}, {}, {}), error_handler=NullValidationResultHandler() + ) + + +@pytest.fixture +def deferred_dicom_file(tmp_path): + filename = str(tmp_path / "deferred.dcm") + dataset = FileDataset( + filename, Dataset(), file_meta=TestFakeDicomFileValidator.create_metadata() + ) + dataset.SOPClassUID = dataset.file_meta.MediaStorageSOPClassUID + dataset.add( + DataElement("PatientID", "LO", "A" * 2048, validation_mode=config.IGNORE) + ) + dcmwrite(filename, dataset, **TestFakeDicomFileValidator.enforce_file_format()) + # The oversized LO value is deferred by the same threshold used in validate_file. + assert dcmread(filename, defer_size=1024)._dict[0x0010_0020].value is None + return filename + + +def test_reading_mode_restored_after_validation( + mode_validator, deferred_dicom_file, reading_mode +): + writing_mode = config.settings.writing_validation_mode + result = mode_validator.validate_file(deferred_dicom_file)[deferred_dicom_file] + assert result.status == Status.UnknownSOPClassUID + assert config.settings.reading_validation_mode == reading_mode + assert config.settings.writing_validation_mode == writing_mode + + +def test_reading_mode_restored_after_invalid_file( + mode_validator, tmp_path, reading_mode +): + filename = str(tmp_path / "invalid.dcm") + Path(filename).write_bytes(b"not a DICOM file") + result = mode_validator.validate_file(filename)[filename] + assert result.status == Status.InvalidFile + assert config.settings.reading_validation_mode == reading_mode + + +def test_reading_mode_restored_after_read_error(mode_validator, tmp_path, reading_mode): + with pytest.raises(FileNotFoundError): + mode_validator.validate_file(str(tmp_path / "missing.dcm")) + assert config.settings.reading_validation_mode == reading_mode + + +@pytest.mark.parametrize("method", ["__init__", "validate"]) +def test_reading_mode_restored_after_validation_error( + mode_validator, deferred_dicom_file, reading_mode, method, monkeypatch +): + def fail_validation(self, *args, **kwargs): + assert config.settings.reading_validation_mode == config.IGNORE + raise RuntimeError("validation failed") + + monkeypatch.setattr(IODValidator, method, fail_validation) + with pytest.raises(RuntimeError, match="validation failed"): + mode_validator.validate_file(deferred_dicom_file) + assert config.settings.reading_validation_mode == reading_mode + + +@pytest.mark.parametrize("invalid_file", [False, True]) +def test_reading_mode_restored_after_handler_error( + mode_validator, deferred_dicom_file, reading_mode, invalid_file, monkeypatch +): + def fail_handler(result): + assert config.settings.reading_validation_mode == config.IGNORE + raise RuntimeError("handler failed") + + if invalid_file: + Path(deferred_dicom_file).write_bytes(b"not a DICOM file") + monkeypatch.setattr( + mode_validator._error_handler, "handle_validation_result", fail_handler + ) + with pytest.raises(RuntimeError, match="handler failed"): + mode_validator.validate_file(deferred_dicom_file) + assert config.settings.reading_validation_mode == reading_mode diff --git a/dicom_validator/validator/dicom_file_validator.py b/dicom_validator/validator/dicom_file_validator.py index 771302d..5455f6a 100644 --- a/dicom_validator/validator/dicom_file_validator.py +++ b/dicom_validator/validator/dicom_file_validator.py @@ -106,7 +106,14 @@ def validate_file(self, file_path: str) -> dict[str, ValidationResult]: ------- dict[str, ValidationResult] A mapping containing exactly one entry for the given file. + + Notes + ----- + Temporarily disables pydicom's process-wide reading validation until + dataset validation and result handling finish, including deferred reads. + This is not thread-safe with concurrent pydicom reads. """ + reading_mode = config.settings.reading_validation_mode try: # dcmread calls validate_value by default. If values don't match # required VR (value representation), it emits a warning but @@ -119,11 +126,8 @@ def validate_file(self, file_path: str) -> dict[str, ValidationResult]: except InvalidDicomError: result = ValidationResult(file_path=file_path, status=Status.InvalidFile) self.handle_error(result) - return { - file_path: result, - } - return { - file_path: IODValidator( + else: + result = IODValidator( data_set, self._dicom_info, log_level=self.log_level, @@ -131,7 +135,9 @@ def validate_file(self, file_path: str) -> dict[str, ValidationResult]: error_handler=self._error_handler, file_path=file_path, ).validate() - } + finally: + config.settings.reading_validation_mode = reading_mode + return {file_path: result} def handle_error(self, result: ValidationResult) -> None: handler = self._error_handler or default_error_handler( From daccc30eea55bcdd168bcca45b0d1f6b7f485395 Mon Sep 17 00:00:00 2001 From: Jeff <138259519+jdotc1@users.noreply.github.com> Date: Wed, 21 Oct 2026 15:19:36 -0400 Subject: [PATCH 2/3] Extract reading validation mode context manager --- .../validator/test_dicom_file_validator.py | 22 ++++++- .../validator/dicom_file_validator.py | 64 ++++++++++++------- 2 files changed, 61 insertions(+), 25 deletions(-) diff --git a/dicom_validator/tests/validator/test_dicom_file_validator.py b/dicom_validator/tests/validator/test_dicom_file_validator.py index 852ff20..f7ac9bd 100644 --- a/dicom_validator/tests/validator/test_dicom_file_validator.py +++ b/dicom_validator/tests/validator/test_dicom_file_validator.py @@ -6,7 +6,10 @@ from pydicom import DataElement, config, dcmread, dcmwrite from pydicom.dataset import Dataset, FileDataset, FileMetaDataset -from dicom_validator.validator.dicom_file_validator import DicomFileValidator +from dicom_validator.validator.dicom_file_validator import ( + DicomFileValidator, + set_validation_mode, +) from dicom_validator.validator.dicom_info import DicomInfo from dicom_validator.validator.error_handler import NullValidationResultHandler from dicom_validator.validator.iod_validator import IODValidator @@ -197,3 +200,20 @@ def fail_handler(result): with pytest.raises(RuntimeError, match="handler failed"): mode_validator.validate_file(deferred_dicom_file) assert config.settings.reading_validation_mode == reading_mode + + +@pytest.mark.parametrize("temporary_mode", [config.IGNORE, config.WARN, config.RAISE]) +def test_validation_mode_context_restores_nested_modes(reading_mode, temporary_mode): + writing_mode = config.settings.writing_validation_mode + with set_validation_mode(temporary_mode): + assert config.settings.reading_validation_mode == temporary_mode + with ( + pytest.raises(RuntimeError, match="inner failure"), + set_validation_mode(config.IGNORE), + ): + assert config.settings.reading_validation_mode == config.IGNORE + raise RuntimeError("inner failure") + assert config.settings.reading_validation_mode == temporary_mode + assert config.settings.writing_validation_mode == writing_mode + assert config.settings.reading_validation_mode == reading_mode + assert config.settings.writing_validation_mode == writing_mode diff --git a/dicom_validator/validator/dicom_file_validator.py b/dicom_validator/validator/dicom_file_validator.py index 5455f6a..555b6a5 100644 --- a/dicom_validator/validator/dicom_file_validator.py +++ b/dicom_validator/validator/dicom_file_validator.py @@ -1,5 +1,7 @@ import logging import os +from collections.abc import Iterator +from contextlib import contextmanager from os import PathLike from pydicom import config, dcmread @@ -14,6 +16,21 @@ from dicom_validator.validator.validation_result import Status, ValidationResult +@contextmanager +def set_validation_mode(mode: int) -> Iterator[None]: + """Temporarily set pydicom's process-wide reading validation mode. + + Restore the previous mode on exit, including when the body raises. + This does not change writing validation and is not thread-safe. + """ + reading_mode = config.settings.reading_validation_mode + try: + config.settings.reading_validation_mode = mode + yield + finally: + config.settings.reading_validation_mode = reading_mode + + class DicomFileValidator: """Validates a single DICOM file or all DICOM files in a directory.""" @@ -113,30 +130,29 @@ def validate_file(self, file_path: str) -> dict[str, ValidationResult]: dataset validation and result handling finish, including deferred reads. This is not thread-safe with concurrent pydicom reads. """ - reading_mode = config.settings.reading_validation_mode - try: - # dcmread calls validate_value by default. If values don't match - # required VR (value representation), it emits a warning but - # does not provide the tag and value that caused the warning. - # We will handle it later (optionally) by calling validate_value - # directly. - config.settings.reading_validation_mode = config.IGNORE - data_set = dcmread(file_path, defer_size=1024, force=self._force_read) - - except InvalidDicomError: - result = ValidationResult(file_path=file_path, status=Status.InvalidFile) - self.handle_error(result) - else: - result = IODValidator( - data_set, - self._dicom_info, - log_level=self.log_level, - suppress_vr_warnings=self._suppress_vr_warnings, - error_handler=self._error_handler, - file_path=file_path, - ).validate() - finally: - config.settings.reading_validation_mode = reading_mode + with set_validation_mode(config.IGNORE): + try: + # dcmread calls validate_value by default. If values don't match + # required VR (value representation), it emits a warning but + # does not provide the tag and value that caused the warning. + # We will handle it later (optionally) by calling validate_value + # directly. + data_set = dcmread(file_path, defer_size=1024, force=self._force_read) + + except InvalidDicomError: + result = ValidationResult( + file_path=file_path, status=Status.InvalidFile + ) + self.handle_error(result) + else: + result = IODValidator( + data_set, + self._dicom_info, + log_level=self.log_level, + suppress_vr_warnings=self._suppress_vr_warnings, + error_handler=self._error_handler, + file_path=file_path, + ).validate() return {file_path: result} def handle_error(self, result: ValidationResult) -> None: From c2846aee3ebf97b0d838ef4886aae8384f135fcc Mon Sep 17 00:00:00 2001 From: Jeff <138259519+jdotc1@users.noreply.github.com> Date: Thu, 22 Oct 2026 10:45:24 -0400 Subject: [PATCH 3/3] Clarify reading validation mode context manager name --- .../tests/validator/test_dicom_file_validator.py | 6 +++--- dicom_validator/validator/dicom_file_validator.py | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/dicom_validator/tests/validator/test_dicom_file_validator.py b/dicom_validator/tests/validator/test_dicom_file_validator.py index f7ac9bd..272fa0c 100644 --- a/dicom_validator/tests/validator/test_dicom_file_validator.py +++ b/dicom_validator/tests/validator/test_dicom_file_validator.py @@ -8,7 +8,7 @@ from dicom_validator.validator.dicom_file_validator import ( DicomFileValidator, - set_validation_mode, + set_reading_validation_mode, ) from dicom_validator.validator.dicom_info import DicomInfo from dicom_validator.validator.error_handler import NullValidationResultHandler @@ -205,11 +205,11 @@ def fail_handler(result): @pytest.mark.parametrize("temporary_mode", [config.IGNORE, config.WARN, config.RAISE]) def test_validation_mode_context_restores_nested_modes(reading_mode, temporary_mode): writing_mode = config.settings.writing_validation_mode - with set_validation_mode(temporary_mode): + with set_reading_validation_mode(temporary_mode): assert config.settings.reading_validation_mode == temporary_mode with ( pytest.raises(RuntimeError, match="inner failure"), - set_validation_mode(config.IGNORE), + set_reading_validation_mode(config.IGNORE), ): assert config.settings.reading_validation_mode == config.IGNORE raise RuntimeError("inner failure") diff --git a/dicom_validator/validator/dicom_file_validator.py b/dicom_validator/validator/dicom_file_validator.py index 555b6a5..848056a 100644 --- a/dicom_validator/validator/dicom_file_validator.py +++ b/dicom_validator/validator/dicom_file_validator.py @@ -17,7 +17,7 @@ @contextmanager -def set_validation_mode(mode: int) -> Iterator[None]: +def set_reading_validation_mode(mode: int) -> Iterator[None]: """Temporarily set pydicom's process-wide reading validation mode. Restore the previous mode on exit, including when the body raises. @@ -130,7 +130,7 @@ def validate_file(self, file_path: str) -> dict[str, ValidationResult]: dataset validation and result handling finish, including deferred reads. This is not thread-safe with concurrent pydicom reads. """ - with set_validation_mode(config.IGNORE): + with set_reading_validation_mode(config.IGNORE): try: # dcmread calls validate_value by default. If values don't match # required VR (value representation), it emits a warning but