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

cidc_api/models/db/stage2/trial_orm.py

@@ -1,60 +1,61 @@
+from __future__ import annotations
 from datetime import datetime
-from typing import List, Optional
+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.base_orm import BaseORM
-from cidc_api.models.types import TrialStatus, AssayType, TrialOrganization, TrialFundingAgency
+from cidc_api.models.db.stage2.base_orm import BaseORM
+from cidc_api.models.types import AssayType, TrialOrganization, TrialFundingAgency, AgeGroup, PrimaryPurposeType
 
 
 class TrialORM(BaseORM):
     __tablename__ = "trial"
     __repr_attrs__ = ["trial_id", "version"]
-    __table_args__ = {"schema": "stage2"}
+    __data_category__ = "study"
 
     trial_id: Mapped[str] = mapped_column(primary_key=True)
     version: Mapped[str] = mapped_column(primary_key=True)
 
-    nct_id: Mapped[Optional[str]]
-    nci_id: Mapped[Optional[str]]
-    trial_name: Mapped[Optional[str]]
-    trial_type: Mapped[Optional[str]]
-    trial_description: Mapped[Optional[str]]
-    trial_organization: Mapped[Optional[TrialOrganization]]
-    grant_or_affiliated_network: Mapped[Optional[TrialFundingAgency]]
-    trial_status: Mapped[TrialStatus]
-    biobank_institution_id: Mapped[Optional[int]]
-    justification: Mapped[Optional[str]]
+    primary_endpoint: Mapped[str | None]
+    age_group: Mapped[List[AgeGroup]] = mapped_column(JSON, nullable=True)
+    study_population: Mapped[str | None]
+    nct_id: Mapped[str | None]
+    nci_id: Mapped[str | None]
+    trial_name: Mapped[str | None]
+    trial_type: Mapped[str | None]
+    trial_description: Mapped[str | None]
+    trial_organization: Mapped[TrialOrganization | None]
+    grant_or_affiliated_network: Mapped[TrialFundingAgency | None]
+    biobank_institution_id: Mapped[int | None]
+    justification: Mapped[str | None]
     dates_of_conduct_start: Mapped[datetime]
-    dates_of_conduct_end: Mapped[Optional[datetime]]
-    schema_file_id: Mapped[Optional[int]]
-    biomarker_plan: Mapped[Optional[str]]
-    data_sharing_plan: Mapped[Optional[str]]
-    expected_assays: Mapped[Optional[List[AssayType]]] = mapped_column(JSON, nullable=True)
-    is_liquid_tumor_trial: Mapped[bool]
-    dbgap_study_accession: Mapped[Optional[str]]
+    dates_of_conduct_end: Mapped[datetime | None]
+    schema_file_id: Mapped[int | None]
+    biomarker_plan: Mapped[str | None]
+    data_sharing_plan: Mapped[str | None]
+    expected_assays: Mapped[List[AssayType]] = mapped_column(JSON, nullable=True)
+    primary_purpose_type: Mapped[PrimaryPurposeType]
+    dbgap_study_accession: Mapped[str | None]
 
