nci-cidc-api-modules 1.2.54__py3-none-any.whl → 1.2.55__py3-none-any.whl

cidc_api/models/pydantic/stage2/comorbidity.py

@@ -1,11 +1,13 @@
-from typing import Self
+from typing import Any
 
-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 ICD10CMCode, ICD10CMTerm
 
 
+@forced_validators
 class Comorbidity(Base):
     __data_category__ = "comorbidity"
     __cardinality__ = "many"
@@ -27,10 +29,15 @@ class Comorbidity(Base):
     # A descriptive string that names or briefly describes the comorbidity.
     comorbidity_other: str | None = None
 
-    @model_validator(mode="after")
-    def validate_code_or_term_or_other_cr(self) -> Self:
-        if not self.comorbidity_code and not self.comorbidity_term and not self.comorbidity_other:
-            raise ValueError(
-                'Please provide at least one of "comorbidity_code", "comorbidity_term" or "comorbidity_other".'
+    @forced_validator
+    @classmethod
+    def validate_code_or_term_or_other_cr(cls, data, info) -> None:
+        comorbidity_term = data.get("comorbidity_term", None)
+        comorbidity_other = data.get("comorbidity_other", None)
+        comorbidity_code = data.get("comorbidity_code", None)
+
+        if not comorbidity_code and not comorbidity_term and not comorbidity_other:
+            raise ValueLocError(
+                'Please provide at least one of "comorbidity_code", "comorbidity_term" or "comorbidity_other".',
+                loc="comorbidity_code,comorbidity_term,comorbidity_other",
             )
-        return self

cidc_api/models/pydantic/stage2/demographic.py

@@ -1,7 +1,9 @@
-from typing import Self, Annotated, List
+from typing import Annotated, List
 
-from pydantic import PositiveInt, NonNegativeFloat, PositiveFloat, model_validator, field_validator, BeforeValidator
+from pydantic import PositiveInt, NonNegativeFloat, PositiveFloat, BeforeValidator
+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 (
     Sex,
@@ -17,6 +19,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class Demographic(Base):
     __data_category__ = "demographic"
     __cardinality__ = "one"
@@ -91,34 +94,48 @@ class Demographic(Base):
     # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=2681552%20and%20ver_nr=1
     highest_level_of_education: Education | None = None
 
-    @model_validator(mode="after")
-    def validate_age_at_enrollment_cr(self) -> Self:
-        if self.age_90_or_over == "Yes":
-            if self.age_at_enrollment or self.age_at_enrollment_units:
-                raise ValueError(
-                    'If "age_90_or_over" is "Yes" then "age_at_enrollment" and "age_at_enrollment_units" must be blank.'
+    @forced_validator
+    @classmethod
+    def validate_age_at_enrollment_cr(cls, data, info) -> None:
+        age_at_enrollment_units = data.get("age_at_enrollment_units", None)
+        age_90_or_over = data.get("age_90_or_over", None)
+        age_at_enrollment = int(data.get("age_at_enrollment", None) or 0)
+
+        if age_90_or_over == "Yes":
+            if age_at_enrollment or age_at_enrollment_units:
+                raise ValueLocError(
+                    'If "age_90_or_over" is "Yes" then "age_at_enrollment" and "age_at_enrollment_units" must be blank.',
+                    loc="age_at_enrollment",
                 )
-        elif self.age_90_or_over == "No":
-            if not self.age_at_enrollment or not self.age_at_enrollment_units:
-                raise ValueError(
-                    'If "age_90_or_over" is "No" then "age_at_enrollment" and "age_at_enrollment_units" are required.'
+        elif age_90_or_over == "No":
+            if not age_at_enrollment or not age_at_enrollment_units:
+                raise ValueLocError(
+                    'If "age_90_or_over" is "No" then "age_at_enrollment" and "age_at_enrollment_units" are required.',
+                    loc="age_at_enrollment",
                 )
-        return self
 
-    @model_validator(mode="after")
-    def validate_age_at_enrollment_value(self) -> Self:
-        if self.age_90_or_over == "No":
-            age_in_years = (
-                self.age_at_enrollment if self.age_at_enrollment_units == "Years" else self.age_at_enrollment / 365.25
-            )
+    @forced_validator
+    @classmethod
+    def validate_age_at_enrollment_value(cls, data, info) -> None:
+        age_at_enrollment_units = data.get("age_at_enrollment_units", None)
+        age_90_or_over = data.get("age_90_or_over", None)
+        age_at_enrollment = int(data.get("age_at_enrollment", None) or 0)
+
+        if age_90_or_over == "No":
+            age_in_years = age_at_enrollment if age_at_enrollment_units == "Years" else age_at_enrollment / 365.25
             if age_in_years >= 90:
-                raise ValueError('"age_at_enrollment" cannot represent a value greater than 90 years of age.')
-        return self
-
-    @model_validator(mode="after")
-    def validate_body_surface_area_units_cr(self) -> Self:
-        if self.body_surface_area and not self.body_surface_area_units:
-            raise ValueError(
-                'If "body_surface_area" is provided then "body_surface_area_units_other" must also be provided.'
+                raise ValueLocError(
+                    '"age_at_enrollment" cannot represent a value greater than 90 years of age.',
+                    loc="age_at_enrollment",
+                )
+
+    @forced_validator
+    @classmethod
+    def validate_body_surface_area_units_cr(cls, data, info) -> None:
+        body_surface_area = data.get("body_surface_area", None)
+        body_surface_area_units = data.get("body_surface_area_units", None)
+
+        if body_surface_area and not body_surface_area_units:
+            raise ValueLocError(
+                'If "body_surface_area" is provided then "body_surface_area_units" must also be provided.'
             )
-        return self

cidc_api/models/pydantic/stage2/disease.py

@@ -1,6 +1,9 @@
-from pydantic import NonPositiveInt, model_validator, BeforeValidator
-from typing import List, Self, Annotated, get_args
+from pydantic import NonPositiveInt, BeforeValidator
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 
+from typing import List, Self, Annotated, get_args, Any
+
+from cidc_api.models.errors import ValueLocError
 from cidc_api.models.pydantic.base import Base
 from cidc_api.models.types import (
     TumorGrade,
@@ -20,6 +23,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class Disease(Base):
     __data_category__ = "disease"
     __cardinality__ = "many"
@@ -92,67 +96,105 @@ class Disease(Base):
 
     extramedullary_organ: Annotated[List[UberonAnatomicalTerm] | None, BeforeValidator(Base.split_list)] = []
 
-    @model_validator(mode="after")
-    def validate_code_or_term_or_description_cr(self) -> Self:
-        if not self.morphological_code and not self.morphological_term and not self.cancer_type_description:
-            raise ValueError(
-                'Please provide at least one of "morphological_code", "morphological_term" or "cancer_type_description".'
+    @forced_validator
+    @classmethod
+    def validate_code_or_term_or_description_cr(cls, data, info) -> None:
+        morphological_term = data.get("morphological_term", None)
+        cancer_type_description = data.get("cancer_type_description", None)
+        morphological_code = data.get("morphological_code", None)
+
+        if not morphological_code and not morphological_term and not cancer_type_description:
+            raise ValueLocError(
+                'Please provide at least one of "morphological_code", "morphological_term" or "cancer_type_description".',
+                loc="morphological_code",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_cancer_stage_system_version(self) -> Self:
-        msg = f"{self.cancer_stage_system_version} is not applicable to {self.cancer_stage_system}"
-        if self.cancer_stage_system == "AJCC" and self.cancer_stage_system_version not in get_args(
-            CancerStageSystemVersionAJCC
-        ):
-            raise ValueError(msg)
-        elif self.cancer_stage_system == "RISS" and self.cancer_stage_system_version not in get_args(
+    @forced_validator
+    @classmethod
+    def validate_cancer_stage_system_version(cls, data, info) -> None:
+        cancer_stage_system_version = data.get("cancer_stage_system_version", None)
+        cancer_stage_system = data.get("cancer_stage_system", None)
+
+        msg = f"{cancer_stage_system_version} is not applicable to {cancer_stage_system}"
+        if cancer_stage_system == "AJCC" and cancer_stage_system_version not in get_args(CancerStageSystemVersionAJCC):
+            raise ValueLocError(msg, loc="cancer_stage_system")
+        elif cancer_stage_system == "RISS" and cancer_stage_system_version not in get_args(
             CancerStageSystemVersionRISS
         ):
-            raise ValueError(msg)
-        elif self.cancer_stage_system == "FIGO" and self.cancer_stage_system_version not in get_args(
+            raise ValueLocError(msg, loc="cancer_stage_system")
+        elif cancer_stage_system == "FIGO" and cancer_stage_system_version not in get_args(
             CancerStageSystemVersionFIGO
         ):
-            raise ValueError(msg)
-        return self
-
-    @model_validator(mode="after")
-    def validate_cancer_stage_system_version_cr(self) -> Self:
-        if self.cancer_stage_system != "Not Applicable" and not self.cancer_stage_system_version:
-            raise ValueError(
-                f'Please provide cancer_stage_system_version when cancer_stage_system is "{self.cancer_stage_system}"'
+            raise ValueLocError(msg, loc="cancer_stage_system")
+
+    @forced_validator
+    @classmethod
+    def validate_cancer_stage_system_version_cr(cls, data, info) -> None:
+        cancer_stage_system = data.get("cancer_stage_system", None)
+        cancer_stage_system_version = data.get("cancer_stage_system_version", None)
+
+        if cancer_stage_system != "Not Applicable" and not cancer_stage_system_version:
+            raise ValueLocError(
+                f'Please provide cancer_stage_system_version when cancer_stage_system is "{cancer_stage_system}"',
+                loc="cancer_stage_system_version",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_cancer_stage_cr(cls, data, info) -> None:
+        cancer_stage_system = data.get("cancer_stage_system", None)
+        cancer_stage = data.get("cancer_stage", None)
+
+        if cancer_stage_system != "Not Applicable" and not cancer_stage:
+            raise ValueLocError(
+                f'Please provide cancer_stage when cancer_stage_system is "{cancer_stage_system}"',
+                loc="cancer_stage",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_t_category_cr(cls, data, info) -> None:
+        cancer_stage_system = data.get("cancer_stage_system", None)
+        t_category = data.get("t_category", None)
+
+        if cancer_stage_system == "AJCC" and not t_category:
+            raise ValueLocError(
+                f'Please provide t_category when cancer_stage_system is "{cancer_stage_system}"',
+                loc="t_category",
             )
-        return self
-
-    @model_validator(mode="after")
-    def validate_cancer_stage_cr(self) -> Self:
-        if self.cancer_stage_system != "Not Applicable" and not self.cancer_stage:
-            raise ValueError(f'Please provide cancer_stage when cancer_stage_system is "{self.cancer_stage_system}"')
-        return self
-
-    @model_validator(mode="after")
-    def validate_t_category_cr(self) -> Self:
-        if self.cancer_stage_system == "AJCC" and not self.t_category:
-            raise ValueError(f'Please provide t_category when cancer_stage_system is "{self.cancer_stage_system}"')
-        return self
-
-    @model_validator(mode="after")
-    def validate_n_category_cr(self) -> Self:
-        if self.cancer_stage_system == "AJCC" and not self.n_category:
-            raise ValueError(f'Please provide n_category when cancer_stage_system is "{self.cancer_stage_system}"')
-        return self
-
-    @model_validator(mode="after")
-    def validate_m_category_cr(self) -> Self:
-        if self.cancer_stage_system == "AJCC" and not self.m_category:
-            raise ValueError(f'Please provide m_category when cancer_stage_system is "{self.cancer_stage_system}"')
-        return self
-
-    @model_validator(mode="after")
-    def validate_extramedullary_organ_cr(self) -> Self:
-        if self.solely_extramedullary_disease in ["No", "Unknown"] and self.extramedullary_organ:
-            raise ValueError(
-                "If solely_extramedullary_disease indicates no disease, please leave extramedullary_organ blank."
+
+    @forced_validator
+    @classmethod
+    def validate_n_category_cr(cls, data, info) -> None:
+        cancer_stage_system = data.get("cancer_stage_system", None)
+        n_category = data.get("n_category", None)
+
+        if cancer_stage_system == "AJCC" and not n_category:
+            raise ValueLocError(
+                f'Please provide n_category when cancer_stage_system is "{cancer_stage_system}"',
+                loc="n_category",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_m_category_cr(cls, data, info) -> None:
+        cancer_stage_system = data.get("cancer_stage_system", None)
+        m_category = data.get("m_category", None)
+
+        if cancer_stage_system == "AJCC" and not m_category:
+            raise ValueLocError(
+                f'Please provide m_category when cancer_stage_system is "{cancer_stage_system}"',
+                loc="m_category",
+            )
+
+    @forced_validator
+    @classmethod
+    def validate_extramedullary_organ_cr(cls, data, info) -> None:
+        solely_extramedullary_disease = data.get("solely_extramedullary_disease", None)
+        extramedullary_organ = data.get("extramedullary_organ", None)
+
+        if solely_extramedullary_disease in ["No", "Unknown"] and extramedullary_organ:
+            raise ValueLocError(
+                "If solely_extramedullary_disease indicates no disease, please leave extramedullary_organ blank.",
+                loc="extramedullary_organ",
             )
-        return self

cidc_api/models/pydantic/stage2/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/stage2/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/stage2/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/stage2/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"
@@ -16,7 +16,7 @@ class Participant(Base):
     participant_id: str | None = None
 
     # The participant identifier assigned by the clinical trial team overseeing the study
-    native_participant_id: str
+    native_participant_id: str | None = None
 
     # The globally unique participant identifier assigned by the CIMAC network. e.g. C8P29A7
     cimac_participant_id: str | None = None
@@ -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/stage2/prior_treatment.py

@@ -24,6 +24,8 @@ class PriorTreatment(Base):
     # the treatment modality.
     prior_treatment_days_to_end: NonPositiveInt | None = None
 
+    # Specifies the category or kind of prior treatment modality a participant received.
+
     # Description of the prior treatment such as its full generic name if it is a type of therapy agent,
     # radiotherapy procedure name and location, or surgical procedure name and location.
     prior_treatment_description: str

cidc_api/models/pydantic/stage2/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 (
     YN,
@@ -13,6 +13,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class RadiotherapyDose(Base):
     __data_category__ = "radiotherapy_dose"
     __cardinality__ = "many"
@@ -67,14 +68,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/stage2/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, YN, YNUNA, CauseOfDeath
+from cidc_api.models.types import SurvivalStatus, YNUNA, YN, CauseOfDeath
 
 
+@forced_validators
 class Response(Base):
     __data_category__ = "response"
     __cardinality__ = "one"
@@ -44,22 +45,40 @@ class Response(Base):
     evaluable_for_efficacy: YN
 
     # 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",
+            )