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

cidc_api/models/db/stage1/participant_orm.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from typing import List
+
+from sqlalchemy import ForeignKey, ForeignKeyConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.base_orm import BaseORM
+from cidc_api.models.types import OffStudyReason, YNU
+
+
+class ParticipantORM(BaseORM):
+    __tablename__ = "participant"
+    __repr_attrs__ = ["participant_id", "native_participant_id", "cimac_participant_id"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage1.trial.trial_id", "stage1.trial.version"], ondelete="CASCADE"
+        ),
+    )
+    __data_category__ = "participant"
+
+    participant_id: Mapped[int] = mapped_column(primary_key=True)
+    trial_id: Mapped[str]
+    version: Mapped[str]
+
+    native_participant_id: Mapped[str | None]
+    cimac_participant_id: Mapped[str | None]
+    consent_group_id: Mapped[int | None] = mapped_column(
+        ForeignKey("stage1.consent_group.consent_group_id", ondelete="CASCADE")
+    )
+    off_study: Mapped[YNU]
+    off_study_reason: Mapped[OffStudyReason | None]
+    off_study_reason_other: Mapped[str | None]
+
+    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[ResponseORM | None] = 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[BaselineClinicalAssessmentORM | None] = relationship(
+        back_populates="participant", cascade="all, delete", passive_deletes=True
+    )
+    medical_history: Mapped[MedicalHistoryORM | None] = 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
+    )
+    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/stage1/prior_treatment_orm.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from typing import List
+
+from pydantic import NonPositiveInt, NegativeInt
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.types import JSON
+
+from cidc_api.models.db.stage1.base_orm import BaseORM
+from cidc_api.models.types import ConditioningRegimenType, StemCellDonorType
+
+
+class PriorTreatmentORM(BaseORM):
+    __tablename__ = "prior_treatment"
+    __repr_attrs__ = ["prior_treatment_id", "type"]
+    __data_category__ = "prior_treatment"
+
+    prior_treatment_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+
+    prior_treatment_days_to_start: Mapped[NonPositiveInt | None]
+    prior_treatment_days_to_end: Mapped[NonPositiveInt | None]
+    prior_treatment_description: Mapped[str]
+    prior_treatment_best_response: Mapped[str | None]
+    prior_treatment_conditioning_regimen_type: Mapped[ConditioningRegimenType | None]
+    prior_treatment_stem_cell_donor_type: Mapped[StemCellDonorType | None]
+    prior_treatment_days_from_transplant_to_treatment_initiation: Mapped[NegativeInt | None]
+
+    participant: Mapped[ParticipantORM] = relationship(back_populates="prior_treatments", cascade="all, delete")

cidc_api/models/db/stage1/radiotherapy_dose_orm.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from pydantic import NonNegativeInt, NonNegativeFloat, PositiveFloat
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"]
+    __data_category__ = "radiotherapy_dose"
+
+    radiotherapy_dose_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage1.treatment.treatment_id", ondelete="CASCADE"))
+
+    days_to_start: Mapped[NonNegativeInt]
+    days_to_end: Mapped[NonNegativeInt]
+    procedure: Mapped[RadiotherapyProcedure]
+    anatomical_location: Mapped[UberonAnatomicalTerm | None]
+    is_total_dose: Mapped[bool]
+    number_of_fractions: Mapped[NonNegativeInt | None]
+    received_dose: Mapped[NonNegativeFloat]
+    received_dose_units: Mapped[RadiotherapyDoseUnits]
+    planned_dose: Mapped[PositiveFloat | None]
+    planned_dose_units: Mapped[RadiotherapyDoseUnits | None]
+    dose_changes_delays: Mapped[YNU]
+    changes_delays_description: Mapped[str | None]
+    radiation_extent: Mapped[RadiationExtent]
+
+    treatment: Mapped[TreatmentORM] = relationship(back_populates="radiotherapy_doses", cascade="all, delete")

