nci-cidc-api-modules 1.2.51__py3-none-any.whl → 1.2.52__py3-none-any.whl

cidc_api/__init__.py

@@ -1 +1 @@
-__version__ = "1.2.51"
+__version__ = "1.2.52"

cidc_api/models/pydantic/base.py

@@ -1,7 +1,11 @@
-from pydantic import BaseModel, ConfigDict
+import copy
 from contextlib import contextmanager
+from typing import Self, ClassVar
+from pydantic import BaseModel, ConfigDict, model_validator, ValidationError
+from pydantic_core import InitErrorDetails
 
-import copy
+from cidc_api.models.errors import ValueLocError
+from functools import wraps
 
 
 class Base(BaseModel):
@@ -11,6 +15,7 @@ class Base(BaseModel):
         from_attributes=True,
         extra="allow",
     )
+    forced_validators: ClassVar = []
 
     # Validates the new state and updates the object if valid
     def update(self, **kwargs):
@@ -33,6 +38,8 @@ class Base(BaseModel):
             self.__dict__.update(original_dict)
             raise
 
+        # CM that delays validation until all fields are applied.
+
     @classmethod
     def split_list(cls, val):
         """Listify fields that are multi-valued in input data, e.g. 'lung|kidney'"""
@@ -46,3 +53,57 @@ class Base(BaseModel):
             return []
         else:
             raise ValueError("Field value must be string or list")
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def check_all_forced_validators(cls, data, handler, info) -> Self:
+        """This base validator ensures all registered forced_validator(s) get called along with
+        normal model field validators no matter what the outcome of either is. Normal field_validator
+        and model_validator decorators don't guarantee this. We want to collect as many errors as we can.
+
+        Collects errors from both attempts and raises them in a combined ValidationError."""
+
+        validation_errors = []
+        # When assigning attributes to an already-hydrated model, data is an instance of the model
+        # instead of a dict and handler is an AssignmentValidatorCallable instead of a ValidatorCallable(!!)
+        extracted_data = data.model_dump() if not isinstance(data, dict) else data
+
+        for validator in cls.forced_validators:
+            try:
+                func_name = validator.__name__
+                func = getattr(cls, func_name)
+                func(extracted_data, info)
+            except (ValueError, ValueLocError) as e:
+                validation_errors.append(
+                    InitErrorDetails(
+                        type="value_error",
+                        loc=e.loc,
+                        input=extracted_data,
+                        ctx={"error": e},
+                    )
+                )
+        try:
+            # Instantiate the model to ensure all other normal field validations are called
+            retval = handler(data)
+        except ValidationError as e:
+            validation_errors.extend(e.errors())
+        if validation_errors:
+            raise ValidationError.from_exception_data(title=cls.__name__, line_errors=validation_errors)
+        return retval
+
+
+def forced_validator(func):
+    """A method marked with this decorator is added to the class list of forced_validators"""
+    func._is_forced_validator = True  # Tag the function object with a custom attribute
+    return func
+
+
+def forced_validators(cls):
+    """A class marked with this decorator accumulates its methods marked with force_validator into a list
+    for later invocation."""
+
+    cls.forced_validators = []
+    for obj in cls.__dict__.values():
+        if getattr(obj, "_is_forced_validator", False):
+            cls.forced_validators.append(obj)
+    return cls

cidc_api/models/pydantic/stage1/adverse_event.py

@@ -1,9 +1,8 @@
-from typing import Self
-
-from pydantic import Field, NonNegativeInt, model_validator
+from pydantic import NonNegativeInt
 
 from cidc_api.models.pydantic.base import Base
 from cidc_api.reference.ctcae import is_ctcae_other_term
