nci-cidc-api-modules 1.2.45__py3-none-any.whl → 1.2.53__py3-none-any.whl

cidc_api/models/pydantic/stage1/exposure.py

@@ -1,11 +1,11 @@
-from typing import Self
-
-from pydantic import model_validator
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import YNU, ExposureType
 
 
+@forced_validators
 class Exposure(Base):
     __data_category__ = "exposure"
     __cardinality__ = "many"
@@ -25,8 +25,14 @@ class Exposure(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=15753203%20and%20ver_nr=1
     exposure_type: ExposureType | None = None
 
-    @model_validator(mode="after")
-    def validate_exposure_type_cr(self) -> Self:
-        if self.carcinogen_exposure in ["No", "Unknown"] and self.exposure_type:
-            raise ValueError("If carcinogen_exposure indicates non exposure, please leave exposure_type blank.")
-        return self
+    @forced_validator
+    @classmethod
+    def validate_exposure_type_cr(cls, data, info) -> None:
+        carcinogen_exposure = data.get("carcinogen_exposure", None)
+        exposure_type = data.get("exposure_type", None)
+
+        if carcinogen_exposure in ["No", "Unknown"] and exposure_type:
+            raise ValueLocError(
+                "If carcinogen_exposure indicates non exposure, please leave exposure_type blank.",
+                loc="exposure_type",
+            )

cidc_api/models/pydantic/stage1/medical_history.py

@@ -1,11 +1,12 @@
-from typing import Self
-
-from pydantic import NonNegativeInt, PositiveFloat, model_validator
+from pydantic import NonNegativeInt, PositiveFloat
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import TobaccoSmokingStatus
 
 
+@forced_validators
 class MedicalHistory(Base):
     __data_category__ = "medical_history"
     __cardinality__ = "one"
@@ -29,8 +30,14 @@ class MedicalHistory(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=16089302%20and%20ver_nr=1
     num_prior_systemic_therapies: NonNegativeInt | None = None
 
-    @model_validator(mode="after")
-    def validate_pack_years_smoked_cr(self) -> Self:
-        if self.tobacco_smoking_status in ["Never Smoker", "Unknown", "Not reported"] and self.pack_years_smoked:
-            raise ValueError("If tobacco_smoking_status indicates non-smoker, please leave pack_years_smoked blank.")
-        return self
+    @forced_validator
+    @classmethod
+    def validate_pack_years_smoked_cr(cls, data, info) -> None:
+        tobacco_smoking_status = data.get("tobacco_smoking_status", None)
+        pack_years_smoked = data.get("pack_years_smoked", None)
+
+        if tobacco_smoking_status in ["Never Smoker", "Unknown", "Not reported"] and pack_years_smoked:
+            raise ValueLocError(
+                "If tobacco_smoking_status indicates non-smoker, please leave pack_years_smoked blank.",
+                loc="pack_years_smoked",
+            )

cidc_api/models/pydantic/stage1/other_malignancy.py

@@ -1,11 +1,12 @@
-from typing import Self
-
-from pydantic import NonPositiveInt, model_validator
+from pydantic import NonPositiveInt
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import UberonAnatomicalTerm, ICDO3MorphologicalCode, ICDO3MorphologicalTerm, MalignancyStatus
 
 
+@forced_validators
 class OtherMalignancy(Base):
     __data_category__ = "other_malignancy"
     __cardinality__ = "many"
@@ -36,14 +37,19 @@ class OtherMalignancy(Base):
     # Indicates the participant’s current clinical state regarding the cancer diagnosis.
     other_malignancy_status: MalignancyStatus | None = None
 
-    @model_validator(mode="after")
-    def validate_code_or_term_or_description_cr(self) -> Self:
+    @forced_validator
+    @classmethod
+    def validate_code_or_term_or_description_cr(cls, data, info) -> None:
+        other_malignancy_morphological_term = data.get("other_malignancy_morphological_term", None)
+        other_malignancy_description = data.get("other_malignancy_description", None)
+        other_malignancy_morphological_code = data.get("other_malignancy_morphological_code", None)
+
         if (
-            not self.other_malignancy_morphological_code
-            and not self.other_malignancy_morphological_term
-            and not self.other_malignancy_description
+            not other_malignancy_morphological_code
+            and not other_malignancy_morphological_term
+            and not other_malignancy_description
         ):
-            raise ValueError(
-                'Please provide at least one of "morphological_code", "morphological_term" or "malignancy_description".'
+            raise ValueLocError(
+                'Please provide at least one of "morphological_code", "morphological_term" or "malignancy_description".',
+                loc="other_malignancy_morphological_code",
             )
-        return self

cidc_api/models/pydantic/stage1/participant.py

@@ -1,12 +1,12 @@
-from typing import Self
-
-from pydantic import model_validator
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import YNU
 from cidc_api.models.types import OffStudyReason
 
 
+@forced_validators
 class Participant(Base):
     __data_category__ = "participant"
     __cardinality__ = "one"
@@ -38,14 +38,26 @@ class Participant(Base):
     # Additional information if "Other" is selected for off_study_reason. e.g. "Transfer to another study"
     off_study_reason_other: str | None = None
 
-    @model_validator(mode="after")
-    def off_study_reason_cr(self) -> Self:
-        if self.off_study == "Yes" and not self.off_study_reason:
-            raise ValueError('If "off_study" is "Yes" then "off_study_reason" is required.')
-        return self
-
-    @model_validator(mode="after")
-    def off_study_reason_other_cr(self) -> Self:
-        if self.off_study_reason == "Other" and not self.off_study_reason_other:
-            raise ValueError('If "off_study_reason" is "Other" then "off_study_reason_other" is required.')
-        return self
+    @forced_validator
+    @classmethod
+    def off_study_reason_cr(cls, data, info) -> None:
+        off_study = data.get("off_study", None)
+        off_study_reason = data.get("off_study_reason", None)
+
+        if off_study == "Yes" and not off_study_reason:
+            raise ValueLocError(
+                'If "off_study" is "Yes" then "off_study_reason" is required.',
+                loc="off_study_reason",
+            )
+
+    @forced_validator
+    @classmethod
+    def off_study_reason_other_cr(cls, data, info) -> None:
+        off_study_reason_other = data.get("off_study_reason_other", None)
+        off_study_reason = data.get("off_study_reason", None)
+
+        if off_study_reason == "Other" and not off_study_reason_other:
+            raise ValueLocError(
+                'If "off_study_reason" is "Other" then "off_study_reason_other" is required.',
+                loc="off_study_reason_other",
+            )

cidc_api/models/pydantic/stage1/radiotherapy_dose.py

@@ -1,7 +1,7 @@
-from typing import Self
-
-from pydantic import NonNegativeInt, NonNegativeFloat, model_validator
+from pydantic import NonNegativeInt, NonNegativeFloat
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import (
     YNU,
@@ -12,6 +12,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class RadiotherapyDose(Base):
     __data_category__ = "radiotherapy_dose"
     __cardinality__ = "many"
@@ -66,14 +67,26 @@ class RadiotherapyDose(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=7063755%20and%20ver_nr=1
     radiation_extent: RadiationExtent
 
-    @model_validator(mode="after")
-    def validate_changes_delays_description_cr(self) -> Self:
-        if self.dose_changes_delays == "Yes" and not self.changes_delays_description:
-            raise ValueError('If dose_changes_delays is "Yes", please provide changes_delays_description.')
-        return self
-
-    @model_validator(mode="after")
-    def validate_planned_dose_units_cr(self) -> Self:
-        if self.planned_dose and not self.planned_dose_units:
-            raise ValueError("If planned_dose is provided, please provide planned_dose_units.")
-        return self
+    @forced_validator
+    @classmethod
+    def validate_changes_delays_description_cr(cls, data, info) -> None:
+        dose_changes_delays = data.get("dose_changes_delays", None)
+        changes_delays_description = data.get("changes_delays_description", None)
+
+        if dose_changes_delays == "Yes" and not changes_delays_description:
+            raise ValueLocError(
+                'If dose_changes_delays is "Yes", please provide changes_delays_description.',
+                loc="changes_delays_description",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_planned_dose_units_cr(cls, data, info) -> None:
+        planned_dose = data.get("planned_dose", None)
+        planned_dose_units = data.get("planned_dose_units", None)
+
+        if planned_dose and not planned_dose_units:
+            raise ValueLocError(
+                "If planned_dose is provided, please provide planned_dose_units.",
+                loc="planned_dose_units",
+            )

cidc_api/models/pydantic/stage1/response.py

@@ -1,11 +1,12 @@
-from typing import Self
-
-from pydantic import NonNegativeInt, model_validator
+from pydantic import NonNegativeInt
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import SurvivalStatus, YNUNA, CauseOfDeath
 
 
+@forced_validators
 class Response(Base):
     __data_category__ = "response"
     __cardinality__ = "one"
@@ -44,22 +45,40 @@ class Response(Base):
     evaluable_for_efficacy: bool
 
     # Days from enrollment date to the last time the patient's vital status was verified.
-    days_to_last_vital_status: NonNegativeInt | None = None  # TODO: Needs CR check
-
-    @model_validator(mode="after")
-    def validate_cause_of_death_cr(self) -> Self:
-        if self.survival_status == "Dead" and not self.cause_of_death:
-            raise ValueError('If survival_status is "Dead" then cause_of_death is required.')
-        return self
-
-    @model_validator(mode="after")
-    def validate_cause_of_death_cr2(self) -> Self:
-        if self.survival_status == "Alive" and self.cause_of_death:
-            raise ValueError('If survival_status is "Alive", please leave cause_of_death blank.')
-        return self
-
-    @model_validator(mode="after")
-    def validate_days_to_death_cr(self) -> Self:
-        if self.survival_status in ["Alive", "Unknown"] and self.days_to_death:
-            raise ValueError("If survival_status does not indicate death, please leave days_to_death blank.")
-        return self
+    days_to_last_vital_status: NonNegativeInt | None = None
+
+    @forced_validator
+    @classmethod
+    def validate_cause_of_death_cr(cls, data, info) -> None:
+        survival_status = data.get("survival_status", None)
+        cause_of_death = data.get("cause_of_death", None)
+
+        if survival_status == "Dead" and not cause_of_death:
+            raise ValueLocError(
+                'If survival_status is "Dead" then cause_of_death is required.',
+                loc="cause_of_death",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_cause_of_death_cr2(cls, data, info) -> None:
+        survival_status = data.get("survival_status", None)
+        cause_of_death = data.get("cause_of_death", None)
+
+        if survival_status == "Alive" and cause_of_death:
+            raise ValueLocError(
+                'If survival_status is "Alive", please leave cause_of_death blank.',
+                loc="cause_of_death",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_days_to_death_cr(cls, data, info) -> None:
+        survival_status = data.get("survival_status", None)
+        days_to_death = data.get("days_to_death", None)
+
+        if survival_status in ["Alive", "Unknown"] and days_to_death:
+            raise ValueLocError(
+                "If survival_status does not indicate death, please leave days_to_death blank.",
+                loc="days_to_death",
+            )

cidc_api/models/pydantic/stage1/response_by_system.py

@@ -1,8 +1,11 @@
 from typing import Self
 
-from pydantic import PositiveInt, model_validator, NonNegativeInt
+from pydantic import PositiveInt, NonNegativeInt, model_validator
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
+from cidc_api.models.pydantic.stage1.response import Response
 from cidc_api.models.types import ResponseSystem, ResponseSystemVersion, BestOverallResponse, YNUNA
 
 
@@ -17,6 +20,7 @@ negative_response_values = [
 ]
 
 
+@forced_validators
 class ResponseBySystem(Base):
     __data_category__ = "response_by_system"
     __cardinality__ = "many"
@@ -28,6 +32,9 @@ class ResponseBySystem(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=12220014%20and%20ver_nr=1
     participant_id: str | None = None
 
+    # The linked parent response for the participant. Used for cross-model validation.
+    response: Response | None = None
+
     # A standardized method used to evaluate and categorize the participant’s clinical response to treatment based on predefined criteria.
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=13381490%20and%20ver_nr=1
     response_system: ResponseSystem
@@ -66,47 +73,148 @@ class ResponseBySystem(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=5143957%20and%20ver_nr=1
     progression_free_survival: PositiveInt | None = None
 
-    @model_validator(mode="after")
-    def validate_response_duration_cr(self) -> Self:
-        if self.best_overall_response in negative_response_values and self.response_duration:
-            raise ValueError(
+    @forced_validator
+    @classmethod
+    def validate_response_duration_cr(cls, data, info) -> None:
+        best_overall_response = data.get("best_overall_response", None)
+        response_duration = data.get("response_duration", None)
+
+        if best_overall_response in negative_response_values and response_duration:
+            raise ValueLocError(
                 "If best_overall_response does not indicate a positive response, "
-                "please leave response_duration blank."
+                "please leave response_duration blank.",
+                loc="response_duration",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_days_to_first_response_cr(self) -> Self:
-        if self.best_overall_response in negative_response_values and self.days_to_first_response:
-            raise ValueError(
+    @forced_validator
+    @classmethod
+    def validate_days_to_first_response_cr(cls, data, info) -> None:
+        best_overall_response = data.get("best_overall_response", None)
+        days_to_first_response = data.get("days_to_first_response", None)
+
+        if best_overall_response in negative_response_values and days_to_first_response:
+            raise ValueLocError(
                 "If best_overall_response does not indicate a positive response, "
-                "please leave days_to_first_response blank."
+                "please leave days_to_first_response blank.",
+                loc="days_to_first_response",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_days_to_best_response_cr(self) -> Self:
-        if self.best_overall_response in negative_response_values and self.days_to_best_response:
-            raise ValueError(
-                "If best_overall_response does not indicate a positive response, \
-                please leave days_to_best_response blank."
+    @forced_validator
+    @classmethod
+    def validate_days_to_best_response_cr(cls, data, info) -> None:
+        best_overall_response = data.get("best_overall_response", None)
+        days_to_best_response = data.get("days_to_best_response", None)
+
+        if best_overall_response in negative_response_values and days_to_best_response:
+            raise ValueLocError(
+                "If best_overall_response does not indicate a positive response, "
+                "please leave days_to_best_response blank.",
+                loc="days_to_best_response",
             )
-        return self
+
+    @forced_validator
+    @classmethod
+    def validate_days_to_disease_progression_cr(cls, data, info) -> None:
+        progression = data.get("progression", None)
+        days_to_disease_progression = data.get("days_to_disease_progression", None)
+
+        if progression in ["No", "Unknown", "Not Applicable"] and days_to_disease_progression:
+            raise ValueLocError(
+                "If progression does not indicate confirmed progression of the disease, "
+                "please leave days_to_disease_progression blank.",
+                loc="days_to_disease_progression",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_progression_free_survival_cr(cls, data, info) -> None:
+        progression_free_survival_event = data.get("progression_free_survival_event", None)
+        progression_free_survival = data.get("progression_free_survival", None)
+
+        if progression_free_survival_event in ["Unknown", "Not Applicable"] and progression_free_survival:
+            raise ValueLocError(
+                "If progression_free_survival_event is not known, " "please leave progression_free_survival blank.",
+                loc="progression_free_survival",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_days_to_best_response_chronology(cls, data, info) -> None:
+        days_to_first_response = data.get("days_to_first_response", None)
+        days_to_best_response = data.get("days_to_best_response", None)
+
+        if days_to_best_response is not None and days_to_first_response is not None:
+            if int(days_to_best_response) < int(days_to_first_response):
+                raise ValueLocError(
+                    'Violate "days_to_best_response" >= days_to_first_response"',
+                    loc="days_to_best_response",
+                )
+
+    @forced_validator
+    @classmethod
+    def validate_days_to_disease_progression_chronology(cls, data, info) -> None:
+        days_to_disease_progression = data.get("days_to_disease_progression", None)
+        days_to_first_response = data.get("days_to_first_response", None)
+
+        if days_to_first_response is not None and days_to_disease_progression is not None:
+            if int(days_to_first_response) >= int(days_to_disease_progression):
+                raise ValueLocError(
+                    'Violate "days_to_first_response" < "days_to_disease_progression"',
+                    loc="days_to_first_response",
+                )
+
+    @forced_validator
+    @classmethod
+    def validate_days_to_best_response_progression_chronology(cls, data, info) -> None:
+        days_to_disease_progression = data.get("days_to_disease_progression", None)
+        days_to_best_response = data.get("days_to_best_response", None)
+
+        if days_to_best_response is not None and days_to_disease_progression is not None:
+            if int(days_to_best_response) >= int(days_to_disease_progression):
+                raise ValueLocError(
+                    'Violate "days_to_best_response" < "days_to_disease_progression"',
+                    loc="days_to_best_response",
+                )
 
     @model_validator(mode="after")
-    def validate_days_to_disease_progression_cr(self) -> Self:
-        if self.progression in ["No", "Unknown", "Not Applicable"] and self.days_to_disease_progression:
-            raise ValueError(
-                "If progression does not indicate confirmed progression of the disease, \
-                please leave days_to_disease_progress blank."
+    def validate_days_to_last_vital_status_chronology(self) -> Self:
+        if not self.response:
+            return self
+
+        if not self.response.days_to_last_vital_status:
+            return self
+
+        max_value = max(
+            self.response.days_to_last_vital_status or 0,
+            self.days_to_first_response or 0,
+            self.days_to_best_response or 0,
+            self.days_to_disease_progression or 0,
+        )
+        if (self.response.days_to_last_vital_status or 0) != max_value:
+            raise ValueLocError(
+                '"days_to_last_vital_status" is not the max of all events. Rule: days_to_last_vital_status '
+                ">= max(days_to_first_response,days_to_best_response,days_to_disease_progression)",
+                loc="days_to_last_vital_status,days_to_first_response,days_to_best_response,days_to_disease_progression",
             )
         return self
 
     @model_validator(mode="after")
-    def validate_progression_free_survival_cr(self) -> Self:
-        if self.progression_free_survival_event in ["Unknown", "Not Applicable"] and self.progression_free_survival:
-            raise ValueError(
-                "If progression_free_survival_event is not known, \
-                please leave progression_free_survival blank."
+    def validate_days_to_death_chronology(self) -> Self:
+        if not self.response:
+            return self
+        if not self.response.days_to_death:
+            return self
+
+        max_value = max(
+            self.response.days_to_death or 0,
+            self.days_to_first_response or 0,
+            self.days_to_best_response or 0,
+            self.days_to_disease_progression or 0,
+        )
+        if (self.response.days_to_death or 0) != max_value:
+            raise ValueLocError(
+                '"days_to_death" is not the max of all events. Rule: days_to_death'
+                ">= max(days_to_first_response,days_to_best_response,days_to_disease_progression)",
+                loc="days_to_death,days_to_first_response,days_to_best_response,days_to_disease_progression",
             )
         return self

cidc_api/models/pydantic/stage1/surgery.py

@@ -1,11 +1,13 @@
-from typing import Self
+from pydantic import NonNegativeInt
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
-from pydantic import NonNegativeInt, model_validator
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import SurgicalProcedure, UberonAnatomicalTerm, YNU
 
 
+@forced_validators
 class Surgery(Base):
     __data_category__ = "surgery"
     __cardinality__ = "many"
@@ -42,8 +44,14 @@ class Surgery(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=13362284%20and%20ver_nr=1
     extent_of_residual_disease: str | None = None
 
-    @model_validator(mode="after")
-    def validate_procedure_other_cr(self) -> Self:
-        if self.procedure == "Other, specify" and not self.procedure_other:
-            raise ValueError('If procedure is "Other, specify", please provide procedure_other.')
-        return self
+    @forced_validator
+    @classmethod
+    def validate_procedure_other_cr(cls, data, info) -> None:
+        procedure = data.get("procedure", None)
+        procedure_other = data.get("procedure_other", None)
+
+        if procedure == "Other, specify" and not procedure_other:
+            raise ValueLocError(
+                'If procedure is "Other, specify", please provide procedure_other.',
+                loc="procedure_other",
+            )

cidc_api/models/pydantic/stage1/therapy_agent_dose.py

@@ -1,11 +1,12 @@
-from typing import Self
-
-from pydantic import NonNegativeInt, NonNegativeFloat, PositiveFloat, model_validator
+from pydantic import NonNegativeInt, NonNegativeFloat, PositiveFloat
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import YNU, TherapyAgentDoseUnits
 
 
+@forced_validators
 class TherapyAgentDose(Base):
     __data_category__ = "therapy_agent_dose"
     __cardinality__ = "many"
@@ -54,14 +55,26 @@ class TherapyAgentDose(Base):
     # Description of the dose changes, misses, or delays.
     changes_delays_description: str | None = None
 
-    @model_validator(mode="after")
-    def validate_changes_delays_description_cr(self) -> Self:
-        if self.dose_changes_delays == "Yes" and not self.changes_delays_description:
-            raise ValueError('If dose_changes_delays is "Yes", please provide changes_delays_description.')
-        return self
-
-    @model_validator(mode="after")
-    def validate_planned_dose_units_cr(self) -> Self:
-        if self.planned_dose and not self.planned_dose_units:
-            raise ValueError("If planned_dose is provided, please provide planned_dose_units.")
-        return self
+    @forced_validator
+    @classmethod
+    def validate_changes_delays_description_cr(cls, data, info) -> None:
+        dose_changes_delays = data.get("dose_changes_delays", None)
+        changes_delays_description = data.get("changes_delays_description", None)
+
+        if dose_changes_delays == "Yes" and not changes_delays_description:
+            raise ValueLocError(
+                'If dose_changes_delays is "Yes", please provide changes_delays_description.',
+                loc="changes_delays_description",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_planned_dose_units_cr(cls, data, info) -> None:
+        planned_dose = data.get("planned_dose", None)
+        planned_dose_units = data.get("planned_dose_units", None)
+
+        if planned_dose and not planned_dose_units:
+            raise ValueLocError(
+                "If planned_dose is provided, please provide planned_dose_units.",
+                loc="planned_dose_units",
+            )