cidc_api/models/db/stage1/response_by_system_orm.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from pydantic import PositiveInt
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"]
+    __data_category__ = "response_by_system"
+
+    response_by_system_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.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]
+    duration_of_stable_disease: 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/stage1/response_orm.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from pydantic import NonNegativeInt
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.base_orm import BaseORM
+from cidc_api.models.types import SurvivalStatus, YNUNA, CauseOfDeath
+
+
+class ResponseORM(BaseORM):
+    __tablename__ = "response"
+    __repr_attrs__ = ["response_id", "participant_id"]
+    __data_category__ = "response"
+
+    response_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+    survival_status: Mapped[SurvivalStatus]
+    overall_survival: Mapped[NonNegativeInt]
+    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_vital_status: Mapped[NonNegativeInt | None]
+
+    participant: Mapped[ParticipantORM] = relationship(back_populates="response", cascade="all, delete")

cidc_api/models/db/stage1/specimen_orm.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+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.stage1.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"]
+    __data_category__ = "specimen"
+
+    specimen_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+
+    cimac_id: Mapped[str]
+    collection_event_name: Mapped[str]
+    days_to_specimen_collection: Mapped[int]
+    organ_site_of_collection: Mapped[UberonAnatomicalTerm]
+
+    participant: Mapped[ParticipantORM] = relationship(back_populates="specimens", cascade="all, delete")

cidc_api/models/db/stage1/stem_cell_transplant_orm.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from pydantic import NonNegativeInt
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"]
+    __data_category__ = "stem_cell_transplant"
+
+    stem_cell_transplant_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage1.treatment.treatment_id", ondelete="CASCADE"))
+
+    stem_cell_donor_type: Mapped[StemCellDonorType]
+    allogeneic_donor_type: Mapped[AllogeneicDonorType | None]
+    stem_cell_source: Mapped[StemCellSource]
+    days_to_transplant: Mapped[NonNegativeInt]
+    conditioning_regimen_type: Mapped[ConditioningRegimenType | None]
+
+    treatment: Mapped[TreatmentORM] = relationship(back_populates="stem_cell_transplants", cascade="all, delete")

cidc_api/models/db/stage1/surgery_orm.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from pydantic import NonNegativeInt
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.base_orm import BaseORM
+from cidc_api.models.types import SurgicalProcedure, UberonAnatomicalTerm, YNU
+
+
+class SurgeryORM(BaseORM):
+    __tablename__ = "surgery"
+    __repr_attrs__ = ["surgery_id", "procedure"]
+    __data_category__ = "surgery"
+
+    surgery_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage1.treatment.treatment_id", ondelete="CASCADE"))
+
+    procedure: Mapped[SurgicalProcedure]
+    procedure_other: Mapped[str | None]
+    days_to_procedure: Mapped[NonNegativeInt]
+    anatomical_location: Mapped[UberonAnatomicalTerm]
+    therapeutic: Mapped[YNU]
+    findings: Mapped[str | None]
+    extent_of_residual_disease: Mapped[str | None]
+
+    treatment: Mapped[TreatmentORM] = relationship(back_populates="surgeries", cascade="all, delete")

cidc_api/models/db/stage1/therapy_agent_dose_orm.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from pydantic import NonNegativeInt, NonNegativeFloat, PositiveFloat
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"]
+    __data_category__ = "therapy_agent_dose"
+
+    therapy_agent_dose_id: Mapped[int] = mapped_column(primary_key=True)
+    treatment_id: Mapped[int] = mapped_column(ForeignKey("stage1.treatment.treatment_id", ondelete="CASCADE"))
+
+    course_number: Mapped[str | None]
+    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[PositiveFloat | None]
+    planned_dose_units: Mapped[TherapyAgentDoseUnits | None]
+    dose_changes_delays: Mapped[YNU]
+    changes_delays_description: Mapped[str | None]
+
+    treatment: Mapped[TreatmentORM] = relationship(back_populates="therapy_agent_doses", cascade="all, delete")

cidc_api/models/db/stage1/treatment_orm.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"]
+    __data_category__ = "treatment"
+
+    treatment_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+    arm: Mapped[str | None]
+    cohort: Mapped[str | None]
+
+    treatment_description: Mapped[str]
+    off_treatment: Mapped[YNU]
+    off_treatment_reason: Mapped[OffTreatmentReason | None]
+    off_treatment_reason_other: Mapped[str | None]
+
+    participant: Mapped[ParticipantORM] = relationship(back_populates="treatments", 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"
+    )

