omop-constructs 0.3.5__tar.gz → 0.3.7__tar.gz

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: omop-constructs
-Version: 0.3.5
+Version: 0.3.7
 Summary: For building complex constructs on top of the omop-alchemy library.
 Author: Georgie Kennedy
 Author-email: Georgie Kennedy <georgina.kennedy@unsw.edu.au>

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omop-constructs"
-version = "0.3.5"
+version = "0.3.7"
 description = "For building complex constructs on top of the omop-alchemy library."
 readme = "README.md"
 authors = [

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/src/omop_constructs/alchemy/episodes/__init__.py

@@ -1,6 +1,11 @@
 from .condition_episode_mv import OverarchingDiseaseEpisodeMV, TreatmentRegimenCycleMV, ConditionEpisodeMV, DxTreatStartMV
 from .condition_episode_objects import ConditionEpisodeObject
 from .surgical_procedure_mv import SurgicalProcedureMV
+from .systemic_treatment_mv import SACTRegimenMV
+from .cycle_mv import CycleMV
+from .course_mv import RTCourseMV
+from .fraction_mv import FractionMV
+from .treatment_summary_mv import ConditionTreatmentEpisode
 
 __all__ = [
     "OverarchingDiseaseEpisodeMV",
@@ -9,4 +14,9 @@ __all__ = [
     "ConditionEpisodeObject",
     "SurgicalProcedureMV",
     "DxTreatStartMV",
+    "SACTRegimenMV",
+    "CycleMV",
+    "RTCourseMV",
+    "FractionMV",
+    "ConditionTreatmentEpisode",
 ]

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/course_joins.py

@@ -0,0 +1,56 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from omop_alchemy.cdm.model import Episode, Episode_Event, Concept
+from omop_semantics.runtime.default_valuesets import runtime
+from ..modifiers import ModifiedProcedure
+from .fraction_mv import FractionMV
+
+
+course_concept = so.aliased(Concept, name='course_concept')
+
+frac_summary_join = (
+    sa.select(
+        FractionMV.person_id,
+        FractionMV.fraction_id,
+        FractionMV.fraction_number,
+        FractionMV.course_id,
+        FractionMV.fraction_name,
+        sa.func.min(FractionMV.procedure_datetime).label('first_exposure_date'),
+        sa.func.max(FractionMV.procedure_datetime).label('last_exposure_date'),
+        sa.func.count(FractionMV.procedure_occurrence_id).label('fraction_count'),
+    )
+    .group_by(FractionMV.person_id, FractionMV.fraction_id, FractionMV.fraction_number, FractionMV.course_id, FractionMV.fraction_name)
+    .subquery()
+)
+
+course_join = (
+    sa.select(
+        *frac_summary_join.c,
+        sa.func.row_number().over().label('mv_id'),
+        Episode.episode_number.label('course_number'),
+        Episode.episode_parent_id.label('condition_episode_id'),
+        ModifiedProcedure.procedure_occurrence_id.label('course_prescription_id'),
+        ModifiedProcedure.procedure_concept_id.label('course_concept_id'),
+        ModifiedProcedure.procedure_concept.label('course_concept'),
+        ModifiedProcedure.intent_concept,
+        ModifiedProcedure.intent_concept_id,
+        ModifiedProcedure.intent_datetime
+    )
+    .join(
+        Episode, 
+        sa.and_(
+            Episode.episode_id == frac_summary_join.c.course_id, 
+            Episode.episode_concept_id==runtime.types.treatment_episode_types.treatment_regimen
+        ),
+        isouter=True
+    )
+    .join(
+        Episode_Event, 
+        sa.and_(
+            Episode_Event.episode_id == Episode.episode_id, 
+            Episode_Event.episode_event_field_concept_id == runtime.modifiers.modifier_fields.procedure_occurrence_id
+        ),
+        isouter=True
+    )
+    .join(ModifiedProcedure, ModifiedProcedure.procedure_occurrence_id==Episode_Event.event_id, isouter=True)
+)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/course_mv.py

@@ -0,0 +1,40 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from orm_loader.helpers import Base
+from datetime import date
+from typing import Optional
+from .course_joins import course_join
+from .fraction_mv import FractionMV
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+
+@register_construct
+class RTCourseMV(
+    MaterializedViewMixin,
+    Base,
+):
+    __mv_name__ = "rt_course_mv"
+    __mv_select__ = course_join.select()
+    __mv_index__ = "course_id"
+    __deps__ = (FractionMV.__mv_name__,)
+    __tablename__ = __mv_name__
+    __table_args__ = {"extend_existing": True}
+
+    mv_id: so.Mapped[int] = so.mapped_column(sa.Integer, primary_key=True)
+    person_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_count: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_name: so.Mapped[str] = so.mapped_column(sa.String)
+    first_exposure_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    last_exposure_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    course_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    condition_episode_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_prescription_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_concept: so.Mapped[str] = so.mapped_column(sa.String)
+    intent_datetime: so.Mapped[Optional[date]] = so.mapped_column(sa.DateTime, nullable=True)
+    intent_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+    intent_concept: so.Mapped[Optional[str]] = so.mapped_column(sa.String, nullable=True)
+    

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/cycle_join.py

@@ -0,0 +1,38 @@
+import sqlalchemy as sa
+from omop_semantics.runtime.default_valuesets import runtime
+import sqlalchemy.orm as so
+from omop_alchemy.cdm.model import Concept, Drug_Exposure, Episode, Episode_Event
+
+drug_concept = so.aliased(Concept, name='drug_concept')
+route_concept = so.aliased(Concept, name='route_concept')
+cycle_concept = so.aliased(Concept, name='cycle_concept')
+
+cycle_join = (
+    sa.select(
+        sa.func.row_number().over().label('mv_id'),
+        Drug_Exposure.person_id,
+        Drug_Exposure.drug_exposure_start_date,
+        Drug_Exposure.drug_exposure_end_date,
+        Drug_Exposure.drug_exposure_id,
+        Drug_Exposure.quantity,
+        Drug_Exposure.drug_concept_id,
+        Drug_Exposure.dose_unit_source_value,
+        drug_concept.concept_name.label('drug_name'),
+        route_concept.concept_name.label('route'),
+        Episode.episode_id.label('cycle_id'),
+        Episode.episode_number.label('cycle_number'),
+        Episode.episode_parent_id.label('regimen_id'),
+        cycle_concept.concept_name.label('cycle_concept')
+    )
+    .join(drug_concept, drug_concept.concept_id==Drug_Exposure.drug_concept_id)
+    .join(route_concept, route_concept.concept_id==Drug_Exposure.route_concept_id)
+    .join(
+        Episode_Event, 
+        sa.and_(
+            Episode_Event.event_id==Drug_Exposure.drug_exposure_id,
+            Episode_Event.episode_event_field_concept_id==runtime.modifiers.modifier_fields.drug_exposure_id
+        )
+    )
+    .join(Episode, Episode.episode_id==Episode_Event.episode_id)
+    .join(cycle_concept, cycle_concept.concept_id==Episode.episode_concept_id)
+)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/cycle_mv.py

@@ -0,0 +1,34 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from orm_loader.helpers import Base
+from datetime import date
+from .cycle_join import cycle_join
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+
+@register_construct
+class CycleMV(
+    MaterializedViewMixin,
+    Base,
+):
+    __mv_name__ = "cycle_mv"
+    __mv_select__ = cycle_join.select()
+    __mv_index__ = "cycle_id"
+    __deps__ = ()
+    __tablename__ = __mv_name__
+    __table_args__ = {"extend_existing": True}
+
+    mv_id: so.Mapped[int] = so.mapped_column(sa.Integer, primary_key=True)
+    person_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    drug_exposure_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    drug_exposure_start_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    drug_exposure_end_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    quantity: so.Mapped[float] = so.mapped_column(sa.Numeric)
+    drug_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    dose_unit_source_value: so.Mapped[str] = so.mapped_column(sa.String)
+    drug_name: so.Mapped[str] = so.mapped_column(sa.String)
+    route: so.Mapped[str] = so.mapped_column(sa.String)
+    cycle_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    cycle_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    cycle_concept: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_id: so.Mapped[int] = so.mapped_column(sa.Integer)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/fraction_joins.py

@@ -0,0 +1,37 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from omop_alchemy.cdm.model import Episode, Episode_Event, Concept
+from omop_semantics.runtime.default_valuesets import runtime
+from ..modifiers import ModifiedProcedure
+from ...semantics import registry
+
+rt_proc_concept = so.aliased(Concept, name='rt_proc_concept')
+fraction_concept = so.aliased(Concept, name='fraction_concept')
+
+fraction_join = (
+    sa.select(
+        sa.func.row_number().over().label('mv_id'),
+        ModifiedProcedure.person_id,
+        ModifiedProcedure.procedure_datetime,
+        ModifiedProcedure.procedure_occurrence_id,
+        ModifiedProcedure.procedure_concept_id,
+        ModifiedProcedure.procedure_concept,
+        ModifiedProcedure.intent_concept,
+        ModifiedProcedure.intent_concept_id,
+        ModifiedProcedure.intent_datetime,
+        Episode.episode_id.label('fraction_id'),
+        Episode.episode_number.label('fraction_number'),
+        Episode.episode_parent_id.label('course_id'),
+        fraction_concept.concept_name.label('fraction_name')
+    )
+    .join(
+        Episode_Event, 
+        sa.and_(
+            Episode_Event.event_id==ModifiedProcedure.procedure_occurrence_id,
+            Episode_Event.episode_event_field_concept_id==runtime.modifiers.modifier_fields.procedure_occurrence_id
+        )
+    )
+    .join(Episode, Episode.episode_id==Episode_Event.episode_id)
+    .join(fraction_concept, fraction_concept.concept_id==Episode.episode_object_concept_id)
+    .filter(ModifiedProcedure.procedure_concept_id.in_(list(registry['metastatic_disease'].all_concepts)))
+)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/fraction_mv.py

@@ -0,0 +1,33 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from orm_loader.helpers import Base
+from datetime import date
+from .fraction_joins import fraction_join
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+
+@register_construct
+class FractionMV(
+    MaterializedViewMixin,
+    Base,
+):
+    __mv_name__ = "fraction_mv"
+    __mv_select__ = fraction_join.select()
+    __mv_index__ = "fraction_id"
+    __deps__ = ()
+    __tablename__ = __mv_name__
+    __table_args__ = {"extend_existing": True}
+
+    mv_id: so.Mapped[int] = so.mapped_column(sa.Integer, primary_key=True)
+    person_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    procedure_occurrence_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    procedure_datetime: so.Mapped[date] = so.mapped_column(sa.DateTime)
+    procedure_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    procedure_concept: so.Mapped[str] = so.mapped_column(sa.String)
+    intent_datetime: so.Mapped[date] = so.mapped_column(sa.DateTime)
+    intent_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    intent_concept: so.Mapped[str] = so.mapped_column(sa.String)
+    fraction_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_name: so.Mapped[str] = so.mapped_column(sa.String)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/systemic_treatment_joins.py

@@ -0,0 +1,53 @@
+import sqlalchemy as sa
+from omop_alchemy.cdm.model import Episode, Episode_Event
+from omop_semantics.runtime.default_valuesets import runtime
+from ..modifiers import ModifiedProcedure
+from .cycle_mv import CycleMV
+
+
+cycle_summary_join = (
+    sa.select(
+        CycleMV.person_id,
+        CycleMV.cycle_id,
+        CycleMV.cycle_number,
+        CycleMV.regimen_id,
+        CycleMV.cycle_concept,
+        sa.func.min(CycleMV.drug_exposure_start_date).label('first_exposure_date'),
+        sa.func.max(CycleMV.drug_exposure_end_date).label('last_exposure_date'),
+        sa.func.count(CycleMV.drug_exposure_id).label('exposure_count'),
+    )
+    .group_by(CycleMV.person_id, CycleMV.cycle_id, CycleMV.cycle_number, CycleMV.regimen_id, CycleMV.cycle_concept)
+    .subquery()
+)
+
+regimen_join = (
+    sa.select(
+        *cycle_summary_join.c,
+        sa.func.row_number().over().label('mv_id'),
+        Episode.episode_number.label('regimen_number'),
+        Episode.episode_parent_id.label('condition_episode_id'),
+        ModifiedProcedure.procedure_occurrence_id.label('regimen_prescription_id'),
+        ModifiedProcedure.procedure_concept_id.label('regimen_concept_id'),
+        ModifiedProcedure.procedure_concept.label('regimen_concept'),
+        ModifiedProcedure.intent_concept,
+        ModifiedProcedure.intent_concept_id,
+        ModifiedProcedure.intent_datetime,
+    )
+    .join(
+        Episode, 
+        sa.and_(
+            Episode.episode_id == cycle_summary_join.c.regimen_id, 
+            Episode.episode_concept_id==runtime.types.treatment_episode_types.treatment_regimen
+        ),
+        isouter=True
+    )
+    .join(
+        Episode_Event, 
+        sa.and_(
+            Episode_Event.episode_id==Episode.episode_id,
+            Episode_Event.episode_event_field_concept_id==runtime.modifiers.modifier_fields.procedure_occurrence_id
+        ),
+        isouter=True
+    )
+    .join(ModifiedProcedure, ModifiedProcedure.procedure_occurrence_id==Episode_Event.event_id, isouter=True)
+)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/systemic_treatment_mv.py

@@ -0,0 +1,40 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from orm_loader.helpers import Base
+from datetime import date
+from typing import Optional
+from .systemic_treatment_joins import regimen_join
+from .cycle_mv import CycleMV
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+
+@register_construct
+class SACTRegimenMV(
+    MaterializedViewMixin,
+    Base,
+):
+    __mv_name__ = "sact_treatment_mv"
+    __mv_select__ = regimen_join.select()
+    __mv_index__ = "regimen_id"
+    __deps__ = (CycleMV.__mv_name__,)
+    __tablename__ = __mv_name__
+    __table_args__ = {"extend_existing": True}
+
+    mv_id: so.Mapped[int] = so.mapped_column(sa.Integer, primary_key=True)
+    person_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    cycle_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    cycle_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    cycle_concept: so.Mapped[int] = so.mapped_column(sa.Integer)
+    exposure_count: so.Mapped[int] = so.mapped_column(sa.Integer)
+    first_exposure_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    last_exposure_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    regimen_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    condition_episode_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_prescription_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_concept: so.Mapped[str] = so.mapped_column(sa.String)
+    intent_datetime: so.Mapped[Optional[date]] = so.mapped_column(sa.DateTime, nullable=True)
+    intent_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+    intent_concept: so.Mapped[Optional[str]] = so.mapped_column(sa.String, nullable=True)
+    

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/treatment_summary_joins.py

@@ -0,0 +1,68 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from .systemic_treatment_mv import SACTRegimenMV
+from .course_mv import RTCourseMV
+from omop_alchemy.cdm.model import Episode_Event, Condition_Occurrence, Concept
+from omop_semantics.runtime.default_valuesets import runtime
+
+condition_concept = so.aliased(Concept, name='condition_concept')
+
+regimen_summary_join = (
+    sa.select(
+        SACTRegimenMV.person_id,
+        SACTRegimenMV.regimen_concept,
+        SACTRegimenMV.regimen_id,
+        SACTRegimenMV.regimen_number,
+        SACTRegimenMV.condition_episode_id,
+        SACTRegimenMV.intent_concept_id.label('sact_intent_concept_id'),
+        SACTRegimenMV.intent_concept.label('sact_intent_concept'),
+        sa.func.min(SACTRegimenMV.first_exposure_date).label('regimen_start_date'),
+        sa.func.max(SACTRegimenMV.last_exposure_date).label('regimen_end_date'),
+        sa.func.sum(SACTRegimenMV.exposure_count).label('exposure_count'),
+        sa.func.count(SACTRegimenMV.regimen_id).label('regimen_count'),
+    )
+    .group_by(SACTRegimenMV.person_id, SACTRegimenMV.regimen_concept, SACTRegimenMV.regimen_id, SACTRegimenMV.regimen_number, SACTRegimenMV.condition_episode_id, SACTRegimenMV.intent_concept_id, SACTRegimenMV.intent_concept)
+    .subquery()
+)
+
+course_summary_join = (
+    sa.select(
+        RTCourseMV.person_id,
+        RTCourseMV.course_concept,
+        RTCourseMV.course_id,
+        RTCourseMV.course_number,
+        RTCourseMV.condition_episode_id,
+        RTCourseMV.intent_concept_id.label('rt_intent_concept_id'),
+        RTCourseMV.intent_concept.label('rt_intent_concept'),
+        sa.func.min(RTCourseMV.first_exposure_date).label('course_start_date'),
+        sa.func.max(RTCourseMV.last_exposure_date).label('course_end_date'),
+        sa.func.sum(RTCourseMV.fraction_count).label('fraction_count'),
+        sa.func.count(RTCourseMV.course_id).label('course_count'),
+    )
+    .group_by(RTCourseMV.person_id, RTCourseMV.course_concept, RTCourseMV.course_id, RTCourseMV.course_number, RTCourseMV.condition_episode_id, RTCourseMV.intent_concept_id, RTCourseMV.intent_concept)
+    .subquery()
+)
+
+condition_treatment_join = (
+    sa.select(
+        sa.func.row_number().over().label('mv_id'),
+        Condition_Occurrence.person_id,
+        Condition_Occurrence.condition_occurrence_id,
+        Condition_Occurrence.condition_start_date,
+        Condition_Occurrence.condition_end_date,
+        Episode_Event.episode_id.label('condition_episode_id'),
+        *regimen_summary_join.c,
+        *course_summary_join.c,
+    )
+    .join(
+        Episode_Event, 
+        sa.and_(
+            Episode_Event.event_id==Condition_Occurrence.condition_occurrence_id,
+            Episode_Event.episode_event_field_concept_id==runtime.modifiers.modifier_fields.condition_occurrence_id
+        ),
+        isouter=True
+    )
+    .join(regimen_summary_join, regimen_summary_join.c.condition_episode_id==Episode_Event.episode_id, isouter=True)
+    .join(course_summary_join, course_summary_join.c.condition_episode_id==Episode_Event.episode_id, isouter=True)
+    .subquery()
+)

omop_constructs-0.3.7/src/omop_constructs/alchemy/episodes/treatment_summary_mv.py

@@ -0,0 +1,47 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from orm_loader.helpers import Base
+from datetime import date
+from typing import Optional
+from .treatment_summary_joins import condition_treatment_join
+from .course_mv import RTCourseMV
+from .systemic_treatment_mv import SACTRegimenMV
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+
+@register_construct
+class ConditionTreatmentEpisode(
+    MaterializedViewMixin,
+    Base,
+):
+    __mv_name__ = "condition_treatment_episode_mv"
+    __mv_select__ = condition_treatment_join.select()
+    __mv_index__ = "condition_episode_id"
+    __deps__ = (RTCourseMV.__mv_name__, SACTRegimenMV.__mv_name__)
+    __tablename__ = __mv_name__
+    __table_args__ = {"extend_existing": True}
+
+    mv_id: so.Mapped[int] = so.mapped_column(sa.Integer, primary_key=True)
+    person_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    condition_episode_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    condition_occurrence_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    condition_start_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    condition_end_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    course_concept: so.Mapped[str] = so.mapped_column(sa.String)
+    course_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_start_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    course_end_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    rt_intent_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    rt_intent_concept: so.Mapped[int] = so.mapped_column(sa.Integer)
+    fraction_count: so.Mapped[int] = so.mapped_column(sa.Integer)
+    course_count: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_concept: so.Mapped[str] = so.mapped_column(sa.String)
+    regimen_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_number: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_start_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    regimen_end_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    sact_intent_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    sact_intent_concept: so.Mapped[int] = so.mapped_column(sa.Integer)
+    exposure_count: so.Mapped[int] = so.mapped_column(sa.Integer)
+    regimen_count: so.Mapped[int] = so.mapped_column(sa.Integer)

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/src/omop_constructs/alchemy/events/__init__.py

@@ -15,6 +15,9 @@ from .dx_linked_event_mv import (
 from .dx_linked_procedure_mv import (
     DxProcedureMV,
 )
+from .dx_linked_obs_mv import (
+    DxObservationMV,
+)
 
 __all__ = [
     "WeightDxMV",
@@ -29,4 +32,5 @@ __all__ = [
     "SmokingPYHDxMV",
     "DxMeasurementMV",
     "DxProcedureMV",
+    "DxObservationMV",
 ]

omop_constructs-0.3.7/src/omop_constructs/alchemy/events/dx_linked_obs_mv.py

@@ -0,0 +1,51 @@
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from datetime import date
+from typing import Optional
+from orm_loader.helpers import Base
+
+from omop_constructs.alchemy.episodes.condition_episode_mv import ConditionEpisodeMV
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+from ..episodes import ConditionEpisodeMV
+from .observation_queries import (
+    dx_all_observations
+)
+
+class ConditionEpisodeObservationCols:
+    __table_args__ = {"extend_existing": True}
+
+    mv_id: so.Mapped[int] = so.mapped_column(primary_key=True)
+
+    person_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    event_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    event_date: so.Mapped[date] = so.mapped_column(sa.Date)
+    event_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    event_label: so.Mapped[Optional[str]] = so.mapped_column(sa.String, nullable=True)
+
+    value_as_number: so.Mapped[Optional[float]] = so.mapped_column(sa.Float, nullable=True)
+    qualifier_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+    value_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+
+    episode_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+    episode_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+    episode_label: so.Mapped[Optional[str]] = so.mapped_column(sa.String, nullable=True)
+
+    episode_start_date: so.Mapped[Optional[date]] = so.mapped_column(sa.Date, nullable=True)
+    episode_end_date: so.Mapped[Optional[date]] = so.mapped_column(sa.Date, nullable=True)
+
+    episode_delta_days: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+
+
+@register_construct
+class DxObservationMV(ConditionEpisodeObservationCols, MaterializedViewMixin, Base):
+    __mv_name__ = "dx_observation_mv"
+    __mv_select__ = dx_all_observations.select()
+    __mv_index__ = "person_id"
+    __deps__ = (ConditionEpisodeMV.__mv_name__,)
+    __tablename__ = __mv_name__
+
+    observation_concept_id: so.Mapped[int] = so.mapped_column(sa.Integer)
+    observation_date: so.Mapped[Optional[date]] = so.mapped_column(sa.DateTime)
+    value_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)
+    qualifier_concept_id: so.Mapped[Optional[int]] = so.mapped_column(sa.Integer, nullable=True)

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/src/omop_constructs/alchemy/events/event_factories.py

@@ -5,13 +5,14 @@ from typing import Iterable, Any, Sequence, Union
 from omop_constructs.alchemy.episodes import ConditionEpisodeMV
 from omop_alchemy.cdm.model.structural import Episode_Event
 from omop_semantics.runtime.default_valuesets import runtime # type: ignore
-from omop_alchemy.cdm.model import Measurement, Concept, Procedure_Occurrence
+from omop_alchemy.cdm.model import Measurement, Concept, Procedure_Occurrence, Observation
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 SQLExpr = Union[ColumnElement[Any], InstrumentedAttribute[Any]]
 
 modifier_concept = so.aliased(Concept, name="modifier_concept")
 procedure_concept = so.aliased(Concept, name="procedure_concept")
+observation_concept = so.aliased(Concept, name="observation_concept")
 
 def attach_to_condition_episode_via_episode_event(
     base_event_subq: sa.Subquery,
@@ -230,6 +231,66 @@ def measurement_attached_to_condition_episode(
         name=name,
     )
 
+def observation_event_core(
+    *,
+    concept_ids: Iterable[int] | None = None,
+    name: str = "observation_core",
+    include_cols: Sequence[SQLExpr] = (),
+    unlinked_only: bool = True,
+) -> sa.Subquery:
+    """
+    Minimal observation event surface (person/id/date/concept/label + extras).
+    """
+    q = (
+        sa.select(
+            Observation.person_id.label("person_id"),
+            Observation.observation_id.label("event_id"),
+            Observation.observation_date.label("event_date"),
+            Observation.observation_concept_id.label("event_concept_id"),
+            observation_concept.concept_name.label("event_label"),
+            Observation.value_as_concept_id.label("value_concept_id"),
+            Observation.qualifier_concept_id.label("qualifier_concept_id"),
+            *include_cols,
+        )
+        .join(
+            observation_concept,
+            observation_concept.concept_id == Observation.observation_concept_id,
+            isouter=True,
+        )
+    )
+
+    if unlinked_only:
+        q = q.where(Observation.observation_event_id == None)
+
+    if concept_ids is not None:
+        q = q.where(Observation.observation_concept_id.in_(list(concept_ids)))
+
+    return q.subquery(name=name)
+
+def observation_attached_to_condition_episode(
+    *,
+    concept_ids: Iterable[int] | None = None,
+    include_cols: Sequence[SQLExpr] = (),
+    name: str,
+    unlinked_only: bool = True,
+    prefer_explicit_link: bool = True,
+) -> sa.Subquery:
+    core = observation_event_core(
+        concept_ids=concept_ids,
+        include_cols=include_cols,
+        name=f"{name}_core",
+        unlinked_only=unlinked_only,
+    )
+
+    return attach_to_condition_episode(
+        core,
+        event_id_col=core.c.event_id,
+        date_col=core.c.event_date,
+        person_col=core.c.person_id,
+        name=name,
+        prefer_explicit_link=prefer_explicit_link,
+    )
+
 def episode_relevant_window(
     starting_query: sa.Subquery,
     *,

omop_constructs-0.3.7/src/omop_constructs/alchemy/events/observation_queries.py

@@ -0,0 +1,16 @@
+from .event_factories import observation_attached_to_condition_episode, episode_relevant_window
+from omop_alchemy.cdm.model import Observation
+dx_all_observations = episode_relevant_window(
+    observation_attached_to_condition_episode(
+        concept_ids=None,  # all obs
+        include_cols=[
+            Observation.value_as_number,
+            Observation.qualifier_concept_id,
+        ],
+        name="dx_all_observations",
+        unlinked_only=False,
+    ),
+    max_days_post=365,
+    max_days_prior=30,
+    name="dx_all_observations_windowed",
+)

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/src/omop_constructs/alchemy/modifiers/__init__.py

@@ -10,6 +10,9 @@ from .modifier_mappers import (
     AllStageModifierMV
 )
 from .condition_modifier_mv import ModifiedCondition, StageModifier
+from .procedure_modifier_mv import (
+    ModifiedProcedure,
+)
 
 __all__ = [
     "TStageMV",
@@ -22,5 +25,6 @@ __all__ = [
     "ModifiedCondition",
     "MetastaticDiseaseModifierMV",
     "AllStageModifierMV",
-    "StageModifier"
+    "StageModifier",
+    "ModifiedProcedure"
 ]

omop_constructs-0.3.7/src/omop_constructs/alchemy/modifiers/procedure_modifier_joins.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+import sqlalchemy as sa
+import sqlalchemy.orm as so
+from omop_alchemy.cdm.model import Concept, Procedure_Occurrence, Measurement
+from omop_semantics.runtime.default_valuesets import runtime
+
+
+modifier_concept = so.aliased(Concept, name='modifier_concept')
+procedure_concept = so.aliased(Concept, name='procedure_concept')
+
+modified_procedure_join = (
+    sa.select(
+        Procedure_Occurrence.person_id,
+        Procedure_Occurrence.procedure_datetime, 
+        Procedure_Occurrence.procedure_occurrence_id,
+        Procedure_Occurrence.procedure_source_value,
+        Procedure_Occurrence.procedure_concept_id,
+        procedure_concept.concept_name.label('procedure_concept'),
+        Measurement.measurement_id.label('intent_id'),
+        Measurement.measurement_datetime.label('intent_datetime'),
+        Measurement.measurement_concept_id.label('intent_concept_id'),
+        modifier_concept.concept_name.label('intent_concept'),
+        sa.func.row_number().over().label('mv_id')
+    )
+    .join(
+        Measurement, 
+        sa.and_(
+            Measurement.modifier_of_field_concept_id==runtime.modifiers.modifier_fields.procedure_occurrence_id,
+            Procedure_Occurrence.procedure_occurrence_id==Measurement.modifier_of_event_id,
+            Measurement.measurement_concept_id.in_(runtime.treatment_modifiers.treatment_intent.ids)
+        ),
+        isouter=True
+    )
+    .join(procedure_concept, procedure_concept.concept_id==Procedure_Occurrence.procedure_concept_id)
+    .join(modifier_concept, modifier_concept.concept_id==Measurement.measurement_concept_id, isouter=True)
+)
+

omop_constructs-0.3.7/src/omop_constructs/alchemy/modifiers/procedure_modifier_mv.py

@@ -0,0 +1,30 @@
+import sqlalchemy as sa
+from orm_loader.helpers import Base
+from ...core.materialized import MaterializedViewMixin
+from ...core.constructs import register_construct
+from .procedure_modifier_joins import modified_procedure_join
+
+@register_construct
+class ModifiedProcedure(MaterializedViewMixin, Base):
+    """
+    this class contains all stage modifier records no matter the sub-type, nor does it preference 
+    clin / path stage etc - just a dump of all, along with the identifier to link to condition ep
+    """
+    __mv_name__ = 'modified_procedure_mv'
+    __mv_select__ = modified_procedure_join.select()
+    __mv_pk__ = ["mv_id"]
+    __table_args__ = {"extend_existing": True}
+    __tablename__ = __mv_name__
+    __deps__ = ()
+    mv_id = sa.Column(sa.Integer,primary_key=True)
+    person_id = sa.Column(sa.Integer)
+    procedure_datetime = sa.Column(sa.Date)
+    procedure_occurrence_id = sa.Column(sa.Integer)
+    procedure_source_value = sa.Column(sa.String)
+    procedure_concept_id = sa.Column(sa.Integer)
+    procedure_concept = sa.Column(sa.String)
+    intent_id = sa.Column(sa.Integer)
+    intent_datetime = sa.Column(sa.Date)
+    intent_concept_id = sa.Column(sa.Integer)
+    intent_concept = sa.Column(sa.String)
+    stage_label = sa.Column(sa.String)

{omop_constructs-0.3.5 → omop_constructs-0.3.7}/src/omop_constructs/semantics/runtime_lookups.py

@@ -38,6 +38,14 @@ DEFAULT_RESOLVER_BUILDERS = {
         parent_list=list(runtime.condition_modifiers.tumor_grade.ids),
         resolver_name="tumor_grade",
     ),
+    "rt_procedures": lambda session: build_parent_resolver(
+        session,
+        parent_list=[
+            runtime.cancer_procedures.cancer_procedure_types.rt_externalbeam, # type: ignore
+            runtime.cancer_procedures.cancer_procedure_types.rt_procedure
+        ],
+        resolver_name="rt_procedures",
+    )
 }
 
 def get_registry_engine(env_path: str = __file__):

omop_constructs-0.3.5/src/omop_constructs/alchemy/episodes/treatment_summary_joins.py

@@ -1,25 +0,0 @@
-import sqlalchemy as sa
-from omop_semantics.runtime.default_valuesets import runtime
-from .condition_episode_mv import TreatmentRegimenCycleMV
-
-treatment_summary = (
-    sa.select(
-        TreatmentRegimenCycleMV.person_id,
-        TreatmentRegimenCycleMV.episode_parent_id.label("condition_episode_id"),
-        TreatmentRegimenCycleMV.episode_concept_id,
-        TreatmentRegimenCycleMV.episode_label,
-
-        sa.func.min(TreatmentRegimenCycleMV.episode_start_date).label("treatment_start_date"),
-        sa.func.max(TreatmentRegimenCycleMV.episode_end_date).label("treatment_end_date"),
-
-        sa.func.count(sa.distinct(TreatmentRegimenCycleMV.episode_id)).label("regimen_count"),
-        sa.func.count(sa.distinct(TreatmentRegimenCycleMV.cycle_episode_id)).label("cycle_count"),
-    )
-    .group_by(
-        TreatmentRegimenCycleMV.person_id,
-        TreatmentRegimenCycleMV.episode_parent_id,
-        TreatmentRegimenCycleMV.episode_concept_id,
-        TreatmentRegimenCycleMV.episode_label,
-    )
-    .subquery("treatment_summary")
-)