nci-cidc-api-modules 1.2.18__py3-none-any.whl → 1.2.25__py3-none-any.whl

cidc_api/models/__init__.py

@@ -1,3 +1,5 @@
 from .models import *
 from .files import *
 from .schemas import *
+
+from cidc_api.models.db.base_orm import BaseORM

cidc_api/models/data.py

@@ -0,0 +1,15 @@
+from cidc_api.models.pydantic.stage2 import all_models
+
+standard_data_categories = [model.__data_category__ for model in all_models if hasattr(model, "__data_category__")]
+
+
+# A class to hold the representation of a trial's dataset all at once
+class Dataset(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for data_category in standard_data_categories:
+            self[data_category] = []
+
+
+# Maps data categories like "treatment" to their associated pydantic model
+data_category_to_model = {model.__data_category__: model for model in all_models if hasattr(model, "__data_category__")}

cidc_api/models/db/base_orm.py

@@ -0,0 +1,25 @@
+from typing import Self
+
+from sqlalchemy_mixins import SerializeMixin, ReprMixin
+
+from cidc_api.config.db import db
+
+
+class BaseORM(db.Model, ReprMixin, SerializeMixin):
+    __abstract__ = True
+    __repr__ = ReprMixin.__repr__
+
+    def merge(self, d: dict) -> Self:
+        """Merge keys and values from dict d into this model, overwriting as necessary."""
+        for key, value in d.items():
+            setattr(self, key, value)
+        return self
+
+    def clone(self) -> "BaseORM":
+        """Clones a SQLAlchemy ORM object, excluding primary keys."""
+        mapper = self.__mapper__
+        new_instance = self.__class__()
+        for column in mapper.columns:
+            if not column.primary_key:
+                setattr(new_instance, column.key, getattr(self, column.key))
+        return new_instance

cidc_api/models/db/stage2/__init__.py

@@ -0,0 +1,78 @@
+from .additional_treatment_orm import AdditionalTreatmentORM
+from .administrative_person_orm import AdministrativePersonORM
+from .administrative_role_assignment_orm import AdministrativeRoleAssignmentORM
+from .adverse_event_orm import AdverseEventORM
+from .arm_orm import ArmORM
+from .baseline_clinical_assessment_orm import BaselineClinicalAssessmentORM
+from .cohort_orm import CohortORM
+from .comorbidity_orm import ComorbidityORM
+from .consent_group_orm import ConsentGroupORM
+from .contact_orm import ContactORM
+from .demographic_orm import DemographicORM
+from .disease_orm import DiseaseORM
+from .exposure_orm import ExposureORM
+from .file_orm import FileORM
+from .gvhd_diagnosis_acute_orm import GVHDDiagnosisAcuteORM
+from .gvhd_diagnosis_chronic_orm import GVHDDiagnosisChronicORM
+from .gvhd_organ_acute_orm import GVHDOrganAcuteORM
+from .gvhd_organ_chronic_orm import GVHDOrganChronicORM
+from .institution_orm import InstitutionORM
+from .medical_history_orm import MedicalHistoryORM
+from .other_clinical_endpoint_orm import OtherClinicalEndpointORM
+from .other_malignancy_orm import OtherMalignancyORM
+from .participant_orm import ParticipantORM
+from .prior_treatment_orm import PriorTreatmentORM
+from .publication_orm import PublicationORM
+from .radiotherapy_dose_orm import RadiotherapyDoseORM
+from .response_by_system_orm import ResponseBySystemORM
+from .response_orm import ResponseORM
+from .shipment_orm import ShipmentORM
+from .shipment_specimen_orm import ShipmentSpecimenORM
+from .specimen_orm import SpecimenORM
+from .stem_cell_transplant_orm import StemCellTransplantORM
+from .surgery_orm import SurgeryORM
+from .therapy_agent_dose_orm import TherapyAgentDoseORM
+from .treatment_orm import TreatmentORM
+from .trial_orm import TrialORM
+
+
+__all__ = [
+    "AdditionalTreatmentORM",
+    "AdministrativePersonORM",
+    "AdministrativeRoleAssignmentORM",
+    "AdverseEventORM",
+    "ArmORM",
+    "BaselineClinicalAssessmentORM",
+    "CohortORM",
+    "ComorbidityORM",
+    "ConsentGroupORM",
+    "ContactORM",
+    "DemographicORM",
+    "DiseaseORM",
+    "ExposureORM",
+    "FileORM",
+    "GVHDDiagnosisAcuteORM",
+    "GVHDDiagnosisChronicORM",
+    "GVHDOrganAcuteORM",
+    "GVHDOrganChronicORM",
+    "InstitutionORM",
+    "MedicalHistoryORM",
+    "OtherClinicalEndpointORM",
+    "OtherMalignancyORM",
+    "ParticipantORM",
+    "PriorTreatmentORM",
+    "PublicationORM",
+    "RadiotherapyDoseORM",
+    "ResponseBySystemORM",
+    "ResponseORM",
+    "ShipmentORM",
+    "ShipmentSpecimenORM",
+    "SpecimenORM",
+    "StemCellTransplantORM",
+    "SurgeryORM",
+    "TherapyAgentDoseORM",
+    "TreatmentORM",
+    "TrialORM",
+]
+
+all_models = [globals()[cls_name] for cls_name in __all__]

cidc_api/models/db/stage2/additional_treatment_orm.py

@@ -0,0 +1,22 @@
+from pydantic import NonNegativeInt
+from typing import Optional
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class AdditionalTreatmentORM(BaseORM):
+    __tablename__ = "additional_treatment"
+    __repr_attrs__ = ["additional_treatment_id", "participant_id", "description"]
+    __table_args__ = {"schema": "stage2"}
+
+    additional_treatment_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+
+    days_to_start: Mapped[Optional[NonNegativeInt]]
+    days_to_end: Mapped[Optional[NonNegativeInt]]
+    description: Mapped[str]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="additional_treatments", cascade="all, delete")