cidc_api/models/db/stage1/trial_orm.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import List
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.types import JSON
+
+from cidc_api.models.db.stage1.base_orm import BaseORM
+from cidc_api.models.types import PrimaryPurposeType, AgeGroup
+
+
+class TrialORM(BaseORM):
+    __tablename__ = "trial"
+    __repr_attrs__ = ["trial_id", "version"]
+    __data_category__ = "study"
+
+    trial_id: Mapped[str] = mapped_column(primary_key=True)
+    version: Mapped[str] = mapped_column(primary_key=True)
+
+    primary_endpoint: Mapped[str | None]
+    age_group: Mapped[List[AgeGroup]] = mapped_column(JSON, nullable=True)
+    study_population: Mapped[str | None]
+    trial_type: Mapped[str | None]
+    dates_of_conduct_start: Mapped[datetime]
+    dates_of_conduct_end: Mapped[datetime | None]
+    primary_purpose_type: Mapped[PrimaryPurposeType]
+    dbgap_study_accession: Mapped[str]
+
+    participants: Mapped[List[ParticipantORM]] = relationship(
+        back_populates="trial", cascade="all, delete", passive_deletes=True
+    )
+    consent_groups: Mapped[List[ConsentGroupORM]] = relationship(
+        back_populates="trial", cascade="all, delete", passive_deletes=True
+    )

cidc_api/models/db/stage2/additional_treatment_orm.py

@@ -1,23 +1,22 @@
+from __future__ import annotations
 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.db.stage2.base_orm import BaseORM
 
 
 class AdditionalTreatmentORM(BaseORM):
     __tablename__ = "additional_treatment"
-    __repr_attrs__ = ["additional_treatment_id", "participant_id", "description"]
-    __table_args__ = {"schema": "stage2"}
+    __repr_attrs__ = ["additional_treatment_id", "participant_id"]
     __data_category__ = "additional_treatment"
 
     additional_treatment_id: Mapped[int] = mapped_column(primary_key=True)
     participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
 
-    additional_treatment_days_to_start: Mapped[Optional[NonNegativeInt]]
-    additional_treatment_days_to_end: Mapped[Optional[NonNegativeInt]]
+    additional_treatment_days_to_start: Mapped[NonNegativeInt | None]
+    additional_treatment_days_to_end: Mapped[NonNegativeInt | None]
     additional_treatment_description: Mapped[str]
 
-    participant: Mapped["ParticipantORM"] = relationship(back_populates="additional_treatments", cascade="all, delete")
+    participant: Mapped[ParticipantORM] = relationship(back_populates="additional_treatments", cascade="all, delete")

cidc_api/models/db/stage2/administrative_person_orm.py

@@ -1,15 +1,15 @@
+from __future__ import annotations
 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.db.stage2.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"))
@@ -19,7 +19,7 @@ class AdministrativePersonORM(BaseORM):
     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(
+    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

@@ -1,7 +1,8 @@
+from __future__ import annotations
 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.db.stage2.base_orm import BaseORM
 from cidc_api.models.types import AdministrativeRole
 
 
@@ -12,7 +13,6 @@ class AdministrativeRoleAssignmentORM(BaseORM):
         ForeignKeyConstraint(
             ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
         ),
-        {"schema": "stage2"},
     )
 
     trial_id: Mapped[str] = mapped_column(primary_key=True)
