vivarium-public-health 4.2.6__py3-none-any.whl → 4.3.1__py3-none-any.whl

vivarium_public_health/risks/effect.py

@@ -3,339 +3,32 @@
 Risk Effect Models
 ==================
 
-This module contains tools for modeling the relationship between risk
-exposure models and disease models.
-
 """
+
 from collections.abc import Callable
-from importlib import import_module
 from typing import Any
 
 import numpy as np
 import pandas as pd
 import scipy
-from layered_config_tree import ConfigurationError
-from vivarium import Component
 from vivarium.framework.engine import Builder
-from vivarium.framework.values import Pipeline
 
-from vivarium_public_health.risks import Risk
-from vivarium_public_health.risks.data_transformations import (
-    load_exposure_data,
-    pivot_categorical,
-)
-from vivarium_public_health.risks.distributions import MissingDataError
-from vivarium_public_health.utilities import EntityString, TargetString, get_lookup_columns
+from vivarium_public_health.exposure import ExposureEffect
+from vivarium_public_health.exposure.distributions import MissingDataError
+from vivarium_public_health.utilities import EntityString, TargetString
 
 
-class RiskEffect(Component):
+class RiskEffect(ExposureEffect):
     """A component to model the effect of a risk factor on an affected entity's target rate.
 
     This component can source data either from builder.data or from parameters
     supplied in the configuration.
 