+from cidc_api.models.pydantic.base import forced_validator, forced_validators
 from cidc_api.models.errors import ValueLocError
 from cidc_api.models.types import (
     CTCAEEventTerm,
@@ -18,6 +17,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class AdverseEvent(Base):
     __data_category__ = "adverse_event"
     __cardinality__ = "many"
@@ -76,44 +76,52 @@ class AdverseEvent(Base):
     # The individual therapy (therapy agent, radiotherapy, surgery, stem cell transplant) in the treatment that is attributed to the adverse event.
     individual_therapy: str | None = None
 
-    @model_validator(mode="after")
-    def validate_term_and_code_cr(self) -> Self:
-        if not self.event_term and not self.event_code:
+    @forced_validator
+    @classmethod
+    def validate_term_and_code_cr(cls, data, info) -> None:
+        event_code = data.get("event_code", None)
+        event_term = data.get("event_term", None)
+
+        if not event_term and not event_code:
             raise ValueLocError(
                 "Please provide event_term or event_code or both",
-                loc="event_term",
+                loc="event_term,event_code",
             )
-        return self
-
-    @model_validator(mode="after")
-    def validate_event_other_specify_cr(self) -> Self:
-        if (
-            self.severity_grade_system == "CTCAE"
-            and is_ctcae_other_term(self.event_term)
-            and not self.event_other_specify
-        ):
+
+    @forced_validator
+    @classmethod
+    def validate_event_other_specify_cr(cls, data, info) -> None:
+        event_other_specify = data.get("event_other_specify", None)
+        severity_grade_system = data.get("severity_grade_system", None)
+        event_term = data.get("event_term", None)
+
+        if severity_grade_system == "CTCAE" and is_ctcae_other_term(event_term) and not event_other_specify:
             raise ValueLocError(
                 'If severity_grade_system is "CTCAE" and the event_code or event_term are of type '
                 '"Other, specify", please provide event_other_specify',
                 loc="event_other_specify",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_system_organ_class_cr(self) -> Self:
-        if self.event_other_specify and not self.system_organ_class:
+    @forced_validator
+    @classmethod
+    def validate_system_organ_class_cr(cls, data, info) -> None:
+        event_other_specify = data.get("event_other_specify", None)
+        system_organ_class = data.get("system_organ_class", None)
+
+        if event_other_specify and not system_organ_class:
             raise ValueLocError(
-                "If event_other_specify is provided, please provide system_organ_class.",
-                loc="system_organ_class",
+                "If event_other_specify is provided, please provide system_organ_class.", loc="system_organ_class"
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_days_to_resolution_of_event_chronology(self) -> Self:
-        if self.days_to_resolution_of_event is not None and self.days_to_onset_of_event is not None:
-            if self.days_to_resolution_of_event < self.days_to_onset_of_event:
+    @forced_validator
+    @classmethod
+    def validate_days_to_resolution_of_event_chronology(cls, data, info) -> None:
+        days_to_onset_of_event = data.get("days_to_onset_of_event", None)
+        days_to_resolution_of_event = data.get("days_to_resolution_of_event", None)
+
+        if days_to_resolution_of_event is not None and days_to_onset_of_event is not None:
+            if int(days_to_resolution_of_event) < int(days_to_onset_of_event):
                 raise ValueLocError(
                     'Violate "days_to_onset_of_event" <= "days_to_resolution_of_event"',
                     loc="days_to_resolution_of_event",
                 )
-        return self

cidc_api/models/pydantic/stage1/comorbidity.py

@@ -1,12 +1,13 @@
-from typing import Self, Any
+from typing import Any
 
-from pydantic import model_validator, field_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"
@@ -28,11 +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:
+    @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",
+                loc="comorbidity_code,comorbidity_term,comorbidity_other",
             )
-        return self

cidc_api/models/pydantic/stage1/demographic.py

@@ -1,6 +1,7 @@
-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
@@ -17,6 +18,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class Demographic(Base):
     __data_category__ = "demographic"
     __cardinality__ = "one"
@@ -91,40 +93,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:
-            if self.age_at_enrollment or self.age_at_enrollment_units:
+    @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:
+            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",
                 )
         else:
-            if not self.age_at_enrollment or not self.age_at_enrollment_units:
+            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_units",
+                    loc="age_at_enrollment",
                 )
-        return self
 
-    @model_validator(mode="after")
-    def validate_age_at_enrollment_value(self) -> Self:
-        if not self.age_90_or_over:
-            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 not age_90_or_over:
+            age_in_years = age_at_enrollment if age_at_enrollment_units == "Years" else age_at_enrollment / 365.25
             if age_in_years >= 90:
                 raise ValueLocError(
                     '"age_at_enrollment" cannot represent a value greater than 90 years of age.',
                     loc="age_at_enrollment",
                 )
