nci-cidc-api-modules 1.2.23__py3-none-any.whl → 1.2.24__py3-none-any.whl

cidc_api/models/db/stage2/institution_orm.py

@@ -0,0 +1,33 @@
+from typing import List
+
+from sqlalchemy import ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class InstitutionORM(BaseORM):
+    __tablename__ = "institution"
+    __repr_attrs__ = ["name"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    institution_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    name: Mapped[str]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="biobank", cascade="all, delete")
+    administrative_people: Mapped[List["AdministrativePersonORM"]] = relationship(
+        back_populates="institution", cascade="all, delete", passive_deletes=True
+    )
+    shipments: Mapped[List["ShipmentORM"]] = relationship(
+        back_populates="institution", cascade="all, delete", passive_deletes=True
+    )
+    files: Mapped[List["FileORM"]] = relationship(back_populates="creator", cascade="all, delete", passive_deletes=True)
+    contacts: Mapped[List["ContactORM"]] = relationship(back_populates="institution")

cidc_api/models/db/stage2/medical_history_orm.py

@@ -0,0 +1,29 @@
+from typing import Optional, List
+
+from pydantic import NonNegativeInt, PositiveFloat
+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 TobaccoSmokingStatus
+
+
+class MedicalHistoryORM(BaseORM):
+    __tablename__ = "medical_history"
+    __repr_attrs__ = ["medical_history_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    medical_history_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+
+    tobacco_smoking_status: Mapped[Optional[TobaccoSmokingStatus]]
+    pack_years_smoked: Mapped[Optional[PositiveFloat]]
+    num_prior_systemic_therapies: Mapped[Optional[NonNegativeInt]]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="medical_history", cascade="all, delete")
+    other_malignancies: Mapped[List["OtherMalignancyORM"]] = relationship(
+        back_populates="medical_history", cascade="all, delete", passive_deletes=True
+    )
+    comorbidities: Mapped[List["ComorbidityORM"]] = relationship(
+        back_populates="medical_history", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/other_clinical_endpoint_orm.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import YNU, ResponseSystem, ResponseSystemVersion
+
+
+class OtherClinicalEndpointORM(BaseORM):
+    __tablename__ = "other_clinical_endpoint"
+    __repr_attrs__ = ["other_clinical_endpoint_id", "name", "event"]
+    __table_args__ = {"schema": "stage2"}
+
+    other_clinical_endpoint_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+
+    name: Mapped[str]
+    event: Mapped[YNU]
+    days: Mapped[Optional[int]]
+    description: Mapped[Optional[str]]
+    calculation: Mapped[Optional[str]]
+    response_system: Mapped[Optional[ResponseSystem]] = mapped_column(String, nullable=True)
+    response_system_version: Mapped[Optional[ResponseSystemVersion]] = mapped_column(String, nullable=True)
+
+    participant: Mapped["ParticipantORM"] = relationship(
+        back_populates="other_clinical_endpoints", cascade="all, delete"
+    )

cidc_api/models/db/stage2/other_malignancy_orm.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from pydantic import NonPositiveInt
+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 UberonAnatomicalTerm, ICDO3MorphologicalCode, ICDO3MorphologicalTerm, MalignancyStatus
+
+
+class OtherMalignancyORM(BaseORM):
+    __tablename__ = "other_malignancy"
+    __repr_attrs__ = ["other_malignancy_id", "primary_disease_site"]
+    __table_args__ = {"schema": "stage2"}
+
+    other_malignancy_id: Mapped[int] = mapped_column(primary_key=True)
+    medical_history_id: Mapped[int] = mapped_column(
+        ForeignKey("stage2.medical_history.medical_history_id", ondelete="CASCADE")
+    )
+
+    primary_disease_site: Mapped[UberonAnatomicalTerm]
+    morphological_code: Mapped[Optional[ICDO3MorphologicalCode]]
+    morphological_term: Mapped[Optional[ICDO3MorphologicalTerm]]
+    malignancy_description: Mapped[Optional[str]]
+    days_since_diagnosis: Mapped[Optional[NonPositiveInt]]
+    malignancy_status: Mapped[Optional[MalignancyStatus]]
+
+    medical_history: Mapped["MedicalHistoryORM"] = relationship(
+        back_populates="other_malignancies", cascade="all, delete"
+    )

cidc_api/models/db/stage2/participant_orm.py

@@ -0,0 +1,79 @@
+from typing import List, Optional
+
+from sqlalchemy import ForeignKey, ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import OffStudyReason
+
+
+class ParticipantORM(BaseORM):
+    __tablename__ = "participant"
+    __repr_attrs__ = ["native_participant_id", "cimac_participant_id"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    participant_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    native_participant_id: Mapped[str]
+    cimac_participant_id: Mapped[str] = mapped_column(unique=True)
+    consent_group_id: Mapped[Optional[int]] = mapped_column(
+        ForeignKey("stage2.consent_group.consent_group_id", ondelete="CASCADE")
+    )
+    off_study: Mapped[bool]
+    off_study_reason: Mapped[Optional[OffStudyReason]]
+    off_study_reason_other: Mapped[Optional[str]]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="participants", cascade="all, delete")
+    demographic: Mapped["DemographicORM"] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    prior_treatments: Mapped[List["PriorTreatmentORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    treatments: Mapped[List["TreatmentORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    diseases: Mapped[List["DiseaseORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    response_by_systems: Mapped[List["ResponseBySystemORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    response: Mapped[Optional["ResponseORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    adverse_events: Mapped[List["AdverseEventORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    baseline_clinical_assessment: Mapped[Optional["BaselineClinicalAssessmentORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    medical_history: Mapped[Optional["MedicalHistoryORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    exposures: Mapped[List["ExposureORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    gvhd_diagnosis_acutes: Mapped[List["GVHDDiagnosisAcuteORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    gvhd_diagnosis_chronics: Mapped[List["GVHDDiagnosisChronicORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    specimens: Mapped[List["SpecimenORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    other_clinical_endpoints: Mapped[List["OtherClinicalEndpointORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    additional_treatments: Mapped[List["AdditionalTreatmentORM"]] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    consent_group: Mapped["ConsentGroupORM"] = relationship(back_populates="participants", cascade="all, delete")

cidc_api/models/db/stage2/prior_treatment_orm.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from pydantic import NonPositiveInt, 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 PriorTreatmentType, ConditioningRegimenType, StemCellDonorType
+
+
+class PriorTreatmentORM(BaseORM):
+    __tablename__ = "prior_treatment"
+    __repr_attrs__ = ["prior_treatment_id", "type"]
+    __table_args__ = {"schema": "stage2"}
+
+    prior_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[NonPositiveInt]]
+    days_to_end: Mapped[Optional[NonPositiveInt]]
+    type: Mapped[PriorTreatmentType]
+    description: Mapped[Optional[str]]
+    best_response: Mapped[Optional[str]]
+    conditioning_regimen_type: Mapped[Optional[ConditioningRegimenType]]
+    stem_cell_donor_type: Mapped[Optional[StemCellDonorType]]
+    days_from_transplant_to_treatment_initiation: Mapped[Optional[NonNegativeInt]]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="prior_treatments", cascade="all, delete")

cidc_api/models/db/stage2/publication_orm.py

@@ -0,0 +1,31 @@
+from typing import Optional, List
+
+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 PriorTreatmentType, ConditioningRegimenType, StemCellDonorType
+
+
+class PublicationORM(BaseORM):
+    __tablename__ = "publication"
+    __repr_attrs__ = ["publication_id", "publication_title"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    publication_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    digital_object_id: Mapped[str]
+    pubmed_id: Mapped[Optional[str]]
+    publication_title: Mapped[Optional[str]]
+    authorship: Mapped[Optional[str]]
+    year_of_publication: Mapped[Optional[str]]
+    journal_citation: Mapped[Optional[str]]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="publications", cascade="all, delete")

cidc_api/models/db/stage2/radiotherapy_dose_orm.py

@@ -0,0 +1,39 @@
+from pydantic import NonNegativeInt, NonNegativeFloat, PositiveFloat
+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 (
+    RadiotherapyProcedure,
+    UberonAnatomicalTerm,
+    RadiotherapyDoseUnits,
+    YNU,
+    RadiationExtent,
+)
+
+
+class RadiotherapyDoseORM(BaseORM):
+    __tablename__ = "radiotherapy_dose"
+    __repr_attrs__ = ["radiotherapy_dose_id", "procedure"]
+    __table_args__ = {"schema": "stage2"}
+
+    radiotherapy_dose_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage2.treatment.treatment_id", ondelete="CASCADE"))
+
+    days_to_start: Mapped[NonNegativeInt]
+    days_to_end: Mapped[NonNegativeInt]
+    procedure: Mapped[RadiotherapyProcedure]
+    anatomical_location: Mapped[Optional[UberonAnatomicalTerm]]
+    is_total_dose: Mapped[bool]
+    number_of_fractions: Mapped[Optional[NonNegativeInt]]
+    received_dose: Mapped[NonNegativeFloat]
+    received_dose_units: Mapped[RadiotherapyDoseUnits]
+    planned_dose: Mapped[Optional[PositiveFloat]]
+    planned_dose_units: Mapped[Optional[RadiotherapyDoseUnits]]
+    dose_changes_delays: Mapped[YNU]
+    changes_delays_description: Mapped[Optional[str]]
+    radiation_extent: Mapped[RadiationExtent]
+
+    treatment: Mapped["TreatmentORM"] = relationship(back_populates="radiotherapy_doses", cascade="all, delete")

cidc_api/models/db/stage2/response_by_system_orm.py

@@ -0,0 +1,28 @@
+from pydantic import PositiveInt
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import ResponseSystem, ResponseSystemVersion, BestOverallResponse, YNUNA
+
+
+class ResponseBySystemORM(BaseORM):
+    __tablename__ = "response_by_system"
+    __repr_attrs__ = ["response_by_system_id", "participant_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    response_by_system_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    response_system: Mapped[ResponseSystem] = mapped_column(String)
+    response_system_version: Mapped[ResponseSystemVersion] = mapped_column(String)
+    best_overall_response: Mapped[BestOverallResponse] = mapped_column(String)
+    response_duration: Mapped[PositiveInt | None]
+    durable_clinical_benefit: Mapped[bool | None]
+    days_to_first_response: Mapped[PositiveInt | None]
+    days_to_best_response: Mapped[PositiveInt | None]
+    progression: Mapped[YNUNA]
+    days_to_disease_progression: Mapped[PositiveInt | None]
+    progression_free_survival_event: Mapped[YNUNA]
+    progression_free_survival: Mapped[PositiveInt | None]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="response_by_systems", cascade="all, delete")

cidc_api/models/db/stage2/response_orm.py

@@ -0,0 +1,27 @@
+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 SurvivalStatus, YNUNA, CauseOfDeath
+
+
+class ResponseORM(BaseORM):
+    __tablename__ = "response"
+    __repr_attrs__ = ["response_id", "participant_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    response_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    survival_status: Mapped[SurvivalStatus]
+    overall_survival: Mapped[NonNegativeInt | None]
+    abscopal_response: Mapped[YNUNA | None]
+    pathological_complete_response: Mapped[YNUNA | None]
+    days_to_death: Mapped[NonNegativeInt | None]
+    cause_of_death: Mapped[CauseOfDeath | None]
+    evaluable_for_toxicity: Mapped[bool]
+    evaluable_for_efficacy: Mapped[bool]
+    days_to_last_follow_up: Mapped[NonNegativeInt | None]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="response", cascade="all, delete")

cidc_api/models/db/stage2/shipment_orm.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+from typing import Optional, List
+
+from sqlalchemy import ForeignKey, ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.types import AssayPriority, AssayType, Courier, ShipmentCondition, ShipmentQuality
+
+
+class ShipmentORM(BaseORM):
+    __tablename__ = "shipment"
+    __repr_attrs__ = ["shipment_id", "institution_id", "trial_id"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
+        ),
+        {"schema": "stage2"},
+    )
+
+    shipment_id: Mapped[int] = mapped_column(primary_key=True)
+    institution_id: Mapped[int] = mapped_column(ForeignKey("stage2.institution.institution_id", ondelete="CASCADE"))
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    manifest_id: Mapped[str]
+    assay_priority: Mapped[Optional[AssayPriority]]
+    assay_type: Mapped[Optional[AssayType]]
+    courier: Mapped[Optional[Courier]]
+    tracking_number: Mapped[Optional[str]]
+    condition: Mapped[Optional[ShipmentCondition]]
+    condition_other: Mapped[Optional[str]]
+    date_shipped: Mapped[Optional[datetime]]
+    date_received: Mapped[Optional[datetime]]
+    quality: Mapped[Optional[ShipmentQuality]]
+
+    trial: Mapped["TrialORM"] = relationship(back_populates="shipments", cascade="all, delete")
+    institution: Mapped["InstitutionORM"] = relationship(back_populates="shipments", cascade="all, delete")
+    shipped_from: Mapped["ContactORM"] = relationship(
+        back_populates="shipment_from", cascade="all, delete", foreign_keys="[ContactORM.shipment_from_id]"
+    )
+    shipped_to: Mapped["ContactORM"] = relationship(
+        back_populates="shipment_to", cascade="all, delete", foreign_keys="[ContactORM.shipment_to_id]"
+    )
+    shipment_specimens: Mapped[List["ShipmentSpecimenORM"]] = relationship(
+        back_populates="shipment", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/shipment_specimen_orm.py

@@ -0,0 +1,24 @@
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.base_orm import BaseORM
+
+
+class ShipmentSpecimenORM(BaseORM):
+    __tablename__ = "shipment_specimen"
+    __repr_attrs__ = ["specimen_id", "shipment_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    specimen_id: Mapped[int] = mapped_column(
+        ForeignKey("stage2.specimen.specimen_id", ondelete="CASCADE"), primary_key=True
+    )
+    shipment_id: Mapped[int] = mapped_column(
+        ForeignKey("stage2.shipment.shipment_id", ondelete="CASCADE"), primary_key=True
+    )
+    box_number: Mapped[str]
+    sample_location: Mapped[str]
+
+    specimen: Mapped["SpecimenORM"] = relationship(back_populates="shipment_specimen", cascade="all, delete")
+    shipment: Mapped["ShipmentORM"] = relationship(back_populates="shipment_specimens", cascade="all, delete")

cidc_api/models/db/stage2/specimen_orm.py

@@ -0,0 +1,100 @@
+from datetime import datetime
+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 (
+    UberonAnatomicalTerm,
+    ICDO3MorphologicalCode,
+    SpecimenType,
+    SpecimenDescription,
+    TumorType,
+    CollectionProcedure,
+    FixationStabilizationType,
+    PrimaryContainerType,
+    VolumeUnits,
+    ProcessedType,
+    ConcentrationUnits,
+    DerivativeType,
+    PBMCRestingPeriodUsed,
+    MaterialUnits,
+    MaterialStorageCondition,
+    QCCondition,
+    ReplacementRequested,
+    ResidualUse,
+    DiagnosisVerification,
+    AssayType,
+)
+
+
+class SpecimenORM(BaseORM):
+    __tablename__ = "specimen"
+    __repr_attrs__ = ["specimen_id", "participant_id", "cimac_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    specimen_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+
+    cimac_id: Mapped[str]
+    surgical_pathology_report_id: Mapped[str | None]
+    clinical_report_id: Mapped[str | None]
+    parent_specimen_id: Mapped[str | None]
+    processed_specimen_id: Mapped[str | None]
+    organ_site_of_collection: Mapped[UberonAnatomicalTerm | None]
+    histology_behavior: Mapped[ICDO3MorphologicalCode | None]
+    histology_behavior_description: Mapped[str | None]
+    collection_event_name: Mapped[str | None]
+    specimen_type: Mapped[SpecimenType | None]
+    specimen_type_other: Mapped[str | None]
+    specimen_description: Mapped[SpecimenDescription | None]
+    tumor_type: Mapped[TumorType | None]
+    collection_procedure: Mapped[CollectionProcedure | None]
+    collection_procedure_other: Mapped[str | None]
+    core_number: Mapped[str | None]
+    fixation_stabilization_type: Mapped[FixationStabilizationType | None]
+    primary_container_type: Mapped[PrimaryContainerType | None]
+    primary_container_type_other: Mapped[str | None]
+    volume: Mapped[float | None]
+    volume_units: Mapped[VolumeUnits | None]
+    processed_type: Mapped[ProcessedType | None]
+    processed_volume: Mapped[float | None]
+    processed_volume_units: Mapped[VolumeUnits | None]
+    processed_concentration: Mapped[float | None]
+    processed_concentration_units: Mapped[ConcentrationUnits | None]
+    processed_quantity: Mapped[float | None]
+    derivative_type: Mapped[DerivativeType | None]
+    derivative_volume: Mapped[float | None]
+    derivative_volume_units: Mapped[VolumeUnits | None]
+    derivative_concentration: Mapped[float | None]
+    derivative_concentration_units: Mapped[ConcentrationUnits | None]
+    tumor_tissue_total_area_percentage: Mapped[float | None]
+    viable_tumor_area_percentage: Mapped[float | None]
+    viable_stroma_area_percentage: Mapped[float | None]
+    necrosis_area_percentage: Mapped[float | None]
+    fibrosis_area_percentage: Mapped[float | None]
+    din: Mapped[float | None]
+    a260_a280: Mapped[float | None]
+    a260_a230: Mapped[float | None]
+    pbmc_viability: Mapped[float | None]
+    pbmc_recovery: Mapped[float | None]
+    pbmc_resting_period_used: Mapped[PBMCRestingPeriodUsed | None]
+    material_used: Mapped[float | None]
+    material_used_units: Mapped[MaterialUnits | None]
+    material_remaining: Mapped[float | None]
+    material_remaining_units: Mapped[MaterialUnits | None]
+    material_storage_condition: Mapped[MaterialStorageCondition | None]
+    qc_condition: Mapped[QCCondition | None]
+    replacement_requested: Mapped[ReplacementRequested | None]
+    residual_use: Mapped[ResidualUse | None]
+    comments: Mapped[str | None]
+    diagnosis_verification: Mapped[DiagnosisVerification | None]
+    intended_assay: Mapped[AssayType | None]
+    date_ingested: Mapped[datetime | None]
+    days_to_specimen_collection: Mapped[int | None]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="specimens", cascade="all, delete")
+    shipment_specimen: Mapped["ShipmentSpecimenORM"] = relationship(
+        back_populates="specimen", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/stem_cell_transplant_orm.py

@@ -0,0 +1,25 @@
+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
+from cidc_api.models.types import StemCellDonorType, AllogeneicDonorType, StemCellSource, ConditioningRegimenType
+
+
+class StemCellTransplantORM(BaseORM):
+    __tablename__ = "stem_cell_transplant"
+    __repr_attrs__ = ["stem_cell_transplant_id"]
+    __table_args__ = {"schema": "stage2"}
+
+    stem_cell_transplant_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage2.treatment.treatment_id", ondelete="CASCADE"))
+
+    stem_cell_donor_type: Mapped[StemCellDonorType]
+    allogeneic_donor_type: Mapped[AllogeneicDonorType]
+    stem_cells_source: Mapped[StemCellSource]
+    days_to_transplant: Mapped[NonNegativeInt]
+    conditioning_regimen_type: Mapped[Optional[ConditioningRegimenType]]
+
+    treatment: Mapped["TreatmentORM"] = relationship(back_populates="stem_cell_transplants", cascade="all, delete")

cidc_api/models/db/stage2/surgery_orm.py

@@ -0,0 +1,27 @@
+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
+from cidc_api.models.types import SurgicalProcedure, UberonAnatomicalTerm, YNU
+
+
+class SurgeryORM(BaseORM):
+    __tablename__ = "surgery"
+    __repr_attrs__ = ["surgery_id", "procedure"]
+    __table_args__ = {"schema": "stage2"}
+
+    surgery_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage2.treatment.treatment_id", ondelete="CASCADE"))
+
+    procedure: Mapped[SurgicalProcedure]
+    procedure_other: Mapped[Optional[str]]
+    days_to_procedure: Mapped[NonNegativeInt]
+    anatomical_location: Mapped[UberonAnatomicalTerm]
+    therapeutic: Mapped[YNU]
+    findings: Mapped[Optional[str]]
+    extent_of_residual_disease: Mapped[Optional[str]]
+
+    treatment: Mapped["TreatmentORM"] = relationship(back_populates="surgeries", cascade="all, delete")

cidc_api/models/db/stage2/therapy_agent_dose_orm.py

@@ -0,0 +1,31 @@
+from pydantic import NonNegativeInt, NonNegativeFloat, PositiveFloat
+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 TherapyAgentDoseUnits, YNU
+
+
+class TherapyAgentDoseORM(BaseORM):
+    __tablename__ = "therapy_agent_dose"
+    __repr_attrs__ = ["therapy_agent_dose_id", "therapy_agent_name"]
+    __table_args__ = {"schema": "stage2"}
+
+    therapy_agent_dose_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage2.treatment.treatment_id", ondelete="CASCADE"))
+
+    course_number: Mapped[Optional[str]]
+    therapy_agent_name: Mapped[str]
+    days_to_start: Mapped[NonNegativeInt]
+    days_to_end: Mapped[NonNegativeInt]
+    number_of_doses: Mapped[NonNegativeInt]
+    received_dose: Mapped[NonNegativeFloat]
+    received_dose_units: Mapped[TherapyAgentDoseUnits]
+    planned_dose: Mapped[Optional[PositiveFloat]]
+    planned_dose_units: Mapped[Optional[TherapyAgentDoseUnits]]
+    dose_changes_delays: Mapped[YNU]
+    changes_delays_description: Mapped[Optional[str]]
+
+    treatment: Mapped["TreatmentORM"] = relationship(back_populates="therapy_agent_doses", cascade="all, delete")

cidc_api/models/db/stage2/treatment_orm.py

@@ -0,0 +1,39 @@
+from typing import List, 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 YNU, OffTreatmentReason
+
+
+class TreatmentORM(BaseORM):
+    __tablename__ = "treatment"
+    __repr_attrs__ = ["treatment_id", "participant_id", "treatment_description"]
+    __table_args__ = {"schema": "stage2"}
+
+    treatment_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
+    arm_id: Mapped[Optional[int]] = mapped_column(ForeignKey("stage2.arm.arm_id", ondelete="CASCADE"))
+    cohort_id: Mapped[Optional[int]] = mapped_column(ForeignKey("stage2.cohort.cohort_id", ondelete="CASCADE"))
+
+    treatment_description: Mapped[str]
+    off_treatment: Mapped[YNU]
+    off_treatment_reason: Mapped[Optional[OffTreatmentReason]]
+    off_treatment_reason_other: Mapped[Optional[str]]
+
+    participant: Mapped["ParticipantORM"] = relationship(back_populates="treatments", cascade="all, delete")
+    arm: Mapped[Optional["ArmORM"]] = relationship(cascade="all, delete")
+    cohort: Mapped[Optional["CohortORM"]] = relationship(cascade="all, delete")
+    adverse_events: Mapped[List["AdverseEventORM"]] = relationship(back_populates="treatment", cascade="all, delete")
+
+    therapy_agent_doses: Mapped[List["TherapyAgentDoseORM"]] = relationship(
+        back_populates="treatment", cascade="all, delete"
+    )
+    radiotherapy_doses: Mapped[List["RadiotherapyDoseORM"]] = relationship(
+        back_populates="treatment", cascade="all, delete"
+    )
+    surgeries: Mapped[List["SurgeryORM"]] = relationship(back_populates="treatment", cascade="all, delete")
+    stem_cell_transplants: Mapped[List["StemCellTransplantORM"]] = relationship(
+        back_populates="treatment", cascade="all, delete"
+    )