repyability 0.4.0__tar.gz → 0.5.0__tar.gz

repyability-0.5.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: repyability
+Version: 0.5.0
+Summary: Reliability engineering tools for Python
+Author-email: derrynknife <derrynknife@gmail.com>
+License: Copyright (c) 2020 The Python Packaging Authority
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/derrynknife/RePyability
+Project-URL: Documentation, https://derrynknife.github.io/RePyability/
+Project-URL: Repository, https://github.com/derrynknife/RePyability
+Project-URL: Issues, https://github.com/derrynknife/RePyability/issues
+Keywords: reliability,reliability-engineering,reliability-block-diagram,rbd,survival-analysis,availability,maintainability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=2.0
+Requires-Dist: scipy>=1.7
+Requires-Dist: networkx>=3.0
+Requires-Dist: surpyval<0.12,>=0.11.1
+Requires-Dist: tqdm>=4.64
+Provides-Extra: dev
+Requires-Dist: black==26.3.1; extra == "dev"
+Requires-Dist: isort>=5.12; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Requires-Dist: flake8-pyproject>=1.2; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: coverage>=7.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Requires-Dist: joblib>=1.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24; extra == "docs"
+Dynamic: license-file
+
+# RePyability
+
+[![actions](https://github.com/derrynknife/RePyability/actions/workflows/actions.yml/badge.svg)](https://github.com/derrynknife/RePyability/actions/workflows/actions.yml)
+[![docs](https://github.com/derrynknife/RePyability/actions/workflows/docs.yml/badge.svg)](https://derrynknife.github.io/RePyability/)
+
+Reliability Engineering Tools
+
+This is a series of tools created to make an open source set of methods to be used by reliability engineers to make it more accessible for students right through to practicing professionals.
+
+## Install
+RePyability can be installed via pip using the PyPI [repository](https://pypi.org/project/repyability/)
+
+```bash
+pip install repyability
+```
+
+## Documentation
+The full documentation — overview, user guide, and API reference — is hosted at
+**[derrynknife.github.io/RePyability](https://derrynknife.github.io/RePyability/)**.
+
+It is built with [MkDocs](https://www.mkdocs.org/) from the sources in `docs/`
+and `mkdocs.yml`, and published to GitHub Pages on every push to `master`. To
+build and serve it locally:
+
+```bash
+pip install -e .[docs]
+mkdocs serve            # then open http://127.0.0.1:8000
+```
+
+The source lives in `docs/` and `mkdocs.yml`; start with `docs/index.md`.
+
+## Testing
+Run the testing suite by simply executing:
+```bash
+pytest
+```
+or use coverage to get a coverage report:
+```bash
+coverage run -m pytest  # Run pytest under coverage's watch
+coverage report         # Print coverage report
+coverage html           # Make a html coverage report (really useful), open htmlcov/index.html
+```
+
+## Pre-commit
+### TL;DR
+- Pip install `pre-commit` (it's in `requirements_dev.txt` anyways)
+- Run `pre-commit install` which sets up the git hook scripts
+- If you'd like, run `pre-commit run --all-files` to run the hooks on all files
+- When you go to commit, it will only proceed after all the hooks succeed
+
+### Why?
+To ensure the good code quality and consistency it is recommended that when contributing to this
+repository to use the provided `.pre-commit-config.yaml` configuration for the Python package
+`pre-commit` (https://pre-commit.com). Upon making a commit, it checks that imports
+and requirements are sorted, syntax is up-to-date, code is formatted, linted, and statically type-checked,
+all with the same tools and configurations as one another.

repyability-0.4.0/repyability.egg-info/PKG-INFO → repyability-0.5.0/README.md

@@ -1,18 +1,8 @@
-Metadata-Version: 2.1
-Name: repyability
-Version: 0.4.0
-Summary: A reliability analysis python package
-Home-page: https://github.com/derrynknife/RePyability
-Author: Derryn Knife
-Author-email: derryn@reliafy.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
 # RePyability
+
+[![actions](https://github.com/derrynknife/RePyability/actions/workflows/actions.yml/badge.svg)](https://github.com/derrynknife/RePyability/actions/workflows/actions.yml)
+[![docs](https://github.com/derrynknife/RePyability/actions/workflows/docs.yml/badge.svg)](https://derrynknife.github.io/RePyability/)
+
 Reliability Engineering Tools
 
 This is a series of tools created to make an open source set of methods to be used by reliability engineers to make it more accessible for students right through to practicing professionals.
@@ -24,6 +14,21 @@ RePyability can be installed via pip using the PyPI [repository](https://pypi.or
 pip install repyability
 ```
 
+## Documentation
+The full documentation — overview, user guide, and API reference — is hosted at
+**[derrynknife.github.io/RePyability](https://derrynknife.github.io/RePyability/)**.
+
+It is built with [MkDocs](https://www.mkdocs.org/) from the sources in `docs/`
+and `mkdocs.yml`, and published to GitHub Pages on every push to `master`. To
+build and serve it locally:
+
+```bash
+pip install -e .[docs]
+mkdocs serve            # then open http://127.0.0.1:8000
+```
+
+The source lives in `docs/` and `mkdocs.yml`; start with `docs/index.md`.
+
 ## Testing
 Run the testing suite by simply executing:
 ```bash
@@ -38,7 +43,7 @@ coverage html           # Make a html coverage report (really useful), open html
 
 ## Pre-commit
 ### TL;DR
-- Pip install `pre-commit` (it's in `requirements.txt` anyways)
+- Pip install `pre-commit` (it's in `requirements_dev.txt` anyways)
 - Run `pre-commit install` which sets up the git hook scripts
 - If you'd like, run `pre-commit run --all-files` to run the hooks on all files
 - When you go to commit, it will only proceed after all the hooks succeed

repyability-0.5.0/pyproject.toml

@@ -0,0 +1,112 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "repyability"
+dynamic = ["version"]
+description = "Reliability engineering tools for Python"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.11"
+authors = [{ name = "derrynknife", email = "derrynknife@gmail.com" }]
+keywords = [
+    "reliability",
+    "reliability-engineering",
+    "reliability-block-diagram",
+    "rbd",
+    "survival-analysis",
+    "availability",
+    "maintainability",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "numpy>=2.0,<3",
+    "scipy>=1.7",
+    "networkx>=3.0",
+    "surpyval>=0.11.1,<0.12",
+    "tqdm>=4.64",
+]
+
+[project.optional-dependencies]
+dev = [
+    "black==26.3.1",
+    "isort>=5.12",
+    "flake8>=6.0",
+    "flake8-pyproject>=1.2",
+    "mypy>=1.8",
+    "pytest>=7.0",
+    "coverage>=7.0",
+    "pre-commit>=3.0",
+    # Testing-only: the suite imports surpyval, which transitively pulls in its
+    # RandomSurvivalForest (and hence joblib). Not a runtime dependency of
+    # RePyability.
+    "joblib>=1.0",
+]
+docs = [
+    "mkdocs-material>=9.0",
+    "mkdocstrings[python]>=0.24",
+]
+
+[project.urls]
+Homepage = "https://github.com/derrynknife/RePyability"
+Documentation = "https://derrynknife.github.io/RePyability/"
+Repository = "https://github.com/derrynknife/RePyability"
+Issues = "https://github.com/derrynknife/RePyability/issues"
+
+[tool.setuptools.dynamic]
+version = { attr = "repyability._version.__version__" }
+
+[tool.setuptools.packages.find]
+include = ["repyability*"]
+
+# For Black pre-commit hook
+[tool.black]
+line-length = 79
+
+# So isort is compatible with black
+[tool.isort]
+profile = "black"
+line_length = 79
+
+# mypy
+[tool.mypy]
+exclude = ['repyability/tests/']
+
+[[tool.mypy.overrides]]
+module = [
+    'scipy.*',
+    'networkx',
+    'surpyval.*',
+    'tqdm',
+    'numpy',
+    'numpy.*',
+]
+ignore_missing_imports = true
+
+# Coverage
+[tool.coverage.run]
+source = ["repyability"]
+omit = ["*/tests/*"]
+
+[tool.coverage.report]
+# The library (excluding tests) must stay above this bar.
+fail_under = 80
+
+# Flake8
+[tool.flake8]
+extend-ignore = ['E203', 'W503']
+per-file-ignores = [
+    '*/__init__.py:F401',
+]

repyability-0.5.0/repyability/__init__.py

@@ -0,0 +1,55 @@
+"""RePyability — reliability engineering tools for Python.
+
+The most commonly used classes are re-exported here so they can be imported
+directly from the top-level package, e.g.::
+
+    from repyability import NonRepairableRBD, StandbyModel
+"""
+
+from repyability._version import __version__
+from repyability.maintenance import MaintenancePolicy
+from repyability.non_repairable import NonRepairable
+from repyability.rbd.helper_classes import (
+    PerfectReliability,
+    PerfectUnreliability,
+)
+from repyability.rbd.non_repairable_rbd import NonRepairableRBD
+from repyability.rbd.rbd import RBD
+from repyability.rbd.repairable_rbd import RepairableRBD
+from repyability.rbd.repeated_node import RepeatedNode
+from repyability.rbd.repeated_standby_node import RepeatedStandbyNode
+from repyability.rbd.results import (
+    AvailabilityResult,
+    ConfidenceInterval,
+    Criticalities,
+    FailureCriticalityIndex,
+    RestorationCriticalityIndex,
+    UpDownImportance,
+)
+from repyability.rbd.standby_node import StandbyModel
+from repyability.repairable import Repairable
+
+__all__ = [
+    "__version__",
+    # System models
+    "RBD",
+    "NonRepairableRBD",
+    "RepairableRBD",
+    # Component models
+    "NonRepairable",
+    "Repairable",
+    "StandbyModel",
+    "RepeatedNode",
+    "RepeatedStandbyNode",
+    # Helpers
+    "PerfectReliability",
+    "PerfectUnreliability",
+    # Result types
+    "AvailabilityResult",
+    "ConfidenceInterval",
+    "Criticalities",
+    "UpDownImportance",
+    "FailureCriticalityIndex",
+    "RestorationCriticalityIndex",
+    "MaintenancePolicy",
+]

repyability-0.5.0/repyability/_version.py

@@ -0,0 +1,8 @@
+"""Single source of truth for the package version.
+
+Kept deliberately free of imports so the build backend can read
+``__version__`` statically (without importing the package and its
+dependencies) via ``[tool.setuptools.dynamic]`` in ``pyproject.toml``.
+"""
+
+__version__ = "0.5.0"

repyability-0.5.0/repyability/maintenance.py

@@ -0,0 +1,28 @@
+"""Shared result types for component maintenance-policy optimisations."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class MaintenancePolicy:
+    """An optimal preventive-maintenance policy for a single component.
+
+    Returned by ``NonRepairable.optimal_replacement_policy()`` (age
+    replacement) and ``Repairable.optimal_overhaul_policy()`` (overhaul
+    under minimal repair).
+
+    Attributes
+    ----------
+    interval : float
+        The optimal preventive interval: the replacement age for an
+        age-replacement policy, or the overhaul interval for a
+        minimal-repair component. ``inf`` when preventive action never
+        pays (run to failure / never overhaul).
+    cost_rate : float
+        The long-run cost per unit time under the policy. When
+        ``interval`` is ``inf`` this is the limiting cost rate of running
+        without preventive action.
+    """
+
+    interval: float
+    cost_rate: float

repyability-0.5.0/repyability/non_repairable.py

@@ -0,0 +1,227 @@
+import numpy as np
+from scipy.integrate import quad
+from scipy.interpolate import interp1d
+from scipy.optimize import minimize
+from surpyval import ExactEventTime, NonParametric, Parametric
+
+from repyability.maintenance import MaintenancePolicy
+from repyability.rbd._model_utils import (
+    distribution_name,
+    is_exponential,
+    model_mean,
+)
+from repyability.rbd.standby_node import StandbyModel
+
+FAILURE = 1
+REPLACE = 0
+
+
+class NonRepairable:
+    """A component renewed by replacement ("as good as new").
+
+    Pairs a lifetime (reliability) model with a time-to-replace model for
+    a unit that cannot be repaired in place: every failure or planned
+    replacement fits a new unit, so each cycle is a statistical renewal.
+
+    It plays two roles:
+
+    - Standalone, it prices the classic *age-replacement* policy — replace
+      preventively at age ``t`` (planned, cost ``cp``) or on failure
+      (unplanned, cost ``cu > cp``) — via ``find_optimal_replacement()``
+      and ``optimal_replacement_policy()``.
+    - Inside ``RepairableRBD``, it is the per-component representation
+      used by the availability engine (components are "repaired" by as-new
+      replacement, which is exactly the renewal this class models).
+
+    Contrast with ``Repairable``, which models *minimal repair* ("as bad
+    as old") and the overhaul-interval policy.
+    """
+
+    def __init__(
+        self, reliability, time_to_replace=ExactEventTime.from_params(0)
+    ):
+        if isinstance(reliability, Parametric):
+            self.model_parameterization = "parametric"
+            self.reliability_function = reliability.sf
+        elif isinstance(reliability, NonParametric):
+            # TODO: Allow non-interpolated?
+            self.model_parameterization = "non-parametric"
+            self.reliability_function = interp1d(
+                reliability.x, 1 - reliability.F, fill_value="extrapolate"
+            )
+        elif isinstance(reliability, StandbyModel):
+            self.model_parameterization = "non-parametric"
+            self.reliability_function = interp1d(
+                reliability.model.x,
+                1 - reliability.model.F,
+                fill_value="extrapolate",
+            )
+        else:
+            raise ValueError("Unknown reliability function")
+
+        self.reliability = reliability
+        self.time_to_replace = time_to_replace
+        self.cost_rate = np.vectorize(
+            self._cost_rate,
+            doc=(
+                "Long-run cost per unit time of an age-replacement policy "
+                "with replacement age t:\n"
+                "(cp * R(t) + cu * F(t)) / integral_0^t R(u) du.\n"
+                "Vectorised over t."
+            ),
+        )
+        self.__next_event_type = FAILURE
+
+    def set_costs_planned_and_unplanned(self, cp, cu):
+        if cp >= cu:
+            raise ValueError("Planned costs must be less than unplanned costs")
+        self.cp = cp
+        self.cu = cu
+
+    def avg_replacement_time(self, t):
+        if self.model_parameterization == "parametric":
+            out = quad(self.reliability_function, 0, t)[0]
+        else:
+            mask = self.reliability.x < t
+            x_less_than_t = self.reliability.x[mask]
+            dt = np.diff(x_less_than_t)
+            F = self.reliability_function(x_less_than_t[1:])
+            out = (dt * F).sum()
+
+        return out
+
+    def _cost_rate(self, t):
+        # surpyval >= 0.11 returns 1-element arrays from sf/mean/qf, and t can
+        # arrive as a 1-element array from scipy.optimize.minimize. Coerce to a
+        # plain float so the quadrature bound in avg_replacement_time() is a
+        # scalar (scipy.integrate.quad rejects array bounds).
+        t = float(np.asarray(t).item())
+        planned_costs = self.reliability_function(t) * self.cp
+        unplanned_costs = (1 - self.reliability_function(t)) * self.cu
+        avg_repl_time = self.avg_replacement_time(t)
+        return (planned_costs + unplanned_costs) / avg_repl_time
+
+    def _log_cost_rate(self, t):
+        return np.log(self._cost_rate(t))
+
+    def mean_unavailability(self) -> float:
+        return 1 - self.mean_availability()
+
+    def mean_availability(self) -> float:
+        """Long-run availability, MTTF / (MTTF + MTTR)."""
+        if isinstance(self.reliability, NonParametric):
+            raise ValueError(
+                "Mean Availability requires a parametric reliability model"
+            )
+        mttf = model_mean(self.reliability)
+        mttr = model_mean(self.time_to_replace)
+        return mttf / (mttr + mttf)
+
+    def failure_frequency(self) -> float:
+        """Long-run failure frequency (failures per unit time).
+
+        For an alternating renewal process (fail, repair, fail, ...) this is
+        ``1 / (MTTF + MTTR)`` — one failure per mean up-down cycle.
+        """
+        if isinstance(self.reliability, NonParametric):
+            raise ValueError(
+                "Failure frequency requires a parametric reliability model"
+            )
+        mttf = model_mean(self.reliability)
+        mttr = model_mean(self.time_to_replace)
+        return 1.0 / (mttf + mttr)
+
+    def _cost_rate_with_log_x(self, x):
+        return self._cost_rate(np.exp(x))
+
+    def _log_cost_rate_with_log_x(self, x):
+        return self._cost_rate(np.exp(x))
+
+    def find_optimal_replacement(self, options=None):
+        if self.model_parameterization == "parametric":
+            if is_exponential(self.reliability) and not (
+                getattr(self.reliability, "offset", False)
+                or getattr(self.reliability, "zi", False)
+                or getattr(self.reliability, "lfp", False)
+            ):
+                # Memoryless lifetime: an old unit is statistically as good
+                # as a new one, so preventive replacement never pays.
+                return np.inf
+            if distribution_name(self.reliability) == "Weibull":
+                if self.reliability.offset:
+                    pass
+                elif self.reliability.zi:
+                    pass
+                elif self.reliability.lfp:
+                    pass
+                elif self.reliability.params[1] <= 1:
+                    return np.inf
+            # When using a parametric distribution the optimisation is
+            # straight forward. Simply find the point in the support where
+            # the cost rate is minimised. Uses quadrature to integrate!
+            mean = self.reliability.mean()
+            old_err_state = np.seterr(all="ignore")
+            res = minimize(self._cost_rate_with_log_x, np.log(mean), tol=1e-10)
+            res_log = minimize(
+                self._log_cost_rate_with_log_x, np.log(mean), tol=1e-10
+            )
+            np.seterr(**old_err_state)
+            self.optimisation_results = res
+            if res["fun"] < np.exp(res_log["fun"]):
+                optimal = np.exp(res.x[0])
+            else:
+                optimal = np.exp(res_log.x[0])
+        else:
+            # When using non-parametric estimations, it can also be straight
+            # forward. Simply find the cost rate at a number of places
+            # from the min to the max support of the model and return the
+            # value of x which has the minimum cost rate.
+            x_search = np.linspace(
+                self.reliability.x.min(), self.reliability.x.max(), 10000
+            )
+
+            dt = np.diff(x_search, prepend=0)
+            R = self.reliability_function(x_search)
+            avg_replacement_times = (dt * R).cumsum()
+
+            planned_costs = R * self.cp
+            unplanned_costs = (1 - R) * self.cu
+
+            costs = (planned_costs + unplanned_costs) / avg_replacement_times
+
+            optimal_idx = np.argmin(costs)
+            optimal = x_search[optimal_idx]
+        return optimal
+
+    def optimal_replacement_policy(self) -> MaintenancePolicy:
+        """The optimal age-replacement policy as a typed result.
+
+        Returns a ``MaintenancePolicy`` whose ``interval`` is the
+        cost-optimal replacement age and whose ``cost_rate`` is the
+        long-run cost per unit time under it. When preventive replacement
+        never pays (no aging — e.g. an exponential lifetime, or a Weibull
+        with shape <= 1) the interval is ``inf`` and the cost rate is the
+        run-to-failure rate ``cu / MTTF``.
+        """
+        if not hasattr(self, "cp"):
+            raise ValueError(
+                "costs not set: call set_costs_planned_and_unplanned"
+                "(cp, cu) first"
+            )
+        interval = self.find_optimal_replacement()
+        if np.isinf(interval):
+            rate = self.cu / model_mean(self.reliability)
+        else:
+            rate = float(self._cost_rate(interval))
+        return MaintenancePolicy(interval=float(interval), cost_rate=rate)
+
+    def reset(self):
+        self.__next_event_type = FAILURE
+
+    def next_event(self):
+        if self.__next_event_type == FAILURE:
+            self.__next_event_type = REPLACE
+            return self.reliability.random(1).item(), False
+        elif self.__next_event_type == REPLACE:
+            self.__next_event_type = FAILURE
+            return self.time_to_replace.random(1).item(), True

repyability-0.5.0/repyability/rbd/_model_utils.py

@@ -0,0 +1,59 @@
+"""Helpers describing the *capabilities* of the reliability models the RBD
+classes consume.
+
+Historically the RBD code branched on ``model.dist.name`` string literals
+(e.g. ``"FixedEventProbability"``, ``"Exponential"``) scattered across several
+modules. That couples behaviour tightly to surpyval's internal naming: a
+rename there silently changes results here. Centralising the checks in these
+small helpers keeps that coupling in one place (easy to audit and to cover
+with a compatibility test) and gives the call sites intention-revealing names.
+"""
+
+from typing import Optional
+
+import numpy as np
+
+# surpyval distribution names whose event probability does not vary with time,
+# i.e. ``sf(t)`` is constant. These behave as fixed per-demand probabilities
+# rather than lifetime distributions.
+FIXED_PROBABILITY_DIST_NAMES = frozenset(
+    {"FixedEventProbability", "Bernoulli"}
+)
+
+
+def distribution_name(model) -> Optional[str]:
+    """Return the surpyval distribution name of ``model``.
+
+    Returns ``None`` for models that do not expose a surpyval distribution
+    (e.g. a ``StandbyModel``, ``RepeatedNode``, nested RBD, or the perfect
+    reliability/unreliability helpers).
+    """
+    dist = getattr(model, "dist", None)
+    if dist is None:
+        return None
+    return getattr(dist, "name", None)
+
+
+def is_fixed_probability(model) -> bool:
+    """True if ``model`` is a time-invariant (fixed) event probability."""
+    return distribution_name(model) in FIXED_PROBABILITY_DIST_NAMES
+
+
+def is_exponential(model) -> bool:
+    """True if ``model`` is a surpyval Exponential distribution."""
+    return distribution_name(model) == "Exponential"
+
+
+def model_mean(model) -> float:
+    """The model's mean as a plain float.
+
+    Works around surpyval 0.11's ExactEventTime, whose ``mean()`` raises
+    AttributeError (its underlying dist has no ``mean``); for an exact event
+    time the mean is simply its parameter.
+    """
+    try:
+        return float(np.atleast_1d(model.mean())[0])
+    except AttributeError:
+        if distribution_name(model) == "ExactEventTime":
+            return float(np.atleast_1d(model.params)[0])
+        raise