-        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:
+    @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_other" must also be provided.',
-                loc="body_surface_area_units_other",
+                'If "body_surface_area" is provided then "body_surface_area_units" must also be provided.'
             )
-        return self

cidc_api/models/pydantic/stage1/disease.py

@@ -1,5 +1,7 @@
-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
@@ -21,6 +23,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class Disease(Base):
     __data_category__ = "disease"
     __cardinality__ = "many"
@@ -93,82 +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:
+    @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
-        ):
+    @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 self.cancer_stage_system == "RISS" and self.cancer_stage_system_version not in get_args(
+        elif cancer_stage_system == "RISS" and cancer_stage_system_version not in get_args(
             CancerStageSystemVersionRISS
         ):
             raise ValueLocError(msg, loc="cancer_stage_system")
-        elif self.cancer_stage_system == "FIGO" and self.cancer_stage_system_version not in get_args(
+        elif cancer_stage_system == "FIGO" and cancer_stage_system_version not in get_args(
             CancerStageSystemVersionFIGO
         ):
             raise ValueLocError(msg, loc="cancer_stage_system")
-        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:
+    @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 "{self.cancer_stage_system}"',
+                f'Please provide cancer_stage_system_version when cancer_stage_system is "{cancer_stage_system}"',
                 loc="cancer_stage_system_version",
             )
-        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:
+    @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 "{self.cancer_stage_system}"',
+                f'Please provide cancer_stage when cancer_stage_system is "{cancer_stage_system}"',
                 loc="cancer_stage",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_t_category_cr(self) -> Self:
-        if self.cancer_stage_system == "AJCC" and not self.t_category:
+    @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 "{self.cancer_stage_system}"',
+                f'Please provide t_category when cancer_stage_system is "{cancer_stage_system}"',
                 loc="t_category",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_n_category_cr(self) -> Self:
-        if self.cancer_stage_system == "AJCC" and not self.n_category:
+    @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 "{self.cancer_stage_system}"',
+                f'Please provide n_category when cancer_stage_system is "{cancer_stage_system}"',
                 loc="n_category",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_m_category_cr(self) -> Self:
-        if self.cancer_stage_system == "AJCC" and not self.m_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 "{self.cancer_stage_system}"',
+                f'Please provide m_category when cancer_stage_system is "{cancer_stage_system}"',
                 loc="m_category",
             )
-        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:
+    @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/stage1/exposure.py

@@ -1,12 +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"
@@ -26,11 +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:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/medical_history.py

@@ -1,12 +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"
@@ -30,11 +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:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/other_malignancy.py

@@ -1,12 +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"
@@ -37,15 +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 ValueLocError(
                 'Please provide at least one of "morphological_code", "morphological_term" or "malignancy_description".',
-                loc="morphological_code",
+                loc="other_malignancy_morphological_code",
             )
-        return self

cidc_api/models/pydantic/stage1/participant.py

@@ -1,6 +1,4 @@
-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
@@ -8,6 +6,7 @@ from cidc_api.models.types import YNU
 from cidc_api.models.types import OffStudyReason
 
 
+@forced_validators
 class Participant(Base):
     __data_category__ = "participant"
     __cardinality__ = "one"
@@ -39,20 +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:
+    @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",
             )
-        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:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/radiotherapy_dose.py

@@ -1,6 +1,5 @@
-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
@@ -13,6 +12,7 @@ from cidc_api.models.types import (
 )
 
 
+@forced_validators
 class RadiotherapyDose(Base):
     __data_category__ = "radiotherapy_dose"
     __cardinality__ = "many"
@@ -67,20 +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:
+    @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",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_planned_dose_units_cr(self) -> Self:
-        if self.planned_dose and not self.planned_dose_units:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/response.py

@@ -1,12 +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"
@@ -47,29 +47,38 @@ class Response(Base):
     # Days from enrollment date to the last time the patient's vital status was verified.
     days_to_last_vital_status: NonNegativeInt | None = None
 
-    @model_validator(mode="after")
-    def validate_cause_of_death_cr(self) -> Self:
-        if self.survival_status == "Dead" and not self.cause_of_death:
+    @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",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_cause_of_death_cr2(self) -> Self:
-        if self.survival_status == "Alive" and self.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",
             )
-        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:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/response_by_system.py

@@ -1,6 +1,7 @@
 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
