vivarium-public-health 4.3.1__tar.gz → 4.3.3__tar.gz

{vivarium_public_health-4.3.1 → vivarium_public_health-4.3.3}/.gitignore

@@ -114,7 +114,4 @@ src/vivarium_public_health/_version.py
 tests/proportion_test_diagnostics.csv
 
 # macOS
-*.DS_Store
-
-# Visual Studio Code project settings
-.vscode/
+*.DS_Store

{vivarium_public_health-4.3.1 → vivarium_public_health-4.3.3}/CHANGELOG.rst

@@ -1,4 +1,12 @@
-**4.3.1 - 08/01/25**
+**4.3.3 - 07/30/25**
+
+  - Revert changes from v4.3.0-4.3.2
+
+**4.3.2 - 07/30/25** (withdrawn)
+
+  - Support RiskEffect backwards compatibility with v4.2.x
+
+**4.3.1 - 07/30/25** (withdrawn)
 
   - Bugfix: reference correct entity name in LBWSG get_current_exposure method
   - Support backwards compatibility with v4.2.x

{vivarium_public_health-4.3.1 → vivarium_public_health-4.3.3}/PKG-INFO

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

vivarium_public_health-4.3.3/docs/source/api_reference/risks/distributions.rst

@@ -0,0 +1 @@
+.. automodule:: vivarium_public_health.risks.distributions

{vivarium_public_health-4.3.1 → vivarium_public_health-4.3.3}/src/vivarium_public_health/__init__.py

@@ -46,13 +46,7 @@ from vivarium_public_health.risks import (
     Risk,
     RiskEffect,
 )