cidc_api/models/db/stage2/administrative_person_orm.py

@@ -0,0 +1,25 @@
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class AdministrativePersonORM(BaseORM):
+    __tablename__ = "administrative_person"
+    __repr_attrs__ = ["first_name", "last_name"]
+    __table_args__ = {"schema": "stage2"}
+
+    administrative_person_id: Mapped[int] = mapped_column(primary_key=True)
+    institution_id: Mapped[int] = mapped_column(ForeignKey("stage2.institution.institution_id", ondelete="CASCADE"))
+    first_name: Mapped[str]
+    middle_name: Mapped[str | None]
+    last_name: Mapped[str]
+    email: Mapped[str | None]
+    phone_number: Mapped[str | None]
+
+    institution: Mapped["InstitutionORM"] = relationship(back_populates="administrative_people", cascade="all, delete")
+    administrative_role_assignments: Mapped[List["AdministrativeRoleAssignmentORM"]] = relationship(
+        back_populates="administrative_person", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/administrative_role_assignment_orm.py

@@ -0,0 +1,28 @@
+from sqlalchemy import ForeignKeyConstraint, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import AdministrativeRole
+
+
+class AdministrativeRoleAssignmentORM(BaseORM):
+    __tablename__ = "administrative_role_assignment"
+    __repr_attrs__ = ["trial_id", "administrative_person_id", "administrative_role"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    trial_id: Mapped[str] = mapped_column(primary_key=True)
+    version: Mapped[str] = mapped_column(primary_key=True)
+    administrative_person_id: Mapped[int] = mapped_column(
+        ForeignKey("stage2.administrative_person.administrative_person_id", ondelete="CASCADE"), primary_key=True
+    )
+    administrative_role: Mapped[AdministrativeRole] = mapped_column(primary_key=True)
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="administrative_role_assignments", cascade="all, delete")
+    administrative_person: Mapped["AdministrativePersonORM"] = relationship(
+        back_populates="administrative_role_assignments", cascade="all, delete"
+    )

cidc_api/models/db/stage2/adverse_event_orm.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from pydantic import NonNegativeInt
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import (
+    CTCAEEventTerm,
+    CTCAEEventCode,
+    SeverityGradeSystem,
+    SeverityGradeSystemVersion,
+    SeverityGrade,
+    SystemOrganClass,
+    AttributionCause,
+    AttributionLikelihood,
+    YNU,
+)
+
+
+class AdverseEventORM(BaseORM):
+    __tablename__ = "adverse_event"
+    __repr_attrs__ = ["adverse_event_id", "participant_id", "event_term"]
+    __table_args__ = {"schema": "stage2"}
+
+    adverse_event_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    treatment_id: Mapped[Optional[int]] = mapped_column(ForeignKey("stage2.treatment.treatment_id", ondelete="CASCADE"))
+
+    event_term: Mapped[Optional[CTCAEEventTerm]]
+    event_code: Mapped[Optional[CTCAEEventCode]]
+    severity_grade_system: Mapped[SeverityGradeSystem]
+    severity_grade_system_version: Mapped[SeverityGradeSystemVersion]
+    severity_grade: Mapped[SeverityGrade]
+    event_other_specify: Mapped[Optional[str]]
+    system_organ_class: Mapped[Optional[SystemOrganClass]]
+    discontinuation_due_to_event: Mapped[bool]
+    days_to_onset_of_event: Mapped[NonNegativeInt]
+    days_to_resolution_of_event: Mapped[Optional[NonNegativeInt]]
+    serious_adverse_event: Mapped[YNU]
+    dose_limiting_toxicity: Mapped[YNU]
+    attribution_cause: Mapped[AttributionCause]
+    attribution_likelihood: Mapped[AttributionLikelihood]
+    individual_therapy: Mapped[Optional[str]]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="adverse_events", cascade="all, delete")
+    treatment: Mapped["TreatmentORM"] = relationship(back_populates="adverse_events", cascade="all, delete")