@@ -19,6 +20,7 @@ negative_response_values = [
 ]
 
 
+@forced_validators
 class ResponseBySystem(Base):
     __data_category__ = "response_by_system"
     __cardinality__ = "many"
@@ -71,90 +73,117 @@ 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:
+    @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.",
                 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:
+    @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.",
                 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:
+    @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.",
+                "If best_overall_response does not indicate a positive response, "
+                "please leave days_to_best_response blank.",
                 loc="days_to_best_response",
             )
-        return self
 
-    @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:
+    @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_progress blank.",
-                loc="days_to_disease_progress",
+                "If progression does not indicate confirmed progression of the disease, "
+                "please leave days_to_disease_progression blank.",
+                loc="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:
+    @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.",
+                "If progression_free_survival_event is not known, " "please leave progression_free_survival blank.",
                 loc="progression_free_survival",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_days_to_best_response_chronology(self) -> Self:
-        if self.days_to_best_response is not None and self.days_to_first_response is not None:
-            if self.days_to_best_response < self.days_to_first_response:
+    @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",
                 )
-        return self
 
-    @model_validator(mode="after")
-    def validate_days_to_disease_progression_chronology(self) -> Self:
-        if self.days_to_first_response is not None and self.days_to_disease_progression is not None:
-            if self.days_to_first_response >= self.days_to_disease_progression:
+    @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",
                 )
-        return self
 
-    @model_validator(mode="after")
-    def validate_days_to_best_response_progression_chronology(self) -> Self:
-        if self.days_to_best_response is not None and self.days_to_disease_progression is not None:
-            if self.days_to_best_response >= self.days_to_disease_progression:
+    @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",
                 )
-        return self
 
     @model_validator(mode="after")
     def validate_days_to_last_vital_status_chronology(self) -> Self:
-        if not self.response or not self.response.days_to_last_vital_status:
+        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,
@@ -171,8 +200,11 @@ class ResponseBySystem(Base):
 
     @model_validator(mode="after")
     def validate_days_to_death_chronology(self) -> Self:
-        if not self.response or not self.response.days_to_death:
+        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,
@@ -185,3 +217,4 @@ class ResponseBySystem(Base):
                 ">= 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,12 +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"
@@ -43,11 +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:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/therapy_agent_dose.py

@@ -1,12 +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"
@@ -55,20 +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:
+    @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",
             )
-        return self
 
-    @model_validator(mode="after")
-    def validate_planned_dose_units_cr(self) -> Self:
-        if self.planned_dose and not self.planned_dose_units:
+    @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",
             )
-        return self

cidc_api/models/pydantic/stage1/treatment.py

@@ -1,12 +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, OffTreatmentReason
 
 
+@forced_validators
 class Treatment(Base):
     __data_category__ = "treatment"
     __cardinality__ = "many"
@@ -38,20 +37,28 @@ class Treatment(Base):
     # If "Other" is selected for "off_treatment_reason", provide a description of the reason.
     off_treatment_reason_other: str | None = None
 
-    @model_validator(mode="after")
-    def validate_off_treatment_reason_cr(self) -> Self:
-        if self.off_treatment == "Yes" and not self.off_treatment_reason:
+    @forced_validator
+    @classmethod
+    def validate_off_treatment_reason_cr(cls, data, info) -> None:
+        off_treatment = data.get("off_treatment", None)
+        off_treatment_reason = data.get("off_treatment_reason", None)
+
+        if off_treatment == "Yes" and not off_treatment_reason:
             raise ValueLocError(
                 'If off_treatment is "Yes", please provide off_treatment_reason.',
                 loc="off_treatment_reason",
             )
-        return self
+        return off_treatment_reason
+
+    @forced_validator
+    @classmethod
+    def validate_off_treatment_reason_other_cr(cls, data, info) -> None:
+        off_treatment_reason = data.get("off_treatment_reason", None)
+        off_treatment_reason_other = data.get("off_treatment_reason_other", None)
 
-    @model_validator(mode="after")
-    def validate_off_treatment_reason_other_cr(self) -> Self:
-        if self.off_treatment_reason == "Other" and not self.off_treatment_reason_other:
+        if off_treatment_reason == "Other" and not off_treatment_reason_other:
             raise ValueLocError(
                 'If off_treatment_reason is "Other", please provide off_treatment_reason_other.',
                 loc="off_treatment_reason_other",
             )