-from vivarium_public_health.treatment import (
-    AbsoluteShift,
-    Intervention,
-    InterventionEffect,
-    LinearScaleUp,
-    TherapeuticInertia,
-)
+from vivarium_public_health.treatment import AbsoluteShift, LinearScaleUp, TherapeuticInertia
 
 __all__ = [
     __author__,

vivarium_public_health-4.3.3/src/vivarium_public_health/_version.py

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

{vivarium_public_health-4.3.1 → vivarium_public_health-4.3.3}/src/vivarium_public_health/population/data_transformations.py

@@ -584,8 +584,8 @@ def rescale_final_age_bin(builder, population_data):
 
 def validate_crude_birth_rate_data(builder, data_year_max):
     population_config = builder.configuration.population.to_dict()
-    untracking_age = population_config.get("untracking_age")
-    age_end = population_config.get("age_end")
+    untracking_age = population_config.get("untracking_age", None)
+    age_end = population_config.get("age_end", None)
     if untracking_age and age_end and age_end != untracking_age:
         raise ValueError(
             "If you specify an exit age, the initial population age end must be the same "

{vivarium_public_health-4.3.1 → vivarium_public_health-4.3.3}/src/vivarium_public_health/results/__init__.py

@@ -1,7 +1,6 @@
 from .columns import COLUMNS
 from .disability import DisabilityObserver
 from .disease import DiseaseObserver
-from .intervention import CategoricalInterventionObserver
 from .mortality import MortalityObserver
 from .observer import PublicHealthObserver
 from .risk import CategoricalRiskObserver

vivarium_public_health-4.3.1/src/vivarium_public_health/exposure/exposure.py → vivarium_public_health-4.3.3/src/vivarium_public_health/risks/base_risk.py

@@ -1,5 +1,14 @@
-from abc import ABC, abstractmethod
-from typing import Any, NamedTuple
+"""
+===================
+Risk Exposure Model
+===================
+
+This module contains tools for modeling categorical and continuous risk
+exposure.
+
+"""
+
+from typing import Any
 
 import pandas as pd
 from vivarium import Component
@@ -10,23 +19,73 @@ from vivarium.framework.randomness import RandomnessStream
 from vivarium.framework.resource import Resource
 from vivarium.framework.values import Pipeline
 
-from vivarium_public_health.exposure.distributions import (
+from vivarium_public_health.risks.data_transformations import get_exposure_post_processor
+from vivarium_public_health.risks.distributions import (
     ContinuousDistribution,
     DichotomousDistribution,
     EnsembleDistribution,
-    ExposureDistribution,
     PolytomousDistribution,
+    RiskExposureDistribution,
 )
-from vivarium_public_health.risks.data_transformations import get_exposure_post_processor
 from vivarium_public_health.utilities import EntityString, get_lookup_columns
 
 
-class Exposure(Component, ABC):
-    """A base class to store common functionality for for risk-like health factors.
+class Risk(Component):
+    """A model for a risk factor defined by either a continuous or a categorical value.
+
+    For example,
+
+    #. high systolic blood pressure as a risk where the SBP is not dichotomized
+       into hypotension and normal but is treated as the actual SBP
+       measurement.
+    #. smoking as two categories: current smoker and non-smoker.
+
+    This component can source data either from builder.data or from parameters
+    supplied in the configuration. If data is derived from the configuration, it
+    must be an integer or float expressing the desired exposure level or a
+    covariate name that is intended to be used as a proxy. For example, for a
+    risk named "risk", the configuration could look like this:
+
+    .. code-block:: yaml
+
+       configuration:
+           risk:
+               exposure: 1.0
+
+    or
+
+    .. code-block:: yaml
+
+       configuration:
+           risk:
+               exposure: proxy_covariate
 
-    This class is used to define the determinant of models health factors such as
-    risks and the exposure to these risks, or interventions and the available coverage
-    for these interventions.
+    For polytomous risks, you can also provide an optional 'rebinned_exposed'
+    block in the configuration to indicate that the risk should be rebinned
+    into a dichotomous risk. That block should contain a list of the categories
+    that should be rebinned into a single exposed category in the resulting
+    dichotomous risk. For example, for a risk named "risk" with categories
+    cat1, cat2, cat3, and cat4 that you wished to rebin into a dichotomous risk
+    with an exposed category containing cat1 and cat2 and an unexposed category
+    containing cat3 and cat4, the configuration could look like this:
+
+    .. code-block:: yaml
+
+       configuration:
+           risk:
+              rebinned_exposed: ['cat1', 'cat2']
+
+    For alternative risk factors, you must provide a 'category_thresholds'
+    block in the in configuration to dictate the thresholds that should be
+    used to bin the continuous distributions. Note that this is mutually
+    exclusive with providing 'rebinned_exposed' categories. For a risk named
+    "risk", the configuration could look like:
+
+    .. code-block:: yaml
+
+       configuration:
+           risk:
+               category_thresholds: [7, 8, 9]
 
     """
 
@@ -45,18 +104,18 @@ class Exposure(Component, ABC):
 
     @property
     def name(self) -> str:
-        return self.entity
+        return self.risk
 
     @property
     def configuration_defaults(self) -> dict[str, Any]:
         return {
             self.name: {
                 "data_sources": {
-                    f"{self.exposure_type}": f"{self.entity}.{self.exposure_type}",
-                    "ensemble_distribution_weights": f"{self.entity}.exposure_distribution_weights",
-                    "exposure_standard_deviation": f"{self.entity}.exposure_standard_deviation",
+                    "exposure": f"{self.risk}.exposure",
+                    "ensemble_distribution_weights": f"{self.risk}.exposure_distribution_weights",
+                    "exposure_standard_deviation": f"{self.risk}.exposure_standard_deviation",
                 },
-                "distribution_type": f"{self.entity}.distribution",
+                "distribution_type": f"{self.risk}.distribution",
                 # rebinned_exposed only used for DichotomousDistribution
                 "rebinned_exposed": [],
                 "category_thresholds": [],
@@ -74,42 +133,27 @@ class Exposure(Component, ABC):
     def initialization_requirements(self) -> list[str | Resource]:
         return [self.randomness]
 
-    @property
-    @abstractmethod
-    def exposure_type(self) -> str:
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def dichotomous_exposure_category_names(self) -> NamedTuple:
-        """The name of the exposure categories. E.g. "exposed" and "unexposed" or
-        "covered" and "uncovered".
-
-        """
-        raise NotImplementedError
-
     #####################
     # Lifecycle methods #
     #####################
 
-    def __init__(self, entity: str) -> None:
+    def __init__(self, risk: str):
         """
 
         Parameters
         ----------
-        entity
-            the type and name of a entity, specified as "type.name". Type is singular.
-        level_type
-            The type of level for the health factor, e.g., "exposure" or "coverage".
+        risk
+            the type and name of a risk, specified as "type.name". Type is singular.
         """
         super().__init__()
-        self.entity = EntityString(entity)
+        self.risk = EntityString(risk)
         self.distribution_type = None
-        self.randomness_stream_name = f"initial_{self.entity.name}_propensity"
-        self.propensity_column_name = f"{self.entity.name}_propensity"
-        self.propensity_pipeline_name = f"{self.entity.name}.propensity"
-        self.exposure_pipeline_name = f"{self.entity.name}.{self.exposure_type}"
-        self.exposure_column_name = f"{self.entity.name}_{self.exposure_type}"
+
+        self.randomness_stream_name = f"initial_{self.risk.name}_propensity"
+        self.propensity_column_name = f"{self.risk.name}_propensity"
+        self.propensity_pipeline_name = f"{self.risk.name}.propensity"
+        self.exposure_pipeline_name = f"{self.risk.name}.exposure"
+        self.exposure_column_name = f"{self.risk.name}_exposure"
 
     #################
     # Setup methods #
@@ -126,10 +170,17 @@ class Exposure(Component, ABC):
 
         self.randomness = self.get_randomness_stream(builder)
         self.propensity = self.get_propensity_pipeline(builder)
-        self.exposure = self.get_exposure_callable(builder)
-        # This will be overwritten in the Risk class if there is a non-loglinear risk effect
-        # on that risk instance
-        self.create_exposure_column = False
+        self.exposure = self.get_exposure_pipeline(builder)
+
+        # We want to set this to True iff there is a non-loglinear risk effect
+        # on this risk instance
+        self.create_exposure_column = bool(
+            [
+                component
+                for component in builder.components.list_components()
+                if component.startswith(f"non_log_linear_risk_effect.{self.risk.name}_on_")
+            ]
+        )
 
     def get_distribution_type(self, builder: Builder) -> str:
         """Get the distribution type for the risk from the configuration.
@@ -165,7 +216,7 @@ class Exposure(Component, ABC):
             distribution_type = "dichotomous"
         return distribution_type
 
-    def get_exposure_distribution(self, builder: Builder) -> ExposureDistribution:
+    def get_exposure_distribution(self, builder: Builder) -> RiskExposureDistribution:
         """Creates and sets up the exposure distribution component for the Risk
         based on its distribution type.
 
@@ -185,7 +236,7 @@ class Exposure(Component, ABC):
         """
         try:
             exposure_distribution = self.exposure_distributions[self.distribution_type](
-                self, self.distribution_type
+                self.risk, self.distribution_type
             )
         except KeyError:
             raise NotImplementedError(
@@ -210,7 +261,7 @@ class Exposure(Component, ABC):
             required_resources=[self.propensity_column_name],
         )
 
-    def get_exposure_callable(self, builder: Builder) -> Pipeline:
+    def get_exposure_pipeline(self, builder: Builder) -> Pipeline:
         required_columns = get_lookup_columns(
             self.exposure_distribution.lookup_tables.values()
         )
@@ -242,7 +293,7 @@ class Exposure(Component, ABC):
 
     def update_exposure_column(self, index: pd.Index) -> None:
         if self.create_exposure_column:
-            exposure = pd.Series(self.exposure_type(index), name=self.exposure_column_name)
+            exposure = pd.Series(self.exposure(index), name=self.exposure_column_name)
             self.population_view.update(exposure)
 
     ##################################

{vivarium_public_health-4.3.1/src/vivarium_public_health/exposure → vivarium_public_health-4.3.3/src/vivarium_public_health/risks}/distributions.py

@@ -1,6 +1,6 @@
 """
 =================================
-Exposure Distribution Models
+Risk Exposure Distribution Models
 =================================
 
 This module contains tools for modeling several different risk
@@ -8,12 +8,8 @@ exposure distributions.
 
 """
 
-from __future__ import annotations
-
-import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable
-from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -28,15 +24,12 @@ from vivarium.framework.values import Pipeline, list_combiner, union_post_proces
 from vivarium_public_health.risks.data_transformations import pivot_categorical
 from vivarium_public_health.utilities import EntityString, get_lookup_columns
 
-if TYPE_CHECKING:
-    from vivarium_public_health.exposure import Exposure
-
 
 class MissingDataError(Exception):
     pass
 
 
-class ExposureDistribution(Component, ABC):
+class RiskExposureDistribution(Component, ABC):
 
     #####################
     # Lifecycle methods #
@@ -44,32 +37,23 @@ class ExposureDistribution(Component, ABC):
 
     def __init__(
         self,
-        exposure_component: Exposure,
+        risk: EntityString,
         distribution_type: str,
         exposure_data: int | float | pd.DataFrame | None = None,
     ) -> None:
         super().__init__()
-        self.exposure_component = exposure_component
+        self.risk = risk
         self.distribution_type = distribution_type
-        if (
-            self.distribution_type != "dichotomous"
-            and self.exposure_component.entity.type == "intervention"
-        ):
-            raise NotImplementedError(
-                f"Distribution type {self.distribution_type} is not supported for interventions."
-            )
         self._exposure_data = exposure_data
 
-        self.parameters_pipeline_name = (
-            f"{self.exposure_component.entity}.exposure_parameters"
-        )
+        self.parameters_pipeline_name = f"{self.risk}.exposure_parameters"
 
     #################
     # Setup methods #
     #################
 
     def get_configuration(self, builder: "Builder") -> LayeredConfigTree | None:
-        return builder.configuration[self.exposure_component.entity]
+        return builder.configuration[self.risk]
 
     @abstractmethod
     def build_all_lookup_tables(self, builder: "Builder") -> None:
@@ -78,9 +62,7 @@ class ExposureDistribution(Component, ABC):
     def get_exposure_data(self, builder: Builder) -> int | float | pd.DataFrame:
         if self._exposure_data is not None:
             return self._exposure_data
-        return self.get_data(
-            builder, self.configuration["data_sources"][self.exposure_component.exposure_type]
-        )
+        return self.get_data(builder, self.configuration["data_sources"]["exposure"])
 
     # noinspection PyAttributeOutsideInit
     def setup(self, builder: Builder) -> None:
@@ -105,7 +87,7 @@ class ExposureDistribution(Component, ABC):
         raise NotImplementedError
 
 
-class EnsembleDistribution(ExposureDistribution):
+class EnsembleDistribution(RiskExposureDistribution):
     ##############
     # Properties #
     ##############
@@ -124,7 +106,7 @@ class EnsembleDistribution(ExposureDistribution):
 
     def __init__(self, risk: EntityString, distribution_type: str = "ensemble") -> None:
         super().__init__(risk, distribution_type)
-        self._propensity = f"ensemble_propensity_{self.exposure_component.entity}"
+        self._propensity = f"ensemble_propensity_{self.risk}"
 
     #################
     # Setup methods #
@@ -147,11 +129,7 @@ class EnsembleDistribution(ExposureDistribution):
         distributions = list(raw_weights["parameter"].unique())
 
         raw_weights = pivot_categorical(
-            builder,
-            self.exposure_component.entity,
-            raw_weights,
-            pivot_column="parameter",
-            reset_index=False,
+            builder, self.risk, raw_weights, pivot_column="parameter", reset_index=False
         )
 
         weights, parameters = rd.EnsembleDistribution.get_parameters(
@@ -223,7 +201,7 @@ class EnsembleDistribution(ExposureDistribution):
         return x
 
 
-class ContinuousDistribution(ExposureDistribution):
+class ContinuousDistribution(RiskExposureDistribution):
     #####################
     # Lifecycle methods #
     #####################
@@ -283,12 +261,12 @@ class ContinuousDistribution(ExposureDistribution):
         return x
 
 
-class PolytomousDistribution(ExposureDistribution):
+class PolytomousDistribution(RiskExposureDistribution):
     @property
     def categories(self) -> list[str]:
-        # These need to be sorted so the cumulative sum is in the correct order of categories
+        # These need to be sorted so the cumulative sum is in the ocrrect order of categories
         # and results are therefore reproducible and correct
-        return sorted(self.lookup_tables[self.exposure_component.exposure_type].value_columns)
+        return sorted(self.lookup_tables["exposure"].value_columns)
 
     #################
     # Setup methods #
@@ -299,11 +277,9 @@ class PolytomousDistribution(ExposureDistribution):
         exposure_value_columns = self.get_exposure_value_columns(exposure_data)
 
         if isinstance(exposure_data, pd.DataFrame):
-            exposure_data = pivot_categorical(
-                builder, self.exposure_component.entity, exposure_data, "parameter"
-            )
+            exposure_data = pivot_categorical(builder, self.risk, exposure_data, "parameter")
 
-        self.lookup_tables[self.exposure_component.exposure_type] = self.build_lookup_table(
+        self.lookup_tables["exposure"] = self.build_lookup_table(
             builder, exposure_data, exposure_value_columns
         )
 
@@ -317,11 +293,9 @@ class PolytomousDistribution(ExposureDistribution):
     def get_exposure_parameter_pipeline(self, builder: Builder) -> Pipeline:
         return builder.value.register_value_producer(
             self.parameters_pipeline_name,
-            source=self.lookup_tables[self.exposure_component.exposure_type],
+            source=self.lookup_tables["exposure"],
             component=self,
-            required_resources=get_lookup_columns(
-                [self.lookup_tables[self.exposure_component.exposure_type]]
-            ),
+            required_resources=get_lookup_columns([self.lookup_tables["exposure"]]),
         )
 
     ##################
@@ -339,12 +313,12 @@ class PolytomousDistribution(ExposureDistribution):
         ).sum(axis=1)
         return pd.Series(
             np.array(self.categories)[category_index],
-            name=f"{self.exposure_component.entity}.exposure",
+            name=self.risk + ".exposure",
             index=quantiles.index,
         )
 
 
-class DichotomousDistribution(ExposureDistribution):
+class DichotomousDistribution(RiskExposureDistribution):
 
     #################
     # Setup methods #
@@ -358,15 +332,11 @@ class DichotomousDistribution(ExposureDistribution):
             any_negatives = (exposure_data[exposure_value_columns] < 0).any().any()
             any_over_one = (exposure_data[exposure_value_columns] > 1).any().any()
             if any_negatives or any_over_one:
-                raise ValueError(
-                    f"All exposures must be in the range [0, 1] for {self.exposure_component.entity}"
-                )
+                raise ValueError(f"All exposures must be in the range [0, 1] for {self.risk}")
         elif exposure_data < 0 or exposure_data > 1:
-            raise ValueError(
-                f"Exposure must be in the range [0, 1] for {self.exposure_component.entity}"
-            )
+            raise ValueError(f"Exposure must be in the range [0, 1] for {self.risk}")
 
-        self.lookup_tables[self.exposure_component.exposure_type] = self.build_lookup_table(
+        self.lookup_tables["exposure"] = self.build_lookup_table(
             builder, exposure_data, exposure_value_columns
         )
         self.lookup_tables["paf"] = self.build_lookup_table(builder, 0.0)
@@ -380,43 +350,20 @@ class DichotomousDistribution(ExposureDistribution):
         # rebin exposure categories
         self.validate_rebin_source(builder, exposure_data)
         rebin_exposed_categories = set(self.configuration["rebinned_exposed"])
-        # Check if risk exposure is exposed vs cat1
-        if (
-            "cat1" in exposure_data["parameter"].unique()
-            and self.exposure_component.entity.type == "risk_factor"
-        ):
-            warnings.warn(
-                "Using 'cat1' and 'cat2' for dichotomous exposure is deprecated and will be removed in a future release. Use 'exposed' and 'unexposed' instead.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            exposure_data["parameter"] = exposure_data["parameter"].replace(
-                {
-                    "cat1": self.exposure_component.dichotomous_exposure_category_names.exposed,
-                    "cat2": self.exposure_component.dichotomous_exposure_category_names.unexposed,
-                }
-            )
         if rebin_exposed_categories:
-            exposure_data = self._rebin_exposure_data(
-                exposure_data,
-                rebin_exposed_categories,
-                self.exposure_component.dichotomous_exposure_category_names.exposed,
-            )
+            exposure_data = self._rebin_exposure_data(exposure_data, rebin_exposed_categories)
 
-        exposure_data = exposure_data[
-            exposure_data["parameter"]
-            == self.exposure_component.dichotomous_exposure_category_names.exposed
-        ]
+        exposure_data = exposure_data[exposure_data["parameter"] == "cat1"]
         return exposure_data.drop(columns="parameter")
 
     @staticmethod
     def _rebin_exposure_data(
-        exposure_data: pd.DataFrame, rebin_exposed_categories: set, exposed_category_name: str
+        exposure_data: pd.DataFrame, rebin_exposed_categories: set
     ) -> pd.DataFrame:
         exposure_data = exposure_data[
             exposure_data["parameter"].isin(rebin_exposed_categories)
         ]
-        exposure_data["parameter"] = exposed_category_name
+        exposure_data["parameter"] = "cat1"
         exposure_data = (
             exposure_data.groupby(list(exposure_data.columns.difference(["value"])))
             .sum()
@@ -435,7 +382,7 @@ class DichotomousDistribution(ExposureDistribution):
     def setup(self, builder: Builder) -> None:
         super().setup(builder)
         self.joint_paf = builder.value.register_value_producer(
-            f"{self.exposure_component.entity}.exposure_parameters.paf",
+            f"{self.risk}.exposure_parameters.paf",
             source=lambda index: [self.lookup_tables["paf"](index)],
             component=self,
             preferred_combiner=list_combiner,
@@ -444,12 +391,10 @@ class DichotomousDistribution(ExposureDistribution):
 
     def get_exposure_parameter_pipeline(self, builder: Builder) -> Pipeline:
         return builder.value.register_value_producer(
-            f"{self.exposure_component.entity}.exposure_parameters",
+            f"{self.risk}.exposure_parameters",
             source=self.exposure_parameter_source,
             component=self,
-            required_resources=get_lookup_columns(
-                [self.lookup_tables[self.exposure_component.exposure_type]]
-            ),
+            required_resources=get_lookup_columns([self.lookup_tables["exposure"]]),
         )
 
     ##############
@@ -460,31 +405,29 @@ class DichotomousDistribution(ExposureDistribution):
         if not isinstance(data, pd.DataFrame):
             return
 
-        rebin_exposed_categories = set(
-            builder.configuration[self.exposure_component.entity]["rebinned_exposed"]
-        )
+        rebin_exposed_categories = set(builder.configuration[self.risk]["rebinned_exposed"])
 
         if (
             rebin_exposed_categories
-            and builder.configuration[self.exposure_component.entity]["category_thresholds"]
+            and builder.configuration[self.risk]["category_thresholds"]
         ):
             raise ValueError(
                 f"Rebinning and category thresholds are mutually exclusive. "
-                f"You provided both for {self.exposure_component.entity.name}."
+                f"You provided both for {self.risk.name}."
             )
 
         invalid_cats = rebin_exposed_categories.difference(set(data.parameter))
         if invalid_cats:
             raise ValueError(
                 f"The following provided categories for the rebinned exposed "
-                f"category of {self.exposure_component.entity.name} are not found in the exposure data: "
+                f"category of {self.risk.name} are not found in the exposure data: "
                 f"{invalid_cats}."
             )
 
         if rebin_exposed_categories == set(data.parameter):
             raise ValueError(
                 f"The provided categories for the rebinned exposed category of "
-                f"{self.exposure_component.entity.name} comprise all categories for the exposure data. "
+                f"{self.risk.name} comprise all categories for the exposure data. "
                 f"At least one category must be left out of the provided categories "
                 f"to be rebinned into the unexposed category."
             )
@@ -494,9 +437,7 @@ class DichotomousDistribution(ExposureDistribution):
     ##################################
 
     def exposure_parameter_source(self, index: pd.Index) -> pd.Series:
-        base_exposure = self.lookup_tables[self.exposure_component.exposure_type](
-            index
-        ).values
+        base_exposure = self.lookup_tables["exposure"](index).values
         joint_paf = self.joint_paf(index).values
         return pd.Series(base_exposure * (1 - joint_paf), index=index, name="values")
 
@@ -507,13 +448,8 @@ class DichotomousDistribution(ExposureDistribution):
     def ppf(self, quantiles: pd.Series) -> pd.Series:
         exposed = quantiles < self.exposure_parameters(quantiles.index)
         return pd.Series(
-            exposed.replace(
-                {
-                    True: self.exposure_component.dichotomous_exposure_category_names.exposed,
-                    False: self.exposure_component.dichotomous_exposure_category_names.unexposed,
-                }
-            ),
-            name=f"{self.exposure_component.entity}.{self.exposure_component.exposure_type}",
+            exposed.replace({True: "cat1", False: "cat2"}),
+            name=self.risk + ".exposure",
             index=quantiles.index,
         )