-    biobank: Mapped["InstitutionORM"] = relationship(back_populates="trial")
-    schema: Mapped[Optional["FileORM"]] = relationship(back_populates="trial", viewonly=True)
-    administrative_role_assignments: Mapped[List["AdministrativeRoleAssignmentORM"]] = relationship(
+    biobank: Mapped[InstitutionORM] = relationship(back_populates="trial")
+    schema: Mapped[FileORM | None] = relationship(back_populates="trial", viewonly=True)
+    administrative_role_assignments: Mapped[List[AdministrativeRoleAssignmentORM]] = relationship(
         back_populates="trial", cascade="all, delete", passive_deletes=True
     )
-    arms: Mapped[List["ArmORM"]] = relationship(back_populates="trial", cascade="all, delete", passive_deletes=True)
-    cohorts: Mapped[List["CohortORM"]] = relationship(
+    arms: Mapped[List[ArmORM]] = relationship(back_populates="trial", cascade="all, delete", passive_deletes=True)
+    cohorts: Mapped[List[CohortORM]] = relationship(back_populates="trial", cascade="all, delete", passive_deletes=True)
+    participants: Mapped[List[ParticipantORM]] = relationship(
         back_populates="trial", cascade="all, delete", passive_deletes=True
     )
-    participants: Mapped[List["ParticipantORM"]] = relationship(
+    shipments: Mapped[List[ShipmentORM]] = relationship(
         back_populates="trial", cascade="all, delete", passive_deletes=True
     )
-    shipments: Mapped[List["ShipmentORM"]] = relationship(
+    files: Mapped[List[FileORM]] = relationship(back_populates="trial", cascade="all, delete", passive_deletes=True)
+    publications: Mapped[List[PublicationORM]] = relationship(
         back_populates="trial", cascade="all, delete", passive_deletes=True
     )
-    files: Mapped[List["FileORM"]] = relationship(back_populates="trial", cascade="all, delete", passive_deletes=True)
-    publications: Mapped[List["PublicationORM"]] = relationship(
-        back_populates="trial", cascade="all, delete", passive_deletes=True
-    )
-    consent_groups: Mapped[List["ConsentGroupORM"]] = relationship(
+    consent_groups: Mapped[List[ConsentGroupORM]] = relationship(
         back_populates="trial", cascade="all, delete", passive_deletes=True
     )

cidc_api/models/files/facets.py

@@ -376,6 +376,10 @@ assay_facets: Facets = {
         "Channels": FacetConfig(["/maldi_glycan/channels.csv", "Channels csv file for MALDI Glycan run"]),
         "Tiff Zip": FacetConfig(["/maldi_glycan/tiff.zip", "Tiff zip for MALDI Glycan run"]),
     },
+    "TCRseq RNA": {
+        "Alpha Results": FacetConfig(["/tcrseq_rna/alpha.csv"]),
+        "Beta Results": FacetConfig(["/tcrseq_rna/beta.csv"]),
+    },
     "mIHC": {
         "Samples Report": FacetConfig(["/mihc/sample_report.csv"], "Samples report for mIHC run"),
         "Multitiffs": FacetConfig(["/mihc/multitiffs.tar.gz"], "Multi Tiffs file from mIHC run"),

cidc_api/models/models.py

@@ -28,6 +28,7 @@ __all__ = [
     "JobFileCategories",
     "CategoryDataElements",
     "ValidationConfigs",
+    "MASTER_APPENDIX_A",
     "TRIAL_APPENDIX_A",
     "TRIAL_APPENDIX_A_CELL_THAT_ENDS_THE_HEADER",
     "REQUEST_LETTER",
@@ -35,7 +36,8 @@ __all__ = [
     "ADMIN_FILE_CATEGORIES",
     "FINAL_JOB_STATUS",
     "INGESTION_JOB_STATUSES",
-    "INGESTION_JOB_COLORS",
+    "ASSAY_JOB_COLORS",
+    "CLINICAL_JOB_COLORS",
 ]
 
 import hashlib
@@ -3261,6 +3263,7 @@ def upload_manifest_json(
     return manifest_upload.id
 
 
+MASTER_APPENDIX_A = "master_appendix_a"
 TRIAL_APPENDIX_A = "trial_appendix_a"
 REQUEST_LETTER = "request_letter"
 DETAILED_VALIDATION = "detailed_validation"
@@ -3360,6 +3363,16 @@ class PreprocessedFiles(CommonColumns):
         query = cls.add_job_filter(query, job_id)
         return query.all()
 
+    @classmethod
+    @with_default_session
+    def get_latest_current_file(
+        cls, file_category: str, job_id: int = None, session: Session = None
+    ) -> Optional["PreprocessedFiles"]:
+        """Return the latest 'current' file for the given category and job_id. Returns None if no file exists."""
+        query = session.query(cls).filter_by(file_category=file_category, status="current")
+        query = cls.add_job_filter(query, job_id)
+        return query.order_by(cls.version.desc()).first()
+
     @classmethod
     @with_default_session
     def get_file_by_category_and_version(
@@ -3399,6 +3412,7 @@ class PreprocessedFiles(CommonColumns):
                 (cls.file_category == latest_subquery.c.file_category)
                 & (cls._created == latest_subquery.c.latest_created),
             )
+            .order_by(cls.file_category)
             .all()
         )
         return latest_files
@@ -3435,7 +3449,7 @@ INGESTION_JOB_STATUSES = [
 ]
 
 # Business decision to pass hex codes from the backend though that should be done by the front end...
-INGESTION_JOB_COLORS = {
+CLINICAL_JOB_COLORS = {
     "DRAFT": "",
     "INITIAL SUBMISSION": "#ACCAD7",
     "VALIDATION REVIEW": "#DABE90",
@@ -3443,6 +3457,13 @@ INGESTION_JOB_COLORS = {
     "INGESTION": "#8FCEC7",
     "PUBLISHED": "#90D9E6",
 }
+ASSAY_JOB_COLORS = {
+    "INITIAL SUBMISSION": "#43807E",
+    "VALIDATION REVIEW": "#906F3F",
+    "REVISION SUBMISSION": "#95358A",
+    "INGESTION": "#542C88",
+    "PUBLISHED": "#1C81A0",
+}
 # TODO If have "CANCELLED" concept or other final status, add here
 FINAL_JOB_STATUS = ["PUBLISHED"]
 TRIAL_APPENDIX_A_CELL_THAT_ENDS_THE_HEADER = "Data Category"
@@ -3464,11 +3485,45 @@ class IngestionJobs(CommonColumns):
     pending = Column(Boolean, nullable=False, default=False)
     start_date = Column(DateTime, nullable=True)
     error_status = Column(String, nullable=True)
+    job_type = Column(String, nullable=False, default="clinical")
+    assay_type = Column(String, nullable=True)
+    batch_id = Column(String, nullable=True)
+    submission_id = Column(String, nullable=True)
+    intake_path = Column(String, nullable=True)
+    uploader_email = Column(String, nullable=True)
+    is_template_downloaded = Column(Boolean, nullable=True)
 
     @staticmethod
     @with_default_session
-    def create(trial_id: str, status: str, version: int, pending: Boolean = False, session: Session = None):
-        new_job = IngestionJobs(trial_id=trial_id, status=status, version=version, pending=pending)
+    def create(
+        trial_id: str,
+        status: str,
+        version: int,
+        error_status: str = None,
+        pending: Boolean = False,
+        job_type: str = "clinical",
+        assay_type: str = None,
+        batch_id: str = None,
+        submission_id: str = None,
+        intake_path: str = None,
+        start_date: datetime = None,
+        uploader_email: str = None,
+        session: Session = None,
+    ):
+        new_job = IngestionJobs(
+            trial_id=trial_id,
+            status=status,
+            error_status=error_status,
+            version=version,
+            pending=pending,
+            job_type=job_type,
+            assay_type=assay_type,
+            batch_id=batch_id,
+            submission_id=submission_id,
+            intake_path=intake_path,
+            start_date=start_date,
+            uploader_email=uploader_email,
+        )
         new_job.insert(session=session)
         return new_job
 
@@ -3493,29 +3548,43 @@ class IngestionJobs(CommonColumns):
 
     @classmethod
     @with_default_session
-    def get_jobs_by_trial(cls, trial_id: str, session: Session = None) -> list["IngestionJobs"]:
-        return session.query(cls).filter(cls.trial_id == trial_id).order_by(cls.version.desc()).all()
+    def get_jobs_by_trial(
+        cls, trial_id: str, job_type: str = "clinical", session: Session = None
+    ) -> list["IngestionJobs"]:
+        return (
+            session.query(cls)
+            .filter(cls.trial_id == trial_id, cls.job_type == job_type)
+            .order_by(cls.version.desc())
+            .all()
+        )
 
     @classmethod
     @with_default_session
-    def get_open_job_by_trial(cls, trial_id: str, session: Session = None) -> Optional["IngestionJobs"]:
+    def get_open_job_by_trial(
+        cls, trial_id: str, job_type: str = "clinical", session: Session = None
+    ) -> Optional["IngestionJobs"]:
         """Return the open job for a given trial if it exists."""
         return (
             session.query(cls)
             .filter(
                 cls.trial_id == trial_id,
+                cls.job_type == job_type,
                 cls.status.notin_(FINAL_JOB_STATUS),
             )
             .order_by(cls._created.desc())
             .first()
         )
 
+    @classmethod
+    def get_jobs_for_user(cls, user: Users, job_type: str = None) -> list["IngestionJobs"]:
+        return cls.get_assay_jobs_for_user(user) if job_type == "assay" else cls.get_clinical_jobs_for_user(user)
+
     @classmethod
     @with_default_session
-    def get_open_jobs_for_user(cls, user: Users, session: Session = None) -> list["IngestionJobs"]:
+    def get_clinical_jobs_for_user(cls, user: Users, session: Session = None) -> list["IngestionJobs"]:
         if user.role not in [CIDCRole.ADMIN.value, CIDCRole.CLINICAL_TRIAL_USER.value]:
             return []
-        job_query = session.query(cls).filter(cls.status.notin_(["DRAFT"]))
+        job_query = session.query(cls).filter(cls.status.notin_(["DRAFT"]), cls.job_type == "clinical")
         if (
             user.role != CIDCRole.ADMIN.value
             and not session.query(Permissions)
@@ -3538,6 +3607,81 @@ class IngestionJobs(CommonColumns):
             job_query = job_query.filter(cls.trial_id.in_(map(lambda x: x.trial_id, authorized_trials)))
         return job_query.order_by(cls._created.desc()).all()
 
+    @classmethod
+    @with_default_session
+    def get_assay_jobs_for_user(cls, user: Users, session: Session = None) -> list["IngestionJobs"]:
+        # TODO allow more than just Admin role and get authorized trials based on permissions
+        if user.role not in [CIDCRole.ADMIN.value]:
+            return []
+        return session.query(cls).filter(cls.job_type == "assay").order_by(cls._created.desc()).all()
+
+    @classmethod
+    @with_default_session
+    def get_unique_assay_job(
+        cls,
+        trial_id: str,
+        assay_type: str,
+        batch_id: str,
+        session: Session = None,
+    ) -> Optional["IngestionJobs"]:
+        """Look for unique assay job with matching trial_id/assay_type/batch_id combination."""
+        return (
+            session.query(cls)
+            .filter(
+                cls.job_type == "assay",
+                cls.trial_id == trial_id,
+                cls.assay_type == assay_type,
+                cls.batch_id == batch_id,
+            )
+            .first()
+        )
+
+    @classmethod
+    @with_default_session
+    def next_assay_submission_id(cls, trial_id: str, assay_type: str, session: Session = None) -> str:
+        """
+        Generate the next CIDC Submission ID for an assay job.
+
+        Format:
+          <trial_id>-<assay_type>-<yyyymmdd>        (first submission of the day)
+          <trial_id>-<assay_type>-<yyyymmdd>-<#>    (subsequent submissions on same day)
+
+        Uses only the most recent matching submission_id to determine the next suffix.
+        """
+        today_str = datetime.now().strftime("%Y%m%d")
+        base_submission_id = f"{trial_id}-{assay_type}-{today_str}"
+
+        # Get the most recent submission_id matching this prefix
+        latest = (
+            session.query(cls.submission_id)
+            .filter(
+                cls.trial_id == trial_id,
+                cls.assay_type == assay_type,
+                cls.submission_id.like(f"{base_submission_id}%"),
+            )
+            .order_by(cls._created.desc())
+            .first()
+        )
+
+        # No existing submission for this prefix -> start at 1
+        if not latest or not latest[0]:
+            return base_submission_id
+
+        last_id = latest[0]
+        # Case 1: the latest is exactly the prefix (i.e., first submission today)
+        if last_id == base_submission_id:
+            return f"{base_submission_id}-2"
+
+        # Case 2: latest already has a suffix
+        try:
+            _, last_suffix = last_id.rsplit("-", 1)
+            n = int(last_suffix)
+            return f"{base_submission_id}-{n + 1}"
+        except Exception as e:
+            # If malformed, restart numbering for safety
+            logger.error("Unexpected error parsing Submission ID in next_assay_submission_id: %s", e)
+            return f"{base_submission_id}-2"
+
 
 class JobFileCategories(CommonColumns):
     __tablename__ = "job_file_categories"
@@ -3612,6 +3756,7 @@ class CategoryDataElements(CommonColumns):
     name = Column(String, nullable=False)
     is_custom = Column(Boolean, nullable=False, default=False, server_default="false")
     element_type = Column(String, nullable=False)
+    data_type = Column(String, nullable=True)
     cardinality = Column(String, nullable=True)
 
     @classmethod

cidc_api/models/pydantic/{stage2/base.py → base.py}

@@ -6,7 +6,11 @@ import copy
 
 class Base(BaseModel):
 
-    model_config = ConfigDict(validate_assignment=True, from_attributes=True)
+    model_config = ConfigDict(
+        validate_assignment=True,
+        from_attributes=True,
+        extra="allow",
+    )
 
     # Validates the new state and updates the object if valid
     def update(self, **kwargs):
@@ -28,3 +32,17 @@ class Base(BaseModel):
         except:
             self.__dict__.update(original_dict)
             raise
+
+    @classmethod
+    def split_list(cls, val):
+        """Listify fields that are multi-valued in input data, e.g. 'lung|kidney'"""
+        if type(val) == list:
+            return val
+        elif type(val) == str:
+            if not val:
+                return []
+            return val.split("|")
+        elif val == None:
+            return []
+        else:
+            raise ValueError("Field value must be string or list")

cidc_api/models/pydantic/stage1/__init__.py

@@ -0,0 +1,56 @@
+from .additional_treatment import AdditionalTreatment
+from .adverse_event import AdverseEvent
+from .baseline_clinical_assessment import BaselineClinicalAssessment
+from .comorbidity import Comorbidity
+from .consent_group import ConsentGroup
+from .demographic import Demographic
+from .disease import Disease
+from .exposure import Exposure
+from .gvhd_diagnosis_acute import GVHDDiagnosisAcute
+from .gvhd_diagnosis_chronic import GVHDDiagnosisChronic
+from .gvhd_organ_acute import GVHDOrganAcute
+from .gvhd_organ_chronic import GVHDOrganChronic
+from .medical_history import MedicalHistory
+from .other_malignancy import OtherMalignancy
+from .participant import Participant
+from .prior_treatment import PriorTreatment
+from .radiotherapy_dose import RadiotherapyDose
+from .response import Response
+from .response_by_system import ResponseBySystem
+from .specimen import Specimen
+from .stem_cell_transplant import StemCellTransplant
+from .surgery import Surgery
+from .therapy_agent_dose import TherapyAgentDose
+from .treatment import Treatment
+from .trial import Trial
+
+
+__all__ = [
+    "AdditionalTreatment",
+    "AdverseEvent",
+    "BaselineClinicalAssessment",
+    "Comorbidity",
+    "ConsentGroup",
+    "Demographic",
+    "Disease",
+    "Exposure",
+    "GVHDDiagnosisAcute",
+    "GVHDOrganAcute",
+    "GVHDDiagnosisChronic",
+    "GVHDOrganChronic",
+    "MedicalHistory",
+    "OtherMalignancy",
+    "Participant",
+    "PriorTreatment",
+    "RadiotherapyDose",
+    "Response",
+    "ResponseBySystem",
+    "Specimen",
+    "StemCellTransplant",
+    "Surgery",
+    "TherapyAgentDose",
+    "Treatment",
+    "Trial",
+]
+
+all_models = [globals()[cls_name] for cls_name in __all__]

cidc_api/models/pydantic/stage1/additional_treatment.py

@@ -0,0 +1,23 @@
+from pydantic import NonNegativeInt
+from cidc_api.models.pydantic.base import Base
+
+
+class AdditionalTreatment(Base):
+    __data_category__ = "additional_treatment"
+    __cardinality__ = "many"
+
+    # The unique internal identifier for the AdditionalTreatment record
+    additional_treatment_id: int | None = None
+
+    # The unique internal identifier for the associated Participant record
+    participant_id: str | None = None
+
+    # Number of days from the enrollment date to the first recorded administration or occurrence of the treatment modality.
+    additional_treatment_days_to_start: NonNegativeInt | None = None
+
+    # Number of days from the enrollment date to the last recorded administration or occurrence of the treatment modality.
+    additional_treatment_days_to_end: NonNegativeInt | None = None
+
+    # Description of the prior treatment such as its full generic name if it is a type of therapy agent, radiotherapy procedure
+    # name and location, or surgical procedure name and location.
+    additional_treatment_description: str

cidc_api/models/pydantic/stage1/adverse_event.py

@@ -0,0 +1,100 @@
+from typing import Self
+
+from pydantic import NonNegativeInt, model_validator
+
+from cidc_api.models.pydantic.base import Base
+from cidc_api.reference.ctcae import is_ctcae_other_term
+from cidc_api.models.types import (
+    CTCAEEventTerm,
+    CTCAEEventCode,
+    SeverityGradeSystem,
+    SeverityGradeSystemVersion,
+    SeverityGrade,
+    SystemOrganClass,
+    AttributionCause,
+    AttributionLikelihood,
+    YNU,
+)
+
+
+class AdverseEvent(Base):
+    __data_category__ = "adverse_event"
+    __cardinality__ = "many"
+
+    # The unique internal identifier of the adverse event
+    adverse_event_id: int | None = None
+
+    # The unique internal identifier of the associated participant
+    participant_id: str | None = None
+
+    # The unique internal identifier of the attributed treatment, if any
+    treatment_id: int | None = None
+
+    # Text that represents the Common Terminology Criteria for Adverse Events low level term name for an adverse event.
+    event_term: CTCAEEventTerm | None = None
+
+    # A MedDRA code mapped to a CTCAE low level name for an adverse event.
+    event_code: CTCAEEventCode | None = None
+
+    # System used to define and report adverse event severity grade.
+    severity_grade_system: SeverityGradeSystem
+
+    # The version of the adverse event grading system.
+    severity_grade_system_version: SeverityGradeSystemVersion
+
+    # Numerical grade indicating the severity of an adverse event.
+    severity_grade: SeverityGrade
+
+    # A brief description that sufficiently details the event.
+    event_other_specify: str | None = None
+
+    # The highest level of the MedDRA hierarchy, distinguished by anatomical or physiological system, etiology (disease origin) or purpose.
+    system_organ_class: SystemOrganClass | None = None
+
+    # Indicator to identify whether a participant exited the study prematurely due to the adverse event being described.
+    discontinuation_due_to_event: bool
+
+    # Days from enrollment date to date of onset of the adverse event.
+    days_to_onset_of_event: NonNegativeInt
+
+    # Days from enrollment date to date of resolution of the adverse event.
+    days_to_resolution_of_event: NonNegativeInt | None = None
+
+    # Indicates whether the adverse event was a serious adverse event (SAE).
+    serious_adverse_event: YNU
+
+    # Indicates whether the adverse event was a dose-limiting toxicity (DLT).
+    dose_limiting_toxicity: YNU
+
+    # Indicates if the adverse was attributable to the protocol as a whole or to an individual treatment.
+    attribution_cause: AttributionCause
+
+    # The code that indicates whether the adverse event is related to the treatment/intervention.
+    attribution_likelihood: AttributionLikelihood
+
+    # The individual therapy (therapy agent, radiotherapy, surgery, stem cell transplant) in the treatment that is attributed to the adverse event.
+    individual_therapy: str | None = None
+
+    @model_validator(mode="after")
+    def validate_term_and_code_cr(self) -> Self:
+        if not self.event_term and not self.event_code:
+            raise ValueError("Please provide event_term or event_code or both")
+        return self
+
+    @model_validator(mode="after")
+    def validate_event_other_specify_cr(self) -> Self:
+        if (
+            self.severity_grade_system == "CTCAE"
+            and is_ctcae_other_term(self.event_term)
+            and not self.event_other_specify
+        ):
+            raise ValueError(
+                'If severity_grade_system is "CTCAE" and the event_code or event_term are of type "Other, specify", please provide event_other_specify'
+            )
+        return self
+
+    @model_validator(mode="after")
+    def validate_system_organ_class_cr(self) -> Self:
+        if self.event_other_specify and not self.system_organ_class:
+            raise ValueError("If event_other_specify is provided, please provide system_organ_class.")
+        return self

cidc_api/models/pydantic/stage1/baseline_clinical_assessment.py

@@ -0,0 +1,23 @@
+from cidc_api.models.pydantic.base import Base
+from cidc_api.models.types import ECOGScore, KarnofskyScore
+
+
+class BaselineClinicalAssessment(Base):
+    __data_category__ = "baseline_clinical_assessment"
+    __cardinality__ = "one"
+
+    # A unique internal identifier for the baseline clinical assessment
+    baseline_clinical_assessment_id: int | None = None
+
+    # The unique identifier for the associated participant
+    participant_id: str | None = None
+
+    # The numerical score that represents the functional capabilities of a participant at the
+    # enrollment date using the Eastern Cooperative Oncology Group Performance Status assessment.
+    # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=88%20and%20ver_nr=5.1
+    ecog_score: ECOGScore | None = None
+
+    # Score from the Karnofsky Performance status scale, representing the functional capabilities of a participant
+    # at the enrollment date.
+    # CDE: 	https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=2003853%20and%20ver_nr=4.2
+    karnofsky_score: KarnofskyScore | None = None

cidc_api/models/pydantic/stage1/comorbidity.py

@@ -0,0 +1,36 @@
+from typing import Self
+
+from pydantic import model_validator
+
+from cidc_api.models.pydantic.base import Base
+from cidc_api.models.types import ICD10CMCode, ICD10CMTerm
+
+
+class Comorbidity(Base):
+    __data_category__ = "comorbidity"
+    __cardinality__ = "many"
+
+    # The unique internal identifier for the comorbidity record
+    comorbidity_id: int | None = None
+
+    # The unique internal identifier for the associated MedicalHistory record
+    medical_history_id: int | None = None
+
+    # The diagnosis, in humans, as captured in the tenth version of the
+    # International Classification of Disease (ICD-10-CM, the disease code subset of ICD-10).
+    comorbidity_code: ICD10CMCode | None = None
+
+    # The words from the tenth version of the International Classification of Disease (ICD-10-CM,
+    # the disease subset of ICD-10) used to identify the diagnosis in humans.
+    comorbidity_term: ICD10CMTerm | None = None
+
+    # A descriptive string that names or briefly describes the comorbidity.
+    comorbidity_other: str | None = None
+
+    @model_validator(mode="after")
+    def validate_code_or_term_or_other_cr(self) -> Self:
+        if not self.comorbidity_code and not self.comorbidity_term and not self.comorbidity_other:
+            raise ValueError(
+                'Please provide at least one of "comorbidity_code", "comorbidity_term" or "comorbidity_other".'
+            )
+        return self

cidc_api/models/pydantic/stage1/consent_group.py

@@ -0,0 +1,30 @@
+from pydantic import NonNegativeInt
+
+from cidc_api.models.pydantic.base import Base
+
+
+class ConsentGroup(Base):
+    __data_category__ = "consent_group"
+    __cardinality__ = "one"
+
+    # The unique internal identifier for the consent group record
+    consent_group_id: int | None = None
+
+    # The unique internal identifier for the associated Trial record
+    trial_id: str | None = None
+
+    # The version number of the trial dataset
+    version: str | None = None
+
+    # An abbreviated name for the consent group
+    consent_group_short_name: str
+
+    # The words or acronym which describe a set of study participants
+    # who have signed the same consent agreement and that will be included in the dbGaP repository.
+    # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=14534329%20and%20ver_nr=1.00
+    consent_group_name: str
+
+    # A numeral or string of numerals used to identify the set of study participants who have signed the same consent
+    # agreement and that will be included in the dbGaP repository.
+    # CDE: https://cadsr.cancer.gov/onedata/dmdirect/NIH/NCI/CO/CDEDD?filter=CDEDD.ITEM_ID=14534330%20and%20ver_nr=1.00
+    consent_group_number: NonNegativeInt