cidc_api/models/db/stage2/arm_orm.py

@@ -0,0 +1,23 @@
+from sqlalchemy import ForeignKey, ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class ArmORM(BaseORM):
+    __tablename__ = "arm"
+    __repr_attrs__ = ["trial_id", "arm_name"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    arm_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    name: Mapped[str]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="arms", cascade="all, delete")

cidc_api/models/db/stage2/baseline_clinical_assessment_orm.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import ECOGScore, KarnofskyScore
+
+
+class BaselineClinicalAssessmentORM(BaseORM):
+    __tablename__ = "baseline_clinical_assessment"
+    __repr_attrs__ = ["baseline_clinical_assessment_id", "participant_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    baseline_clinical_assessment_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+
+    ecog_score: Mapped[Optional[ECOGScore]]
+    karnofsky_score: Mapped[Optional[KarnofskyScore]]
+
+    participant: Mapped["ParticipantORM"] = relationship(
+        back_populates="baseline_clinical_assessment", cascade="all, delete"
+    )

cidc_api/models/db/stage2/cohort_orm.py

@@ -0,0 +1,23 @@
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class CohortORM(BaseORM):
+    __tablename__ = "cohort"
+    __repr_attrs__ = ["trial_id", "cohort_name"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    cohort_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    name: Mapped[str]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="cohorts", cascade="all, delete")

cidc_api/models/db/stage2/comorbidity_orm.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import ICD10CMCode, ICD10CMTerm
+
+
+class ComorbidityORM(BaseORM):
+    __tablename__ = "comorbidity"
+    __repr_attrs__ = ["comorbidity_id", "comorbidity_term"]
+    __table_args__ = {"schema": "stage2"}
+
+    comorbidity_id: Mapped[int] = mapped_column(primary_key=True)
+    medical_history_id: Mapped[int] = mapped_column(
+        ForeignKey("stage2.medical_history.medical_history_id", ondelete="CASCADE")
+    )
+
+    comorbidity_code: Mapped[Optional[ICD10CMCode]]
+    comorbidity_term: Mapped[Optional[ICD10CMTerm]]
+    comorbidity_other: Mapped[Optional[str]]
+
+    medical_history: Mapped["MedicalHistoryORM"] = relationship(back_populates="comorbidities", cascade="all, delete")

cidc_api/models/db/stage2/consent_group_orm.py

@@ -0,0 +1,31 @@
+from typing import List
+
+from pydantic import NonNegativeInt
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class ConsentGroupORM(BaseORM):
+    __tablename__ = "consent_group"
+    __repr_attrs__ = ["consent_group_id", "consent_group_name"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    consent_group_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    consent_group_short_name: Mapped[str]
+    consent_group_name: Mapped[str]
+    consent_group_number: Mapped[NonNegativeInt]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="consent_groups", cascade="all, delete")
+    participants: Mapped[List["ParticipantORM"]] = relationship(
+        back_populates="consent_group", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/contact_orm.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class ContactORM(BaseORM):
+    __tablename__ = "contact"
+    __table_args__ = {"schema": "stage2"}
+
+    contact_id: Mapped[int] = mapped_column(primary_key=True)
+    institution_id: Mapped[int] = mapped_column(ForeignKey("stage2.institution.institution_id", ondelete="CASCADE"))
+    shipment_from_id: Mapped[Optional[int]] = mapped_column(
+        ForeignKey("stage2.shipment.shipment_id", ondelete="CASCADE")
+    )
+    shipment_to_id: Mapped[Optional[int]] = mapped_column(ForeignKey("stage2.shipment.shipment_id", ondelete="CASCADE"))
+
+    name: Mapped[Optional[str]]
+    email: Mapped[Optional[str]]
+    phone: Mapped[Optional[str]]
+    street1: Mapped[Optional[str]]
+    street2: Mapped[Optional[str]]
+    city: Mapped[Optional[str]]
+    state: Mapped[Optional[str]]
+    zip: Mapped[Optional[str]]
+    country: Mapped[Optional[str]]
+
+    institution: Mapped[Optional["InstitutionORM"]] = relationship(back_populates="contacts", cascade="all, delete")
+    shipment_from: Mapped["ShipmentORM"] = relationship(cascade="all, delete", foreign_keys=[shipment_from_id])
+    shipment_to: Mapped["ShipmentORM"] = relationship(cascade="all, delete", foreign_keys=[shipment_to_id])

cidc_api/models/db/stage2/demographic_orm.py

@@ -0,0 +1,44 @@
+from pydantic import NonNegativeFloat, PositiveFloat, PositiveInt
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import (
+    Sex,
+    Race,
+    Ethnicity,
+    HeightUnits,
+    WeightUnits,
+    BodySurfaceAreaUnits,
+    Occupation,
+    Education,
+    AgeAtEnrollmentUnits,
+)
+
+
+class DemographicORM(BaseORM):
+    __tablename__ = "demographic"
+    __repr_attrs__ = ["demographic_id", "participant_id", "age_at_enrollment", "sex"]
+    __table_args__ = {"schema": "stage2"}
+
+    demographic_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    age_at_enrollment: Mapped[PositiveInt | None]
+    age_at_enrollment_units: Mapped[AgeAtEnrollmentUnits | None]
+    age_90_or_older: Mapped[bool]
+    sex: Mapped[Sex]
+    race: Mapped[Race]
+    ethnicity: Mapped[Ethnicity]
+    height: Mapped[PositiveFloat]
+    height_units: Mapped[HeightUnits]
+    weight: Mapped[PositiveFloat]
+    weight_units: Mapped[WeightUnits]
+    body_mass_index: Mapped[PositiveFloat]
+    body_surface_area: Mapped[PositiveFloat]
+    body_surface_area_units: Mapped[BodySurfaceAreaUnits]
+    occupation: Mapped[Occupation | None]
+    income: Mapped[NonNegativeFloat | None]
+    highest_level_of_education: Mapped[Education | None]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="demographic", cascade="all, delete")

cidc_api/models/db/stage2/disease_orm.py

@@ -0,0 +1,53 @@
+from typing import List, Optional
+
+from pydantic import NonPositiveInt
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.types import JSON
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import (
+    PrimaryDiagnosisDiseaseGroup,
+    TumorGrade,
+    CancerStageSystem,
+    CancerStageSystemVersion,
+    CancerStage,
+    TCategory,
+    NCategory,
+    MCategory,
+    UberonAnatomicalTerm,
+    ICDO3MorphologicalCode,
+    ICDO3MorphologicalTerm,
+    YNU,
+)
+from sqlalchemy import String
+
+
+class DiseaseORM(BaseORM):
+    __tablename__ = "disease"
+    __repr_attrs__ = [
+        "disease_id",
+        "participant_id",
+    ]
+    __table_args__ = {"schema": "stage2"}
+
+    disease_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    primary_diagnosis_disease_group: Mapped[PrimaryDiagnosisDiseaseGroup]
+    primary_disease_site: Mapped[UberonAnatomicalTerm]
+    morphological_code: Mapped[ICDO3MorphologicalCode]
+    morphological_term: Mapped[ICDO3MorphologicalTerm]
+    cancer_type_description: Mapped[str | None]
+    days_since_original_diagnosis: Mapped[NonPositiveInt]
+    tumor_grade: Mapped[TumorGrade | None]
+    cancer_stage_system: Mapped[CancerStageSystem]
+    cancer_stage_system_version: Mapped[CancerStageSystemVersion | None] = mapped_column(String, nullable=True)
+    cancer_stage: Mapped[CancerStage] = mapped_column(String)
+    t_category: Mapped[TCategory]
+    n_category: Mapped[NCategory]
+    m_category: Mapped[MCategory]
+    metastatic_organ: Mapped[List[UberonAnatomicalTerm]] = mapped_column(JSON, nullable=True)
+    solely_extramedullary_disease: Mapped[YNU]
+    extramedullary_organ: Mapped[List[UberonAnatomicalTerm]] = mapped_column(JSON, nullable=True)
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="diseases", cascade="all, delete")

