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

boot.py

@@ -0,0 +1,14 @@
+from os import mkdir, path
+import shutil
+
+TEMPLATES_DIR = path.join("/tmp", "templates")
+
+
+# set up the directories for holding generated templates
+def set_up_templates_directories():
+    if path.exists(TEMPLATES_DIR):
+        shutil.rmtree(TEMPLATES_DIR)
+    mkdir(TEMPLATES_DIR)
+    for family in ["assays", "manifests", "analyses"]:
+        family_dir = path.join(TEMPLATES_DIR, family)
+        mkdir(family_dir)

cidc_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.2.53"

cidc_api/config/db.py

@@ -1,8 +1,10 @@
 from os import environ
+from typing import Self
 
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
 from flask_migrate import Migrate, upgrade
+from sqlalchemy import MetaData
 from sqlalchemy.engine.url import URL
 from sqlalchemy.orm import declarative_base
 from google.cloud.sql.connector import Connector, IPTypes
@@ -11,6 +13,8 @@ from .secrets import get_secrets_manager
 
 db = SQLAlchemy()
 BaseModel = db.Model
+Stage1BaseModel = SQLAlchemy(metadata=MetaData(schema="stage1")).Model
+Stage2BaseModel = SQLAlchemy(metadata=MetaData(schema="stage2")).Model
 
 connector = Connector()
 
@@ -46,7 +50,6 @@ def get_sqlalchemy_database_uri(testing: bool = False) -> str:
         db_uri = f"postgresql+pg8000://{environ.get('CLOUD_SQL_DB_USER')}:xxx@/{environ.get('CLOUD_SQL_DB_NAME')}"
 
     assert db_uri
-
     return db_uri
 
 
@@ -56,3 +59,20 @@ def cloud_connector(testing: bool = False):
         return {"creator": getconn}
     else:
         return {}
+
+
+class ModelMixin:
+    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/config/settings.py