@@ -22,7 +22,7 @@ class AdministrativeRoleAssignmentORM(BaseORM):
     )
     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(
+    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

@@ -1,10 +1,9 @@
-from typing import Optional
-
+from __future__ import annotations
 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.db.stage2.base_orm import BaseORM
 from cidc_api.models.types import (
     CTCAEEventTerm,
     CTCAEEventCode,
@@ -21,28 +20,27 @@ from cidc_api.models.types import (
 class AdverseEventORM(BaseORM):
     __tablename__ = "adverse_event"
     __repr_attrs__ = ["adverse_event_id", "participant_id", "event_term"]
-    __table_args__ = {"schema": "stage2"}
     __data_category__ = "adverse_event"
 
     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"))
+    treatment_id: Mapped[int | None] = mapped_column(ForeignKey("stage2.treatment.treatment_id", ondelete="CASCADE"))
 
-    event_term: Mapped[Optional[CTCAEEventTerm]]
-    event_code: Mapped[Optional[CTCAEEventCode]]
+    event_term: Mapped[CTCAEEventTerm | None]
+    event_code: Mapped[CTCAEEventCode | None]
     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]]
+    event_other_specify: Mapped[str | None]
+    system_organ_class: Mapped[SystemOrganClass | None]
     discontinuation_due_to_event: Mapped[bool]
     days_to_onset_of_event: Mapped[NonNegativeInt]
-    days_to_resolution_of_event: Mapped[Optional[NonNegativeInt]]
+    days_to_resolution_of_event: Mapped[NonNegativeInt | None]
     serious_adverse_event: Mapped[YNU]
     dose_limiting_toxicity: Mapped[YNU]
     attribution_cause: Mapped[AttributionCause]
     attribution_likelihood: Mapped[AttributionLikelihood]
-    individual_therapy: Mapped[Optional[str]]
+    individual_therapy: Mapped[str | None]
 
-    participant: Mapped["ParticipantORM"] = relationship(back_populates="adverse_events", cascade="all, delete")
-    treatment: Mapped["TreatmentORM"] = relationship(back_populates="adverse_events", cascade="all, delete")
+    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

@@ -1,7 +1,8 @@
+from __future__ import annotations
 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.db.stage2.base_orm import BaseORM
 
 
 class ArmORM(BaseORM):
@@ -11,7 +12,6 @@ class ArmORM(BaseORM):
         ForeignKeyConstraint(
             ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
         ),
-        {"schema": "stage2"},
     )
 
     arm_id: Mapped[int] = mapped_column(primary_key=True)
@@ -20,4 +20,4 @@ class ArmORM(BaseORM):
 
     name: Mapped[str]
 
-    trial: Mapped["TrialORM"] = relationship(back_populates="arms", cascade="all, delete")
+    trial: Mapped[TrialORM] = relationship(back_populates="arms", cascade="all, delete")

cidc_api/models/db/stage2/base_orm.py

@@ -0,0 +1,7 @@
+from sqlalchemy_mixins import SerializeMixin, ReprMixin
+from cidc_api.config.db import Stage2BaseModel, ModelMixin
+
+
+class BaseORM(Stage2BaseModel, ModelMixin, ReprMixin, SerializeMixin):
+    __abstract__ = True
+    __repr__ = ReprMixin.__repr__

cidc_api/models/db/stage2/baseline_clinical_assessment_orm.py

@@ -1,24 +1,22 @@
-from typing import Optional
-
+from __future__ import annotations
 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.db.stage2.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"}
     __data_category__ = "baseline_clinical_assessment"
 
     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]]
+    ecog_score: Mapped[ECOGScore | None]
+    karnofsky_score: Mapped[KarnofskyScore | None]
 
-    participant: Mapped["ParticipantORM"] = relationship(
+    participant: Mapped[ParticipantORM] = relationship(
         back_populates="baseline_clinical_assessment", cascade="all, delete"
     )

cidc_api/models/db/stage2/cohort_orm.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from sqlalchemy import ForeignKeyConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from cidc_api.models.db.base_orm import BaseORM
+from cidc_api.models.db.stage2.base_orm import BaseORM
 
 
 class CohortORM(BaseORM):
@@ -11,7 +12,6 @@ class CohortORM(BaseORM):
         ForeignKeyConstraint(
             ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
         ),
-        {"schema": "stage2"},
     )
 
     cohort_id: Mapped[int] = mapped_column(primary_key=True)
@@ -20,4 +20,4 @@ class CohortORM(BaseORM):
 
     name: Mapped[str]
 
-    trial: Mapped["TrialORM"] = relationship(back_populates="cohorts", cascade="all, delete")
+    trial: Mapped[TrialORM] = relationship(back_populates="cohorts", cascade="all, delete")