cidc_api/models/db/stage2/exposure_orm.py

@@ -0,0 +1,21 @@
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import YNU, ExposureType
+
+
+class ExposureORM(BaseORM):
+    __tablename__ = "exposure"
+    __repr_attrs__ = ["exposure_id", "exposure_type", "carcinogen_exposure"]
+    __table_args__ = {"schema": "stage2"}
+
+    exposure_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+
+    carcinogen_exposure: Mapped[YNU]
+    exposure_type: Mapped[ExposureType]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="exposures", cascade="all, delete")

cidc_api/models/db/stage2/file_orm.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import ForeignKeyConstraint, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import ChecksumType, FileFormat
+
+
+class FileORM(BaseORM):
+    __tablename__ = "file"
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    file_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    creator_id: Mapped[Optional[int]] = mapped_column(
+        ForeignKey("stage2.institution.institution_id", ondelete="CASCADE")
+    )
+    description: Mapped[Optional[str]]
+    uuid: Mapped[str]
+    file_name: Mapped[str]
+    object_url: Mapped[str]
+    uploaded_timestamp: Mapped[datetime]
+    file_size_bytes: Mapped[int]
+    checksum_value: Mapped[str]
+    checksum_type: Mapped[ChecksumType]
+    file_format: Mapped[FileFormat]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="files", cascade="all, delete")
+    creator: Mapped[Optional["InstitutionORM"]] = relationship(back_populates="files", cascade="all, delete")