-        return self
+        return off_treatment_reason_other

{nci_cidc_api_modules-1.2.51.dist-info → nci_cidc_api_modules-1.2.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nci_cidc_api_modules
-Version: 1.2.51
+Version: 1.2.52
 Summary: SQLAlchemy data models and configuration tools used in the NCI CIDC API
 Home-page: https://github.com/NCI-CIDC/cidc-api-gae
 License: MIT license

{nci_cidc_api_modules-1.2.51.dist-info → nci_cidc_api_modules-1.2.52.dist-info}/RECORD

@@ -1,5 +1,5 @@
 boot.py,sha256=oS_16OgU34iDxyFNpJl5rb5KbfbsCXroUCNLwVPxPNg,416
-cidc_api/__init__.py,sha256=kgsz9u_lLDc3N0akch6v9PpMXz_PW7_aEHXRb1pWgHg,23
+cidc_api/__init__.py,sha256=jf5CtcUq4OTsCQcG2e0HUKeI9KD06OUpOQioBuO1h-Y,23
 cidc_api/telemetry.py,sha256=LuZWkG8CKCn23O41RTNxEOQwMmfpp-fQ6zSInZhVJg8,3333
 cidc_api/config/__init__.py,sha256=5mX8GAPxUKV84iS-aGOoE-4m68LsOCGCDptXNdlgvj0,148
 cidc_api/config/db.py,sha256=mEz8ugjvRNGylCqDYHaaMqaZfDh7sbd76BowmfBvq5c,2428
@@ -81,32 +81,32 @@ cidc_api/models/db/stage2/trial_orm.py,sha256=7_5kA1Yv80GFQykK8AIlFC0vtrsb2H8xLs
 cidc_api/models/files/__init__.py,sha256=8BMTnUSHzUbz0lBeEQY6NvApxDD3GMWMduoVMos2g4Y,213
 cidc_api/models/files/details.py,sha256=sZkGM7iEV4-J6IDQCdiMV6KBDLbPxCOqUMaU3aY9rX8,65153
 cidc_api/models/files/facets.py,sha256=vieZ3z_tYB29NqtvNzvKqajVwxM5ZLLZKeyQTq5lheU,33776
-cidc_api/models/pydantic/base.py,sha256=6Lsf4fekIS1E-DwZmgCXlfm3Qq9_23dA_v3iz1w2JoA,1427
+cidc_api/models/pydantic/base.py,sha256=sL_0PwEH2vS8BMT_w-zL7CPeaU-R7ih5afRigX6k2DM,4069
 cidc_api/models/pydantic/stage1/__init__.py,sha256=H-NDjCd8isHTgZ7sqz-MIbzC-PpW1kEtR-x-Dyc8r6Q,1667
 cidc_api/models/pydantic/stage1/additional_treatment.py,sha256=TFVzjd1NPLSfH9UnL2W3aZhpZSzDsg97j9IK8t882YA,1050
-cidc_api/models/pydantic/stage1/adverse_event.py,sha256=YzH8YbgxvjrrcJENtbctYCziR_io4fKPtSiHxO0GV9A,4652
+cidc_api/models/pydantic/stage1/adverse_event.py,sha256=ZW5iVnMmX7NtZcsgDAjzPorWPZDSJSmTXGK1EsU9AaQ,5167
 cidc_api/models/pydantic/stage1/baseline_clinical_assessment.py,sha256=5FYvtOVf_nIK1h3xTs3vQgJe2ivQSVHt_wfrTSDgVxU,1119
-cidc_api/models/pydantic/stage1/comorbidity.py,sha256=K9MyK4XsSGr-3TjrDH_GJN1rG3uWqkyECbwGGuqkbzc,1528
+cidc_api/models/pydantic/stage1/comorbidity.py,sha256=IfxFb0dZAdCY--Ze5kiZ3CrzVKJtuknpcpvrQ3ki-gI,1769
 cidc_api/models/pydantic/stage1/consent_group.py,sha256=aP_nd0GKK6K7VH-6IZRSDDX2RxFM_j9B36FIRGwysOU,1216
-cidc_api/models/pydantic/stage1/demographic.py,sha256=V5Fymdl2ge6eGcnCnP7ekCJuzfR7XeCgwclBKCMeolE,6304
-cidc_api/models/pydantic/stage1/disease.py,sha256=e-BT6Z_QMyDJhtzJcYbMdqABkuVsX4OWw5HGnNuLzZM,8212
-cidc_api/models/pydantic/stage1/exposure.py,sha256=XtnLxXSBrvuvOgrdg2A-x_FclQvT8zJkGeXIB50ZJs0,1426
+cidc_api/models/pydantic/stage1/demographic.py,sha256=S2riNy6njMSamgupFAsbM656TDamQExRzUGKNYaBaOo,6752
+cidc_api/models/pydantic/stage1/disease.py,sha256=G8d2iqsMhmDA3uxjOitxzmlFKIRxyUMp-o-H7eUfZFg,9250
+cidc_api/models/pydantic/stage1/exposure.py,sha256=bd9gUmOQ7ge-xvoxD17pX95MKxfHKD2xNaFEJAMAkn4,1571
 cidc_api/models/pydantic/stage1/gvhd_diagnosis_acute.py,sha256=jVMoWuLfspOZtOpC7rg1EzdvEAg8qEabcTaS6RRobZ8,1395
 cidc_api/models/pydantic/stage1/gvhd_diagnosis_chronic.py,sha256=SRwkAL07YyIZM4bYCqm01aKqSvj3yRmpsqFKxAZEZoM,1382
 cidc_api/models/pydantic/stage1/gvhd_organ_acute.py,sha256=VxlNGRJYjm9tW2lyLll8pD0t9JZs18gicnH-Ci_nR2I,771
 cidc_api/models/pydantic/stage1/gvhd_organ_chronic.py,sha256=Fnp1Qm-ZDDtDLrgOAnEOUnQVNWI9WrTSomiFPStGmjc,810
-cidc_api/models/pydantic/stage1/medical_history.py,sha256=5QU01b5-lKIWiz7GoIwZmZ_meFJ70ku7tvd3To1OpIA,1821
-cidc_api/models/pydantic/stage1/other_malignancy.py,sha256=wIiYa3EffLYA4hu8JJORCZwG2GRbRdl2y47VJN4OffI,2283
-cidc_api/models/pydantic/stage1/participant.py,sha256=QQVi0jhqSot1TiopongU_VnJHvk2RLKUpKtR15a_A1M,2402
+cidc_api/models/pydantic/stage1/medical_history.py,sha256=z-cE_ChyWUKTvWjVhKMUAYvap9YfpZn6Z2BiHhBXx6g,2000
+cidc_api/models/pydantic/stage1/other_malignancy.py,sha256=VIzhbkauaDfZdPxhTYpqNtwYBxE_4osE9wyZ67LQJx4,2622
+cidc_api/models/pydantic/stage1/participant.py,sha256=QfRkK2okY7nM84y9QMK12kZLURBGk-HNWWHL4pQZjec,2655
 cidc_api/models/pydantic/stage1/prior_treatment.py,sha256=axhyPHwYCoIvcIonjyPJ95HUyaAXqIuOd6hhoDM3LJU,2101
-cidc_api/models/pydantic/stage1/radiotherapy_dose.py,sha256=eGCkqfK2jIu3Lh0G51hXs4oqP9CRAxJrSbApdNjANb8,3536
-cidc_api/models/pydantic/stage1/response.py,sha256=3Cuhu0DBew96e-k0sSN4vvPJ1xSoejXJdjpXw9HPtjo,3126
-cidc_api/models/pydantic/stage1/response_by_system.py,sha256=3Om1R2vJd6C7UDQAIh-suDnwrZGquFf9SpirPJDKFUs,8590
+cidc_api/models/pydantic/stage1/radiotherapy_dose.py,sha256=gDaL1OQuSuTauml6HafBiVvBn8gcynS3G1fa9KNhEPA,3833
+cidc_api/models/pydantic/stage1/response.py,sha256=TJlKmUz9SypbbDnv6iSmLb4KPEuFUPe9Q8iNSGsLbfI,3491
+cidc_api/models/pydantic/stage1/response_by_system.py,sha256=gjyo_jDyc2xHNNrUwoFqH3Fz51v2eSr3JRHkH0xwVqI,9851
 cidc_api/models/pydantic/stage1/specimen.py,sha256=scDekZ-RtXOQTTLburhqT3RF4KM34iY9NAV1wYi_HSg,1281
 cidc_api/models/pydantic/stage1/stem_cell_transplant.py,sha256=XsDVUksqbIprPxHwLlwHGyji4jsIFNMcIk-S0H4rDnQ,1228
-cidc_api/models/pydantic/stage1/surgery.py,sha256=IPBhgyPHuPrPpy0Qs9j2rHO7ig7J8ixBVNp_1l5TvzU,2271
-cidc_api/models/pydantic/stage1/therapy_agent_dose.py,sha256=ZIsImguwBuAFGogla1rBN6N_FNUzhoC3OkconsJ-33k,3230
-cidc_api/models/pydantic/stage1/treatment.py,sha256=C2xQ_fU0ZxGgBzes7hyHOHvicAzSjyva3Z5F78tor30,2244
+cidc_api/models/pydantic/stage1/surgery.py,sha256=sHPzYMNusYIQrC6gjWopwxo0j9BNOq_Tcl6HKAMvuAQ,2421
+cidc_api/models/pydantic/stage1/therapy_agent_dose.py,sha256=XX7JM4CdvTuAsbI5rI4wYDcbevP46BetTk_z7N_EL-M,3527
+cidc_api/models/pydantic/stage1/treatment.py,sha256=eEjCcmkLdPmS2kg9dtUm3pt9apo1sRypBbte_xUVAYU,2607
 cidc_api/models/pydantic/stage1/trial.py,sha256=EFsMVMxxHbPeaBb6JG9JpX1qjtoho2t-GZnaI0gsYrY,1859
 cidc_api/models/pydantic/stage2/__init__.py,sha256=OQRG5wFkNsyAU_0KI1W5PDn8pBDe1EJDcgKZ19shh_g,2331
 cidc_api/models/pydantic/stage2/additional_treatment.py,sha256=TFVzjd1NPLSfH9UnL2W3aZhpZSzDsg97j9IK8t882YA,1050
@@ -160,8 +160,8 @@ cidc_api/shared/gcloud_client.py,sha256=EJ2ZzZ0gwDOZx18PEzXil4F-jpruacShkVIoecw8
 cidc_api/shared/jose.py,sha256=-qzGzEDAlokEp9E7WtBtQkXyyfPWTYXlwYpCqVJWmqM,1830
 cidc_api/shared/rest_utils.py,sha256=RwR30WOUAYCxL7V-i2totEyeriG30GbBDvBcpLXhM9w,6594
 cidc_api/shared/utils.py,sha256=-gLnzxCR9E6h0plt2xrNisUG5_Y6GhhVwz3DgDIzpvs,367
-nci_cidc_api_modules-1.2.51.dist-info/licenses/LICENSE,sha256=pNYWVTHaYonnmJyplmeAp7tQAjosmDpAWjb34jjv7Xs,1102
-nci_cidc_api_modules-1.2.51.dist-info/METADATA,sha256=MCveB10mn5WAmlZX44mM0Z0BCCCu2wsttqjPitAF4Nc,40301
-nci_cidc_api_modules-1.2.51.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-nci_cidc_api_modules-1.2.51.dist-info/top_level.txt,sha256=BSJqF6ura8-bWCKZvarvQEKvidMM05lH0bLQsNOrI0o,14
-nci_cidc_api_modules-1.2.51.dist-info/RECORD,,
+nci_cidc_api_modules-1.2.52.dist-info/licenses/LICENSE,sha256=pNYWVTHaYonnmJyplmeAp7tQAjosmDpAWjb34jjv7Xs,1102
+nci_cidc_api_modules-1.2.52.dist-info/METADATA,sha256=LmysKc5tWnhHucOWIA2ZesTGvnWy63VG7a6zw8bRtXQ,40301
+nci_cidc_api_modules-1.2.52.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nci_cidc_api_modules-1.2.52.dist-info/top_level.txt,sha256=BSJqF6ura8-bWCKZvarvQEKvidMM05lH0bLQsNOrI0o,14
+nci_cidc_api_modules-1.2.52.dist-info/RECORD,,