@@ -5,11 +5,11 @@ Any 'UPPER_CASE' variables will be exported as a key-value pair
 in the `SETTINGS` dictionary defined at the bottom of this file.
 """
 
-import shutil
-from os import environ, path, mkdir
+from os import environ, path
 
 from dotenv import load_dotenv
 
+from boot import TEMPLATES_DIR as templates_dir
 from .db import get_sqlalchemy_database_uri, cloud_connector
 from .secrets import get_secrets_manager
 
@@ -36,14 +36,7 @@ PAGINATION_PAGE_SIZE = 25
 MAX_PAGINATION_PAGE_SIZE = 200
 INACTIVE_USER_DAYS = 60
 MAX_THREADPOOL_WORKERS = 32
-TEMPLATES_DIR = path.join("/tmp", "templates")
-# Also, set up the directories for holding generated templates
-if path.exists(TEMPLATES_DIR):
-    shutil.rmtree(TEMPLATES_DIR)
-mkdir(TEMPLATES_DIR)
-for family in ["assays", "manifests", "analyses"]:
-    family_dir = path.join(TEMPLATES_DIR, family)
-    mkdir(family_dir)
+TEMPLATES_DIR = templates_dir
 
 ### Configure prism encrypt ###
 if not TESTING:
@@ -84,6 +77,8 @@ GOOGLE_ARTIFACT_UPLOAD_TOPIC = environ["GOOGLE_ARTIFACT_UPLOAD_TOPIC"]
 GOOGLE_GRANT_DOWNLOAD_PERMISSIONS_TOPIC = environ["GOOGLE_GRANT_DOWNLOAD_PERMISSIONS_TOPIC"]
 GOOGLE_HL_CLINICAL_VALIDATION_TOPIC = environ["GOOGLE_HL_CLINICAL_VALIDATION_TOPIC"]
 GOOGLE_DL_CLINICAL_VALIDATION_TOPIC = environ["GOOGLE_DL_CLINICAL_VALIDATION_TOPIC"]
+GOOGLE_ASSAY_METADATA_VALIDATION_TOPIC = environ["GOOGLE_ASSAY_METADATA_VALIDATION_TOPIC"]
+GOOGLE_CLINICAL_DATA_INGESTION_PROCESSING_TOPIC = "ingestion"
 GOOGLE_AND_OPERATOR = " && "
 GOOGLE_OR_OPERATOR = " || "
 

cidc_api/models/__init__.py

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

cidc_api/models/data.py

@@ -1,19 +1,28 @@
-from cidc_api.models.pydantic.stage2 import all_models
-from cidc_api.models.db.stage2 import all_models as all_db_models
+from cidc_api.models.pydantic.stage1 import all_models as stage1_all_models
+from cidc_api.models.pydantic.stage2 import all_models as stage2_all_models
+from cidc_api.models.db.stage1 import all_models as stage1_all_db_models
+from cidc_api.models.db.stage2 import all_models as stage2_all_db_models
 
-standard_data_categories = [model.__data_category__ for model in all_models if hasattr(model, "__data_category__")]
+standard_data_categories = [
+    model.__data_category__ for model in stage1_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] = []
+        super().__init__(*args, **kwargs)
 
 
 # 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__")}
+data_category_to_model = {
+    "stage1": {model.__data_category__: model for model in stage1_all_models if hasattr(model, "__data_category__")},
+    "stage2": {model.__data_category__: model for model in stage2_all_models if hasattr(model, "__data_category__")},
+}
+
 data_category_to_db_model = {
-    model.__data_category__: model for model in all_db_models if hasattr(model, "__data_category__")
+    "stage1": {model.__data_category__: model for model in stage1_all_db_models if hasattr(model, "__data_category__")},
+    "stage2": {model.__data_category__: model for model in stage2_all_db_models if hasattr(model, "__data_category__")},
 }

cidc_api/models/db/stage1/__init__.py

@@ -0,0 +1,56 @@
+from .additional_treatment_orm import AdditionalTreatmentORM
+from .adverse_event_orm import AdverseEventORM
+from .baseline_clinical_assessment_orm import BaselineClinicalAssessmentORM
+from .comorbidity_orm import ComorbidityORM
+from .consent_group_orm import ConsentGroupORM
+from .demographic_orm import DemographicORM
+from .disease_orm import DiseaseORM
+from .exposure_orm import ExposureORM
+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 .medical_history_orm import MedicalHistoryORM
+from .other_malignancy_orm import OtherMalignancyORM
+from .participant_orm import ParticipantORM
+from .prior_treatment_orm import PriorTreatmentORM
+from .radiotherapy_dose_orm import RadiotherapyDoseORM
+from .response_by_system_orm import ResponseBySystemORM
+from .response_orm import ResponseORM
+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",
+    "AdverseEventORM",
+    "BaselineClinicalAssessmentORM",
+    "ComorbidityORM",
+    "ConsentGroupORM",
+    "DemographicORM",
+    "DiseaseORM",
+    "ExposureORM",
+    "GVHDDiagnosisAcuteORM",
+    "GVHDDiagnosisChronicORM",
+    "GVHDOrganAcuteORM",
+    "GVHDOrganChronicORM",
+    "MedicalHistoryORM",
+    "OtherMalignancyORM",
+    "ParticipantORM",
+    "PriorTreatmentORM",
+    "RadiotherapyDoseORM",
+    "ResponseBySystemORM",
+    "ResponseORM",
+    "SpecimenORM",
+    "StemCellTransplantORM",
+    "SurgeryORM",
+    "TherapyAgentDoseORM",
+    "TreatmentORM",
+    "TrialORM",
+]
+
+all_models = [globals()[cls_name] for cls_name in __all__]

cidc_api/models/db/stage1/additional_treatment_orm.py

@@ -0,0 +1,22 @@
+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
+
+
+class AdditionalTreatmentORM(BaseORM):
+    __tablename__ = "additional_treatment"
+    __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("stage1.participant.participant_id", ondelete="CASCADE"))
+
+    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")

cidc_api/models/db/stage1/adverse_event_orm.py

@@ -0,0 +1,46 @@
+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 (
+    CTCAEEventTerm,
+    CTCAEEventCode,
+    SeverityGradeSystem,
+    SeverityGradeSystemVersion,
+    SeverityGrade,
+    SystemOrganClass,
+    AttributionCause,
+    AttributionLikelihood,
+    YNU,
+)
+
+
+class AdverseEventORM(BaseORM):
+    __tablename__ = "adverse_event"
+    __repr_attrs__ = ["adverse_event_id", "participant_id", "event_term"]
+    __data_category__ = "adverse_event"
+
+    adverse_event_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+    treatment_id: Mapped[int | None] = mapped_column(ForeignKey("stage1.treatment.treatment_id", ondelete="CASCADE"))
+
+    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[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[NonNegativeInt | None]
+    serious_adverse_event: Mapped[YNU]
+    dose_limiting_toxicity: Mapped[YNU]
+    attribution_cause: Mapped[AttributionCause]
+    attribution_likelihood: Mapped[AttributionLikelihood]
+    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")

cidc_api/models/db/stage1/base_orm.py

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

cidc_api/models/db/stage1/baseline_clinical_assessment_orm.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+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 ECOGScore, KarnofskyScore
+
+
+class BaselineClinicalAssessmentORM(BaseORM):
+    __tablename__ = "baseline_clinical_assessment"
+    __repr_attrs__ = ["baseline_clinical_assessment_id", "participant_id"]
+    __data_category__ = "baseline_clinical_assessment"
+
+    baseline_clinical_assessment_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+
+    ecog_score: Mapped[ECOGScore | None]
+    karnofsky_score: Mapped[KarnofskyScore | None]
+
+    participant: Mapped[ParticipantORM] = relationship(
+        back_populates="baseline_clinical_assessment", cascade="all, delete"
+    )

cidc_api/models/db/stage1/comorbidity_orm.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+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 ICD10CMCode, ICD10CMTerm
+
+
+class ComorbidityORM(BaseORM):
+    __tablename__ = "comorbidity"
+    __repr_attrs__ = ["comorbidity_id", "comorbidity_term"]
+    __data_category__ = "comorbidity"
+
+    comorbidity_id: Mapped[int] = mapped_column(primary_key=True)
+    medical_history_id: Mapped[int] = mapped_column(
+        ForeignKey("stage1.medical_history.medical_history_id", ondelete="CASCADE")
+    )
+
+    comorbidity_code: Mapped[ICD10CMCode | None]
+    comorbidity_term: Mapped[ICD10CMTerm | None]
+    comorbidity_other: Mapped[str | None]
+
+    medical_history: Mapped[MedicalHistoryORM] = relationship(back_populates="comorbidities", cascade="all, delete")

cidc_api/models/db/stage1/consent_group_orm.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+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.stage1.base_orm import BaseORM
+
+
+class ConsentGroupORM(BaseORM):
+    __tablename__ = "consent_group"
+    __repr_attrs__ = ["consent_group_id", "consent_group_name"]
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["trial_id", "version"], ["stage1.trial.trial_id", "stage1.trial.version"], ondelete="CASCADE"
+        ),
+    )
+    __data_category__ = "consent_group"
+
+    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/stage1/demographic_orm.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from pydantic import NonNegativeFloat, PositiveFloat, PositiveInt
+from typing import List
+
+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 (
+    Sex,
+    Race,
+    Ethnicity,
+    HeightUnits,
+    WeightUnits,
+    BodySurfaceAreaUnits,
+    Occupation,
+    Education,
+    AgeAtEnrollmentUnits,
+)
+
+
+class DemographicORM(BaseORM):
+    __tablename__ = "demographic"
+    __repr_attrs__ = ["demographic_id", "participant_id", "age_at_enrollment", "sex"]
+    __data_category__ = "demographic"
+
+    demographic_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+    age_at_enrollment: Mapped[PositiveInt | None]
+    age_at_enrollment_units: Mapped[AgeAtEnrollmentUnits | None]
+    age_90_or_over: Mapped[bool]
+    sex: Mapped[Sex]
+    race: Mapped[List[Race]] = mapped_column(JSON)
+    ethnicity: Mapped[Ethnicity]
+    height: Mapped[PositiveFloat]
+    height_units: Mapped[HeightUnits]
+    weight: Mapped[PositiveFloat]
+    weight_units: Mapped[WeightUnits]
+    body_mass_index: Mapped[PositiveFloat | None]
+    body_surface_area: Mapped[PositiveFloat | None]
+    body_surface_area_units: Mapped[BodySurfaceAreaUnits | None]
+    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/stage1/disease_orm.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from typing import List
+
+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.stage1.base_orm import BaseORM
+from cidc_api.models.types import (
+    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",
+    ]
+    __data_category__ = "disease"
+
+    disease_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+    primary_disease_site: Mapped[UberonAnatomicalTerm]
+    morphological_code: Mapped[ICDO3MorphologicalCode | None]
+    morphological_term: Mapped[ICDO3MorphologicalTerm | None]
+    cancer_type_description: Mapped[str | None]
+    days_since_original_diagnosis: Mapped[NonPositiveInt | None]
+    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 | None] = mapped_column(String)
+    t_category: Mapped[TCategory | None]
+    n_category: Mapped[NCategory | None]
+    m_category: Mapped[MCategory | None]
+    metastatic_organ: Mapped[List[UberonAnatomicalTerm] | None] = 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/stage1/exposure_orm.py

@@ -0,0 +1,22 @@
+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, ExposureType
+
+
+class ExposureORM(BaseORM):
+    __tablename__ = "exposure"
+    __repr_attrs__ = ["exposure_id", "exposure_type", "carcinogen_exposure"]
+    __data_category__ = "exposure"
+
+    exposure_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+
+    carcinogen_exposure: Mapped[YNU]
+    exposure_type: Mapped[ExposureType | None]
+
+    participant: Mapped[ParticipantORM] = relationship(back_populates="exposures", cascade="all, delete")

cidc_api/models/db/stage1/gvhd_diagnosis_acute_orm.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from typing import List
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"),
+    )
+    __repr_attrs__ = ["gvhd_diagnosis_acute_id", "pre_or_post_enrollment"]
+    __data_category__ = "gvhd_diagnosis_acute"
+
+    gvhd_diagnosis_acute_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.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/stage1/gvhd_diagnosis_chronic_orm.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import List
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from cidc_api.models.db.stage1.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"
+        ),
+    )
+    __repr_attrs__ = ["gvhd_diagnosis_chronic_id", "pre_or_post_enrollment"]
+    __data_category__ = "gvhd_diagnosis_chronic"
+
+    gvhd_diagnosis_chronic_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.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
+    )

cidc_api/models/db/stage1/gvhd_organ_acute_orm.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+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 GVHDOrgan, GVHDOrganAcuteStage
+
+
+class GVHDOrganAcuteORM(BaseORM):
+    __tablename__ = "gvhd_organ_acute"
+    __repr_attrs__ = ["gvhd_organ_acute_id", "organ"]
+    __data_category__ = "gvhd_organ_acute"
+
+    gvhd_organ_acute_id: Mapped[int] = mapped_column(primary_key=True)
+    gvhd_diagnosis_acute_id: Mapped[int] = mapped_column(
+        ForeignKey("stage1.gvhd_diagnosis_acute.gvhd_diagnosis_acute_id", ondelete="CASCADE")
+    )
+    organ: Mapped[GVHDOrgan]
+    acute_stage: Mapped[GVHDOrganAcuteStage]
+
+    diagnosis: Mapped[GVHDDiagnosisAcuteORM] = relationship(back_populates="organs", cascade="all, delete")

cidc_api/models/db/stage1/gvhd_organ_chronic_orm.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+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 GVHDOrgan, GVHDOrganChronicScore
+
+
+class GVHDOrganChronicORM(BaseORM):
+    __tablename__ = "gvhd_organ_chronic"
+    __repr_attrs__ = ["gvhd_organ_chronic_id", "organ"]
+    __data_category__ = "gvhd_organ_chronic"
+
+    gvhd_organ_chronic_id: Mapped[int] = mapped_column(primary_key=True)
+    gvhd_diagnosis_chronic_id: Mapped[int] = mapped_column(
+        ForeignKey("stage1.gvhd_diagnosis_chronic.gvhd_diagnosis_chronic_id", ondelete="CASCADE")
+    )
+    organ: Mapped[GVHDOrgan]
+    chronic_score: Mapped[GVHDOrganChronicScore]
+
+    diagnosis: Mapped[GVHDDiagnosisChronicORM] = relationship(back_populates="organs", cascade="all, delete")

cidc_api/models/db/stage1/medical_history_orm.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import List
+
+from pydantic import NonNegativeInt, 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 TobaccoSmokingStatus
+
+
+class MedicalHistoryORM(BaseORM):
+    __tablename__ = "medical_history"
+    __repr_attrs__ = ["medical_history_id"]
+    __data_category__ = "medical_history"
+
+    medical_history_id: Mapped[int] = mapped_column(primary_key=True)
+    participant_id: Mapped[int] = mapped_column(ForeignKey("stage1.participant.participant_id", ondelete="CASCADE"))
+
+    tobacco_smoking_status: Mapped[TobaccoSmokingStatus | None]
+    pack_years_smoked: Mapped[PositiveFloat | None]
+    num_prior_systemic_therapies: Mapped[NonNegativeInt | None]
+
+    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/stage1/other_malignancy_orm.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from pydantic import NonPositiveInt
+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, ICDO3MorphologicalTerm, MalignancyStatus
+
+
+class OtherMalignancyORM(BaseORM):
+    __tablename__ = "other_malignancy"
+    __repr_attrs__ = ["other_malignancy_id", "primary_disease_site"]
+    __data_category__ = "other_malignancy"
+
+    other_malignancy_id: Mapped[int] = mapped_column(primary_key=True)
+    medical_history_id: Mapped[int] = mapped_column(
+        ForeignKey("stage1.medical_history.medical_history_id", ondelete="CASCADE")
+    )
+
+    other_malignancy_primary_disease_site: Mapped[UberonAnatomicalTerm]
+    other_malignancy_morphological_code: Mapped[ICDO3MorphologicalCode | None]
+    other_malignancy_morphological_term: Mapped[ICDO3MorphologicalTerm | None]
+    other_malignancy_description: Mapped[str | None]
+    other_malignancy_days_since_diagnosis: Mapped[NonPositiveInt | None]
+    other_malignancy_status: Mapped[MalignancyStatus | None]
+
+    medical_history: Mapped[MedicalHistoryORM] = relationship(
+        back_populates="other_malignancies", cascade="all, delete"
+    )