-    For a risk named 'risk' that affects  'affected_risk' and 'affected_cause',
-    the configuration would look like:
-
-    .. code-block:: yaml
-
-       configuration:
-            risk_effect.risk_name_on_affected_target:
-               exposure_parameters: 2
-               incidence_rate: 10
-
     """
 
-    ###############
-    # Properties #
-    ##############
-
-    @property
-    def name(self) -> str:
-        return self.get_name(self.risk, self.target)
-
-    @staticmethod
-    def get_name(risk: EntityString, target: TargetString) -> str:
+    def get_name(self, risk: EntityString, target: TargetString) -> str:
         return f"risk_effect.{risk.name}_on_{target}"
 
-    @property
-    def configuration_defaults(self) -> dict[str, Any]:
-        """Default values for any configurations managed by this component."""
-        return {
-            self.name: {
-                "data_sources": {
-                    "relative_risk": f"{self.risk}.relative_risk",
-                    "population_attributable_fraction": f"{self.risk}.population_attributable_fraction",
-                },
-                "data_source_parameters": {
-                    "relative_risk": {},
-                },
-            }
-        }
-
-    @property
-    def is_exposure_categorical(self) -> bool:
-        return self._exposure_distribution_type in [
-            "dichotomous",
-            "ordered_polytomous",
-            "unordered_polytomous",
-        ]
-
-    #####################
-    # Lifecycle methods #
-    #####################
-
-    def __init__(self, risk: str, target: str):
-        """
-
-        Parameters
-        ----------
-        risk
-            Type and name of risk factor, supplied in the form
-            "risk_type.risk_name" where risk_type should be singular (e.g.,
-            risk_factor instead of risk_factors).
-        target
-            Type, name, and target rate of entity to be affected by risk factor,
-            supplied in the form "entity_type.entity_name.measure"
-            where entity_type should be singular (e.g., cause instead of causes).
-        """
-        super().__init__()
-        self.risk = EntityString(risk)
-        self.target = TargetString(target)
-
-        self._exposure_distribution_type = None
-
-        self.exposure_pipeline_name = f"{self.risk.name}.exposure"
-        self.target_pipeline_name = f"{self.target.name}.{self.target.measure}"
-        self.target_paf_pipeline_name = f"{self.target_pipeline_name}.paf"
-
-    # noinspection PyAttributeOutsideInit
-    def setup(self, builder: Builder) -> None:
-        self.exposure = self.get_risk_exposure(builder)
-
-        self._relative_risk_source = self.get_relative_risk_source(builder)
-        self.relative_risk = self.get_relative_risk_pipeline(builder)
-
-        self.register_target_modifier(builder)
-        self.register_paf_modifier(builder)
-
-    #################
-    # Setup methods #
-    #################
-
-    def build_all_lookup_tables(self, builder: Builder) -> None:
-        self._exposure_distribution_type = self.get_distribution_type(builder)
-
-        rr_data = self.load_relative_risk(builder)
-        rr_value_cols = None
-        if self.is_exposure_categorical:
-            rr_data, rr_value_cols = self.process_categorical_data(builder, rr_data)
-        self.lookup_tables["relative_risk"] = self.build_lookup_table(
-            builder, rr_data, rr_value_cols
-        )
-
-        paf_data = self.get_filtered_data(
-            builder, self.configuration.data_sources.population_attributable_fraction
-        )
-        self.lookup_tables["population_attributable_fraction"] = self.build_lookup_table(
-            builder, paf_data
-        )
-
-    def get_distribution_type(self, builder: Builder) -> str:
-        """Get the distribution type for the risk from the configuration."""
-        risk_exposure_component = self._get_risk_exposure_class(builder)
-        if risk_exposure_component.distribution_type:
-            return risk_exposure_component.distribution_type
-        return risk_exposure_component.get_distribution_type(builder)
-
-    def load_relative_risk(
-        self,
-        builder: Builder,
-        configuration=None,
-    ) -> str | float | pd.DataFrame:
-        if configuration is None:
-            configuration = self.configuration
-
-        rr_source = configuration.data_sources.relative_risk
-        rr_dist_parameters = configuration.data_source_parameters.relative_risk.to_dict()
-
-        if isinstance(rr_source, str):
-            try:
-                distribution = getattr(import_module("scipy.stats"), rr_source)
-                rng = np.random.default_rng(builder.randomness.get_seed(self.name))
-                rr_data = distribution(**rr_dist_parameters).ppf(rng.random())
-            except AttributeError:
-                rr_data = self.get_filtered_data(builder, rr_source)
-            except TypeError:
-                raise ConfigurationError(
-                    f"Parameters {rr_dist_parameters} are not valid for distribution {rr_source}."
-                )
-        else:
-            rr_data = self.get_filtered_data(builder, rr_source)
-        return rr_data
-
-    def get_filtered_data(
-        self, builder: "Builder", data_source: str | float | pd.DataFrame
-    ) -> float | pd.DataFrame:
-        data = super().get_data(builder, data_source)
-
-        if isinstance(data, pd.DataFrame):
-            # filter data to only include the target entity and measure
-            correct_target_mask = True
-            columns_to_drop = []
-            if "affected_entity" in data.columns:
-                correct_target_mask &= data["affected_entity"] == self.target.name
-                columns_to_drop.append("affected_entity")
-            if "affected_measure" in data.columns:
-                correct_target_mask &= data["affected_measure"] == self.target.measure
-                columns_to_drop.append("affected_measure")
-            data = data[correct_target_mask].drop(columns=columns_to_drop)
-        return data
-
-    def process_categorical_data(
-        self, builder: Builder, rr_data: str | float | pd.DataFrame
-    ) -> tuple[str | float | pd.DataFrame, list[str]]:
-        if not isinstance(rr_data, pd.DataFrame):
-            cat1 = builder.data.load("population.demographic_dimensions")
-            cat1["parameter"] = "cat1"
-            cat1["value"] = rr_data
-            cat2 = cat1.copy()
-            cat2["parameter"] = "cat2"
-            cat2["value"] = 1
-            rr_data = pd.concat([cat1, cat2], ignore_index=True)
-        if "parameter" in rr_data.index.names:
-            rr_data = rr_data.reset_index("parameter")
-
-        rr_value_cols = list(rr_data["parameter"].unique())
-        rr_data = pivot_categorical(builder, self.risk, rr_data, "parameter")
-        return rr_data, rr_value_cols
-
-    # todo currently this isn't being called. we need to properly set rrs if
-    #  the exposure has been rebinned
-    def rebin_relative_risk_data(
-        self, builder, relative_risk_data: pd.DataFrame
-    ) -> pd.DataFrame:
-        """Rebin relative risk data.
-
-        When the polytomous risk is rebinned, matching relative risk needs to be rebinned.
-        After rebinning, rr for both exposed and unexposed categories should be the weighted sum of relative risk
-        of the component categories where weights are relative proportions of exposure of those categories.
-        For example, if cat1, cat2, cat3 are exposed categories and cat4 is unexposed with exposure [0.1,0.2,0.3,0.4],
-        for the matching rr = [rr1, rr2, rr3, 1], rebinned rr for the rebinned cat1 should be:
-        (0.1 *rr1 + 0.2 * rr2 + 0.3* rr3) / (0.1+0.2+0.3)
-        """
-        if not self.risk in builder.configuration.to_dict():
-            return relative_risk_data
-
-        rebin_exposed_categories = set(builder.configuration[self.risk]["rebinned_exposed"])
-
-        if rebin_exposed_categories:
-            # todo make sure this works
-            exposure_data = load_exposure_data(builder, self.risk)
-            relative_risk_data = self._rebin_relative_risk_data(
-                relative_risk_data, exposure_data, rebin_exposed_categories
-            )
-
-        return relative_risk_data
-
-    def _rebin_relative_risk_data(
-        self,
-        relative_risk_data: pd.DataFrame,
-        exposure_data: pd.DataFrame,
-        rebin_exposed_categories: set,
-    ) -> pd.DataFrame:
-        cols = list(exposure_data.columns.difference(["value"]))
-
-        relative_risk_data = relative_risk_data.merge(exposure_data, on=cols)
-        relative_risk_data["value_x"] = relative_risk_data.value_x.multiply(
-            relative_risk_data.value_y
-        )
-        relative_risk_data.parameter = relative_risk_data["parameter"].map(
-            lambda p: "cat1" if p in rebin_exposed_categories else "cat2"
-        )
-        relative_risk_data = relative_risk_data.groupby(cols).sum().reset_index()
-        relative_risk_data["value"] = relative_risk_data.value_x.divide(
-            relative_risk_data.value_y
-        ).fillna(0)
-        return relative_risk_data.drop(columns=["value_x", "value_y"])
-
-    def get_risk_exposure(self, builder: Builder) -> Callable[[pd.Index], pd.Series]:
-        return builder.value.get_value(self.exposure_pipeline_name)
-
-    def adjust_target(self, index: pd.Index, target: pd.Series) -> pd.Series:
-        relative_risk = self.relative_risk(index)
-        return target * relative_risk
-
-    def get_relative_risk_source(self, builder: Builder) -> Callable[[pd.Index], pd.Series]:
-
-        if not self.is_exposure_categorical:
-            tmred = builder.data.load(f"{self.risk}.tmred")
-            tmrel = 0.5 * (tmred["min"] + tmred["max"])
-            scale = builder.data.load(f"{self.risk}.relative_risk_scalar")
-
-            def generate_relative_risk(index: pd.Index) -> pd.Series:
-                rr = self.lookup_tables["relative_risk"](index)
-                exposure = self.exposure(index)
-                relative_risk = np.maximum(rr.values ** ((exposure - tmrel) / scale), 1)
-                return relative_risk
-
-        else:
-            index_columns = ["index", self.risk.name]
-
-            def generate_relative_risk(index: pd.Index) -> pd.Series:
-                rr = self.lookup_tables["relative_risk"](index)
-                exposure = self.exposure(index).reset_index()
-                exposure.columns = index_columns
-                exposure = exposure.set_index(index_columns)
-
-                relative_risk = rr.stack().reset_index()
-                relative_risk.columns = index_columns + ["value"]
-                relative_risk = relative_risk.set_index(index_columns)
-
-                effect = relative_risk.loc[exposure.index, "value"].droplevel(self.risk.name)
-                return effect
-
-        return generate_relative_risk
-
-    def get_relative_risk_pipeline(self, builder: Builder) -> Pipeline:
-        return builder.value.register_value_producer(
-            f"{self.risk.name}_on_{self.target.name}.relative_risk",
-            self._relative_risk_source,
-            component=self,
-            required_resources=[self.exposure],
-        )
-
-    def register_target_modifier(self, builder: Builder) -> None:
-        builder.value.register_value_modifier(
-            self.target_pipeline_name,
-            modifier=self.adjust_target,
-            component=self,
-            required_resources=[self.relative_risk],
-        )
-
-    def register_paf_modifier(self, builder: Builder) -> None:
-        required_columns = get_lookup_columns(
-            [self.lookup_tables["population_attributable_fraction"]]
-        )
-        builder.value.register_value_modifier(
-            self.target_paf_pipeline_name,
-            modifier=self.lookup_tables["population_attributable_fraction"],
-            component=self,
-            required_resources=required_columns,
-        )
-
-    ##################
-    # Helper methods #
-    ##################
-
-    def _get_risk_exposure_class(self, builder: Builder) -> Risk:
-        risk_exposure_component = builder.components.get_component(self.risk)
-        if not isinstance(risk_exposure_component, Risk):
-            raise ValueError(
-                f"Risk effect model {self.name} requires a Risk component named {self.risk}"
-            )
-        return risk_exposure_component
-
 
 class NonLogLinearRiskEffect(RiskEffect):
     """A component to model the exposure-parametrized effect of a risk factor.
