nci-cidc-api-modules 1.2.29__py3-none-any.whl → 1.2.45__py3-none-any.whl

cidc_api/models/db/stage2/participant_orm.py

@@ -1,10 +1,10 @@
-from typing import List, Optional
-
+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.base_orm import BaseORM
-from cidc_api.models.types import OffStudyReason
+from cidc_api.models.db.stage2.base_orm import BaseORM
+from cidc_api.models.types import OffStudyReason, YNU
 
 
 class ParticipantORM(BaseORM):
@@ -14,66 +14,66 @@ class ParticipantORM(BaseORM):
         ForeignKeyConstraint(
             ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
         ),
-        {"schema": "stage2"},
     )
+    __data_category__ = "participant"
 
     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(
+    native_participant_id: Mapped[str | None]
+    cimac_participant_id: Mapped[str | None]
+    consent_group_id: Mapped[int | None] = 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]]
+    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(
+    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(
+    prior_treatments: Mapped[List[PriorTreatmentORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    treatments: Mapped[List["TreatmentORM"]] = relationship(
+    treatments: Mapped[List[TreatmentORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    diseases: Mapped[List["DiseaseORM"]] = relationship(
+    diseases: Mapped[List[DiseaseORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    response_by_systems: Mapped[List["ResponseBySystemORM"]] = relationship(
+    response_by_systems: Mapped[List[ResponseBySystemORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    response: Mapped[Optional["ResponseORM"]] = relationship(
+    response: Mapped[ResponseORM | None] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    adverse_events: Mapped[List["AdverseEventORM"]] = relationship(
+    adverse_events: Mapped[List[AdverseEventORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    baseline_clinical_assessment: Mapped[Optional["BaselineClinicalAssessmentORM"]] = relationship(
+    baseline_clinical_assessment: Mapped[BaselineClinicalAssessmentORM | None] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    medical_history: Mapped[Optional["MedicalHistoryORM"]] = relationship(
+    medical_history: Mapped[MedicalHistoryORM | None] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    exposures: Mapped[List["ExposureORM"]] = relationship(
+    exposures: Mapped[List[ExposureORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    gvhd_diagnosis_acutes: Mapped[List["GVHDDiagnosisAcuteORM"]] = relationship(
+    gvhd_diagnosis_acutes: Mapped[List[GVHDDiagnosisAcuteORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    gvhd_diagnosis_chronics: Mapped[List["GVHDDiagnosisChronicORM"]] = relationship(
+    gvhd_diagnosis_chronics: Mapped[List[GVHDDiagnosisChronicORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    specimens: Mapped[List["SpecimenORM"]] = relationship(
+    specimens: Mapped[List[SpecimenORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    other_clinical_endpoints: Mapped[List["OtherClinicalEndpointORM"]] = relationship(
+    other_clinical_endpoints: Mapped[List[OtherClinicalEndpointORM]] = relationship(
         back_populates="participant", cascade="all, delete", passive_deletes=True
     )
-    additional_treatments: Mapped[List["AdditionalTreatmentORM"]] = relationship(
+    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")
+    consent_group: Mapped[ConsentGroupORM] = relationship(back_populates="participants", cascade="all, delete")

cidc_api/models/db/stage2/prior_treatment_orm.py

@@ -1,28 +1,29 @@
-from typing import Optional
+from __future__ import annotations
+from typing import List
 
-from pydantic import NonPositiveInt, NonNegativeInt
+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.base_orm import BaseORM
-from cidc_api.models.types import PriorTreatmentType, ConditioningRegimenType, StemCellDonorType
+from cidc_api.models.db.stage2.base_orm import BaseORM
+from cidc_api.models.types import ConditioningRegimenType, StemCellDonorType
 
 
 class PriorTreatmentORM(BaseORM):
     __tablename__ = "prior_treatment"
     __repr_attrs__ = ["prior_treatment_id", "type"]
-    __table_args__ = {"schema": "stage2"}
+    __data_category__ = "prior_treatment"
 
     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]]
+    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_to_prior_transplant: Mapped[NegativeInt | None]
 
-    participant: Mapped["ParticipantORM"] = relationship(back_populates="prior_treatments", cascade="all, delete")
+    participant: Mapped[ParticipantORM] = relationship(back_populates="prior_treatments", cascade="all, delete")

cidc_api/models/db/stage2/publication_orm.py

@@ -1,10 +1,9 @@
-from typing import Optional, List
-
+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.types import PriorTreatmentType, ConditioningRegimenType, StemCellDonorType
+from cidc_api.models.db.stage2.base_orm import BaseORM
+from cidc_api.models.types import ConditioningRegimenType, StemCellDonorType
 
 
 class PublicationORM(BaseORM):
@@ -14,7 +13,6 @@ class PublicationORM(BaseORM):
         ForeignKeyConstraint(
             ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
         ),
-        {"schema": "stage2"},
     )
 
     publication_id: Mapped[int] = mapped_column(primary_key=True)
@@ -22,10 +20,10 @@ class PublicationORM(BaseORM):
     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]]
+    pubmed_id: Mapped[str | None]
+    publication_title: Mapped[str | None]
+    authorship: Mapped[str | None]
+    year_of_publication: Mapped[str | None]
+    journal_citation: Mapped[str | None]
 
-    trial: Mapped["TrialORM"] = relationship(back_populates="publications", cascade="all, delete")
+    trial: Mapped[TrialORM] = relationship(back_populates="publications", cascade="all, delete")

cidc_api/models/db/stage2/radiotherapy_dose_orm.py

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

cidc_api/models/db/stage2/response_by_system_orm.py

@@ -1,15 +1,16 @@
+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.base_orm import BaseORM
+from cidc_api.models.db.stage2.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"}
+    __data_category__ = "response_by_system"
 
     response_by_system_id: Mapped[int] = mapped_column(primary_key=True)
     participant_id: Mapped[int] = mapped_column(ForeignKey("stage2.participant.participant_id", ondelete="CASCADE"))
@@ -17,6 +18,7 @@ class ResponseBySystemORM(BaseORM):
     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]
@@ -25,4 +27,4 @@ class ResponseBySystemORM(BaseORM):
     progression_free_survival_event: Mapped[YNUNA]
     progression_free_survival: Mapped[PositiveInt | None]
 
-    participant: Mapped["ParticipantORM"] = relationship(back_populates="response_by_systems", cascade="all, delete")
+    participant: Mapped[ParticipantORM] = relationship(back_populates="response_by_systems", cascade="all, delete")

cidc_api/models/db/stage2/response_orm.py

@@ -1,27 +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.base_orm import BaseORM
+from cidc_api.models.db.stage2.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"}
+    __data_category__ = "response"
 
     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]
+    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_follow_up: Mapped[NonNegativeInt | None]
+    days_to_last_vital_status: Mapped[NonNegativeInt | None]
 
-    participant: Mapped["ParticipantORM"] = relationship(back_populates="response", cascade="all, delete")
+    participant: Mapped[ParticipantORM] = relationship(back_populates="response", cascade="all, delete")

cidc_api/models/db/stage2/shipment_orm.py

@@ -1,10 +1,11 @@
+from __future__ import annotations
 from datetime import datetime
-from typing import Optional, List
+from typing import 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.db.stage2.base_orm import BaseORM
 from cidc_api.models.types import AssayPriority, AssayType, Courier, ShipmentCondition, ShipmentQuality
 
 
@@ -15,7 +16,6 @@ class ShipmentORM(BaseORM):
         ForeignKeyConstraint(
             ["trial_id", "version"], ["stage2.trial.trial_id", "stage2.trial.version"], ondelete="CASCADE"
         ),
-        {"schema": "stage2"},
     )
 
     shipment_id: Mapped[int] = mapped_column(primary_key=True)
@@ -24,24 +24,24 @@ class ShipmentORM(BaseORM):
     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]]
+    assay_priority: Mapped[AssayPriority | None]
+    assay_type: Mapped[AssayType | None]
+    courier: Mapped[Courier | None]
+    tracking_number: Mapped[str | None]
+    condition: Mapped[ShipmentCondition | None]
+    condition_other: Mapped[str | None]
+    date_shipped: Mapped[datetime | None]
+    date_received: Mapped[datetime | None]
+    quality: Mapped[ShipmentQuality | None]
 
-    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(
+    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(
+    shipped_to: Mapped[ContactORM] = relationship(
         back_populates="shipment_to", cascade="all, delete", foreign_keys="[ContactORM.shipment_to_id]"
     )
-    shipment_specimens: Mapped[List["ShipmentSpecimenORM"]] = relationship(
+    shipment_specimens: Mapped[List[ShipmentSpecimenORM]] = relationship(
         back_populates="shipment", cascade="all, delete", passive_deletes=True
     )

cidc_api/models/db/stage2/shipment_specimen_orm.py

@@ -1,15 +1,15 @@
+from __future__ import annotations
 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
+from cidc_api.models.db.stage2.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
@@ -20,5 +20,5 @@ class ShipmentSpecimenORM(BaseORM):
     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")
+    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

@@ -1,10 +1,11 @@
+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.base_orm import BaseORM
+from cidc_api.models.db.stage2.base_orm import BaseORM
 from cidc_api.models.types import (
     UberonAnatomicalTerm,
     ICDO3MorphologicalCode,
@@ -32,7 +33,6 @@ from cidc_api.models.types import (
 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"))
@@ -45,7 +45,7 @@ class SpecimenORM(BaseORM):
     organ_site_of_collection: Mapped[UberonAnatomicalTerm | None]
     histology_behavior: Mapped[ICDO3MorphologicalCode | None]
     histology_behavior_description: Mapped[str | None]
-    collection_event_name: Mapped[str | None]
+    collection_event_name: Mapped[str]
     specimen_type: Mapped[SpecimenType | None]
     specimen_type_other: Mapped[str | None]
     specimen_description: Mapped[SpecimenDescription | None]
@@ -92,9 +92,10 @@ class SpecimenORM(BaseORM):
     diagnosis_verification: Mapped[DiagnosisVerification | None]
     intended_assay: Mapped[AssayType | None]
     date_ingested: Mapped[datetime | None]
-    days_to_specimen_collection: Mapped[int | None]
+    days_to_specimen_collection: Mapped[int]
+    organ_site_of_collection: Mapped[UberonAnatomicalTerm]
 
-    participant: Mapped["ParticipantORM"] = relationship(back_populates="specimens", cascade="all, delete")
-    shipment_specimen: Mapped["ShipmentSpecimenORM"] = relationship(
+    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

@@ -1,25 +1,25 @@
+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
 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"}
+    __data_category__ = "stem_cell_transplant"
 
     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]
+    allogeneic_donor_type: Mapped[AllogeneicDonorType | None]
+    stem_cell_source: Mapped[StemCellSource]
     days_to_transplant: Mapped[NonNegativeInt]
-    conditioning_regimen_type: Mapped[Optional[ConditioningRegimenType]]
+    conditioning_regimen_type: Mapped[ConditioningRegimenType | None]
 
-    treatment: Mapped["TreatmentORM"] = relationship(back_populates="stem_cell_transplants", cascade="all, delete")
+    treatment: Mapped[TreatmentORM] = relationship(back_populates="stem_cell_transplants", cascade="all, delete")

cidc_api/models/db/stage2/surgery_orm.py

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

cidc_api/models/db/stage2/therapy_agent_dose_orm.py

@@ -1,31 +1,31 @@
+from __future__ import annotations
 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.db.stage2.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"}
+    __data_category__ = "therapy_agent_dose"
 
     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]]
+    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[Optional[PositiveFloat]]
-    planned_dose_units: Mapped[Optional[TherapyAgentDoseUnits]]
+    planned_dose: Mapped[PositiveFloat | None]
+    planned_dose_units: Mapped[TherapyAgentDoseUnits | None]
     dose_changes_delays: Mapped[YNU]
-    changes_delays_description: Mapped[Optional[str]]
+    changes_delays_description: Mapped[str | None]
 
-    treatment: Mapped["TreatmentORM"] = relationship(back_populates="therapy_agent_doses", cascade="all, delete")
+    treatment: Mapped[TreatmentORM] = relationship(back_populates="therapy_agent_doses", cascade="all, delete")

cidc_api/models/db/stage2/treatment_orm.py

@@ -1,39 +1,40 @@
-from typing import List, Optional
+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
 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"}
+    __data_category__ = "treatment"
 
     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"))
+    arm_id: Mapped[int | None] = mapped_column(ForeignKey("stage2.arm.arm_id", ondelete="CASCADE"))
+    cohort_id: Mapped[int | None] = 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]]
+    off_treatment_reason: Mapped[OffTreatmentReason | None]
+    off_treatment_reason_other: Mapped[str | None]
 
-    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")
+    participant: Mapped[ParticipantORM] = relationship(back_populates="treatments", cascade="all, delete")
+    arm: Mapped[ArmORM | None] = relationship(cascade="all, delete")
+    cohort: Mapped[CohortORM | None] = relationship(cascade="all, delete")
+    adverse_events: Mapped[List[AdverseEventORM]] = relationship(back_populates="treatment", cascade="all, delete")
 
-    therapy_agent_doses: Mapped[List["TherapyAgentDoseORM"]] = relationship(
+    therapy_agent_doses: Mapped[List[TherapyAgentDoseORM]] = relationship(
         back_populates="treatment", cascade="all, delete"
     )
-    radiotherapy_doses: Mapped[List["RadiotherapyDoseORM"]] = relationship(
+    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(
+    surgeries: Mapped[List[SurgeryORM]] = relationship(back_populates="treatment", cascade="all, delete")
+    stem_cell_transplants: Mapped[List[StemCellTransplantORM]] = relationship(
         back_populates="treatment", cascade="all, delete"
     )