cidc_api/models/db/stage2/gvhd_diagnosis_acute_orm.py

@@ -0,0 +1,33 @@
+from typing import List
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import (
+    GVHDDiagnosisAcuteAssessmentSystem,
+    GVHDDiagnosisAcuteAssessmentSystemVersion,
+    GVHDDiagnosisAcuteGrade,
+    PreOrPostEnrollment,
+)
+
+
+class GVHDDiagnosisAcuteORM(BaseORM):
+    __tablename__ = "gvhd_diagnosis_acute"
+    __table_args__ = (
+        UniqueConstraint("participant_id", "pre_or_post_enrollment", name="unique_ix_gvhd_diagnosis_acute_pre_or_post"),
+        {"schema": "stage2"},
+    )
+    __repr_attrs__ = ["gvhd_diagnosis_acute_id", "pre_or_post_enrollment"]
+
+    gvhd_diagnosis_acute_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    acute_assessment_system: Mapped[GVHDDiagnosisAcuteAssessmentSystem]
+    system_version: Mapped[GVHDDiagnosisAcuteAssessmentSystemVersion]
+    acute_grade: Mapped[GVHDDiagnosisAcuteGrade]
+    pre_or_post_enrollment: Mapped[PreOrPostEnrollment]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="gvhd_diagnosis_acutes", cascade="all, delete")
+    organs: Mapped[List["GVHDOrganAcuteORM"]] = relationship(
+        back_populates="diagnosis", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/gvhd_diagnosis_chronic_orm.py

@@ -0,0 +1,37 @@
+from typing import List
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import (
+    GVHDDiagnosisChronicAssessmentSystem,
+    GVHDDiagnosisChronicAssessmentSystemVersion,
+    GVHDDiagnosisChronicGlobalSeverity,
+    PreOrPostEnrollment,
+)
+
+
+class GVHDDiagnosisChronicORM(BaseORM):
+    __tablename__ = "gvhd_diagnosis_chronic"
+    __table_args__ = (
+        UniqueConstraint(
+            "participant_id", "pre_or_post_enrollment", name="unique_ix_gvhd_diagnosis_chronic_pre_or_post"
+        ),
+        {"schema": "stage2"},
+    )
+    __repr_attrs__ = ["gvhd_diagnosis_chronic_id", "pre_or_post_enrollment"]
+
+    gvhd_diagnosis_chronic_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    chronic_assessment_system: Mapped[GVHDDiagnosisChronicAssessmentSystem]
+    system_version: Mapped[GVHDDiagnosisChronicAssessmentSystemVersion]
+    chronic_global_severity: Mapped[GVHDDiagnosisChronicGlobalSeverity]
+    pre_or_post_enrollment: Mapped[PreOrPostEnrollment]
+
+    participant: Mapped["ParticipantORM"] = relationship(
+        back_populates="gvhd_diagnosis_chronics", cascade="all, delete"
+    )
+    organs: Mapped[List["GVHDOrganChronicORM"]] = relationship(
+        back_populates="diagnosis", cascade="all, delete", passive_deletes=True
+    )