@@ -366,15 +59,15 @@ class NonLogLinearRiskEffect(RiskEffect):
         return {
             self.name: {
                 "data_sources": {
-                    "relative_risk": f"{self.risk}.relative_risk",
-                    "population_attributable_fraction": f"{self.risk}.population_attributable_fraction",
+                    "relative_risk": f"{self.entity}.relative_risk",
+                    "population_attributable_fraction": f"{self.entity}.population_attributable_fraction",
                 },
             }
         }
 
     @property
     def columns_required(self) -> list[str]:
-        return [f"{self.risk.name}_exposure"]
+        return [f"{self.entity.name}_exposure"]
 
     #################
     # Setup methods #
@@ -414,8 +107,8 @@ class NonLogLinearRiskEffect(RiskEffect):
             .reset_index()
         )
         rr_data = rr_data.drop("parameter", axis=1)
-        rr_data[f"{self.risk.name}_exposure_start"] = rr_data["left_exposure"]
-        rr_data[f"{self.risk.name}_exposure_end"] = rr_data["right_exposure"]
+        rr_data[f"{self.entity.name}_exposure_start"] = rr_data["left_exposure"]
+        rr_data[f"{self.entity.name}_exposure_end"] = rr_data["right_exposure"]
         # build lookup table
         rr_value_cols = ["left_exposure", "left_rr", "right_exposure", "right_rr"]
         self.lookup_tables["relative_risk"] = self.build_lookup_table(
@@ -438,17 +131,19 @@ class NonLogLinearRiskEffect(RiskEffect):
             configuration = self.configuration
 
         # get TMREL
-        tmred = builder.data.load(f"{self.risk}.tmred")
+        tmred = builder.data.load(f"{self.entity}.tmred")
         if tmred["distribution"] == "uniform":
             draw = builder.configuration.input_data.input_draw_number
             rng = np.random.default_rng(builder.randomness.get_seed(self.name + str(draw)))
             self.tmrel = rng.uniform(tmred["min"], tmred["max"])
         elif tmred["distribution"] == "draws":  # currently only for iron deficiency
             raise MissingDataError(
-                f"This data has draw-level TMRELs. You will need to contact the research team that models {self.risk.name} to get this data."
+                f"This data has draw-level TMRELs. You will need to contact the research team that models {self.entity.name} to get this data."
             )
         else:
-            raise MissingDataError(f"No TMRED found in gbd_mapping for risk {self.risk.name}")
+            raise MissingDataError(
+                f"No TMRED found in gbd_mapping for risk {self.entity.name}"
+            )
 
         # calculate RR at TMREL
         rr_source = configuration.data_sources.relative_risk
@@ -489,7 +184,7 @@ class NonLogLinearRiskEffect(RiskEffect):
     def get_relative_risk_source(self, builder: Builder) -> Callable[[pd.Index], pd.Series]:
         def generate_relative_risk(index: pd.Index) -> pd.Series:
             rr_intervals = self.lookup_tables["relative_risk"](index)
-            exposure = self.population_view.get(index)[f"{self.risk.name}_exposure"]
+            exposure = self.population_view.get(index)[f"{self.entity.name}_exposure"]
             x1, x2 = (
                 rr_intervals["left_exposure"].values,
                 rr_intervals["right_exposure"].values,
@@ -512,7 +207,7 @@ class NonLogLinearRiskEffect(RiskEffect):
         parameter_data_is_numeric = rr_data["parameter"].dtype.kind in "biufc"
         if not parameter_data_is_numeric:
             raise ValueError(
-                f"The parameter column in your {self.risk.name} relative risk data must contain numeric data. Its dtype is {rr_data['parameter'].dtype} instead."
+                f"The parameter column in your {self.entity.name} relative risk data must contain numeric data. Its dtype is {rr_data['parameter'].dtype} instead."
             )
 
         # and that these RR values are monotonically increasing within each demographic group

vivarium_public_health/risks/implementations/low_birth_weight_and_short_gestation.py

@@ -22,12 +22,12 @@ from vivarium.framework.population import SimulantData
 from vivarium.framework.resource import Resource
 from vivarium.framework.values import Pipeline
 
+from vivarium_public_health.exposure.distributions import PolytomousDistribution
 from vivarium_public_health.risks import Risk, RiskEffect
 from vivarium_public_health.risks.data_transformations import (
     get_exposure_post_processor,
     pivot_categorical,
 )
-from vivarium_public_health.risks.distributions import PolytomousDistribution
 from vivarium_public_health.utilities import EntityString, get_lookup_columns, to_snake_case
 
 CATEGORICAL = "categorical"
@@ -71,7 +71,10 @@ class LBWSGDistribution(PolytomousDistribution):
 
             if isinstance(birth_exposure_data, pd.DataFrame):
                 birth_exposure_data = pivot_categorical(
-                    builder, self.risk, birth_exposure_data, "parameter"
+                    builder,
+                    self.exposure_component.entity,
+                    birth_exposure_data,
+                    "parameter",
                 )
 
             self.lookup_tables["birth_exposure"] = self.build_lookup_table(
@@ -118,7 +121,9 @@ class LBWSGDistribution(PolytomousDistribution):
         -------
             The intervals for each category.
         """
-        categories: dict[str, str] = builder.data.load(f"{self.risk}.categories")
+        categories: dict[str, str] = builder.data.load(
+            f"{self.exposure_component.entity}.categories"
+        )
         category_intervals = {
             axis: {
                 category: self._parse_description(axis, description)
@@ -271,7 +276,7 @@ class LBWSGRisk(Risk):
         # Add birth exposure data source
         configuration_defaults[self.name]["data_sources"][
             "birth_exposure"
-        ] = f"{self.risk}.birth_exposure"
+        ] = f"{self.entity}.birth_exposure"
         configuration_defaults[self.name]["distribution_type"] = "lbwsg"
         return configuration_defaults
 
@@ -300,7 +305,7 @@ class LBWSGRisk(Risk):
         # Propensity only used on initialization; not being saved to avoid a cycle
         return None
 
-    def get_exposure_pipeline(self, builder: Builder) -> Pipeline | None:
+    def get_exposure_callable(self, builder: Builder) -> Pipeline | None:
         # Exposure only used on initialization; not being saved to avoid a cycle
         return None
 
@@ -359,7 +364,7 @@ class LBWSGRisk(Risk):
 
     def get_current_exposure(self, index: pd.Index) -> pd.DataFrame:
         raise LifeCycleError(
-            f"The {self.risk.name} exposure pipeline should not be called. You probably want to"
+            f"The {self.entity.name} exposure pipeline should not be called. You probably want to"
             f" refer directly one of the exposure columns. During simulant initialization the birth"
             f" exposure pipelines should be used instead."
         )
@@ -400,12 +405,12 @@ class LBWSGRiskEffect(RiskEffect):
             LBWSGRisk.get_exposure_column_name(axis) for axis in LBWSGRisk.AXES
         ]
         self.relative_risk_pipeline_name = (
-            f"effect_of_{self.risk.name}_on_{self.target.name}.relative_risk"
+            f"effect_of_{self.entity.name}_on_{self.target.name}.relative_risk"
         )
 
     def relative_risk_column_name(self, age_group_id: str) -> str:
         return (
-            f"effect_of_{self.risk.name}_on_{age_group_id}_{self.target.name}_relative_risk"
+            f"effect_of_{self.entity.name}_on_{age_group_id}_{self.target.name}_relative_risk"
         )
 
     # noinspection PyAttributeOutsideInit
@@ -426,7 +431,7 @@ class LBWSGRiskEffect(RiskEffect):
             builder, paf_data, paf_value_cols
         )
 
-    def get_risk_exposure(self, builder: Builder) -> Callable[[pd.Index], pd.DataFrame]:
+    def get_exposure_callable(self, builder: Builder) -> Callable[[pd.Index], pd.DataFrame]:
         def exposure(index: pd.Index) -> pd.DataFrame:
             return self.population_view.subview(self.lbwsg_exposure_column_names).get(index)
 
@@ -435,7 +440,7 @@ class LBWSGRiskEffect(RiskEffect):
     def get_population_attributable_fraction_source(
         self, builder: Builder
     ) -> tuple[pd.DataFrame, list[str]]:
-        paf_key = f"{self.risk}.population_attributable_fraction"
+        paf_key = f"{self.entity}.population_attributable_fraction"
         paf_data = builder.data.load(paf_key)
         return paf_data, builder.data.value_columns()(paf_key)
 
@@ -449,7 +454,7 @@ class LBWSGRiskEffect(RiskEffect):
 
     def get_age_intervals(self, builder: Builder) -> dict[str, pd.Interval]:
         age_bins = builder.data.load("population.age_bins").set_index("age_start")
-        relative_risks = builder.data.load(f"{self.risk}.relative_risk")
+        relative_risks = builder.data.load(f"{self.entity}.relative_risk")
         exposed_age_group_starts = (
             relative_risks.groupby("age_start")["value"].any().reset_index()["age_start"]
         )
@@ -476,7 +481,7 @@ class LBWSGRiskEffect(RiskEffect):
         }
 
         # get relative risk data for target
-        interpolators = builder.data.load(f"{self.risk}.relative_risk_interpolator")
+        interpolators = builder.data.load(f"{self.entity}.relative_risk_interpolator")
         interpolators = (
             # isolate RRs for target and drop non-neonatal age groups since they have RR == 1.0
             interpolators[

vivarium_public_health/treatment/__init__.py

@@ -1,3 +1,4 @@
+from vivarium_public_health.treatment.intervention import Intervention, InterventionEffect
 from vivarium_public_health.treatment.magic_wand import AbsoluteShift
 from vivarium_public_health.treatment.scale_up import LinearScaleUp
 from vivarium_public_health.treatment.therapeutic_inertia import TherapeuticInertia

vivarium_public_health/treatment/intervention.py

@@ -0,0 +1,85 @@
+from typing import NamedTuple
+
+from vivarium_public_health.exposure import Exposure
+from vivarium_public_health.exposure.effect import ExposureEffect
+from vivarium_public_health.utilities import EntityString, TargetString
+
+
+class Intervention(Exposure):
+    """A model for an intervention defined by coverage (access to intervention).
+
+    This component models access to an intervention as a dichotomous exposure where
+    simulants are either covered or uncovered by the intervention.
+
+    For example,
+
+    #. vaccination coverage where simulants are either vaccinated (covered) or
+       unvaccinated (uncovered).
+    #. treatment access where simulants either have access to treatment (covered)
+       or do not have access (uncovered).
+
+    This component can source data either from a key in an Artifact
+    ("intervention.intervention_name.coverage") or from parameters
+    supplied in the configuration. If data is derived from the configuration, it
+    must be an integer or float expressing the desired coverage level or a
+    covariate name that is intended to be used as a proxy. For example, for an
+    intervention named "intervention", the configuration could look like this:
+
+    .. code-block:: yaml
+
+       configuration:
+           intervention.intervention_name:
+               coverage: 0.8
+
+    Interventions should be configured with names in the format of
+    "intervention.intervention_name".
+
+    """
+
+    @property
+    def exposure_type(self) -> str:
+        """The measure of the intervention access."""
+        return "coverage"
+
+    @property
+    def dichotomous_exposure_category_names(self) -> NamedTuple:
+        """The name of the covered and uncovered categories for this intervention."""
+
+        class __Categories(NamedTuple):
+            exposed: str = "covered"
+            unexposed: str = "uncovered"
+
+        categories = __Categories()
+        return categories
+
+
+class InterventionEffect(ExposureEffect):
+    """A component to model the effect of an intervention on an affected entity's target rate.
+
+    This component models how intervention coverage affects the rate of some target
+    entity (e.g., disease incidence, mortality, disability). The effect is typically
+    protective, reducing the target rate for covered simulants compared to uncovered
+    simulants.
+
+    This component can source data either from builder.data or from parameters
+    supplied in the configuration. The data should specify the relative risk or
+    rate ratio associated with intervention coverage.
+
+    For example, an intervention effect might model how vaccination coverage affects
+    disease incidence, where vaccinated individuals have a lower risk of disease
+    compared to unvaccinated individuals.
+
+    For an exposure named 'exposure_name' that affects  'affected_entity' and 'affected_cause',
+    the configuration would look like:
+
+    .. code-block:: yaml
+
+       configuration:
+            intervention_effect.exposure_name_on_affected_target:
+               exposure_parameters: 2
+               incidence_rate: 10
+
+    """
+
+    def get_name(self, intervention: EntityString, target: TargetString) -> str:
+        return f"intervention_effect.{intervention.name}_on_{target}"

{vivarium_public_health-4.2.6.dist-info → vivarium_public_health-4.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vivarium_public_health
-Version: 4.2.6
+Version: 4.3.1
 Summary: Components for modelling diseases, risks, and interventions with ``vivarium``
 Home-page: https://github.com/ihmeuw/vivarium_public_health
 Author: The vivarium developers