guts-base 0.8.6__py3-none-any.whl → 1.0.0__py3-none-any.whl

guts_base/sim/ecx.py

@@ -9,39 +9,57 @@ from matplotlib import pyplot as plt
 from tqdm import tqdm
 
 from pymob import SimulationBase
+from guts_base.sim.utils import GutsBaseError
 
 class ECxEstimator:
     """Estimates the exposure level that corresponds to a given effect. The algorithm 
-    operates by varying a given exposure profile (x_in)
+    operates by varying a given exposure profile (x_in). For each new estimation, a new
+    estimator is initialized.
+
+    Parameters
+    ----------
+
+    sim : SimulationBase
+        This must be a pymob.SimulationBase object. If the ECxEstimator.estimate method
+        is used with the modes 'draw' or 'mean'    
+    
     """
     _name = "EC"
+    _parameter_msg = (
+        "Manual estimation (mode='manual', without using posterior information) requires " +
+        "specification of parameters={...}. You can obtain and modify " +
+        "parameters using the pymob API: `sim.config.model_parameters.value_dict` " +
+        "returns a dictionary of DEFAULT PARAMETERS that you can customize to your liking " +
+        "(https://pymob.readthedocs.io/en/stable/api/pymob.sim.html#pymob.sim.config.Modelparameters.value_dict)."
+    )                
 
     def __init__(
         self, 
         sim: SimulationBase, 
         effect: str, 
-        x: float=0.5,
-        id: Optional[str]=None, 
-        time: Optional[float]=None, 
-        x_in: Optional[xr.Dataset]=None, 
+        x: float,
+        time: float, 
+        x_in: xr.Dataset, 
     ):
         self.sim = sim.copy()
         self.time = time
         self.x = x
-        self.id = id
         self.effect = effect
         self._mode = None
 
-        if id is None:
-            self.sim.coordinates["id"] = [self.sim.coordinates["id"][0]]
-        else:
-            self.sim.coordinates["id"] = [id]
+        # creates an empty observation dataset with the coordinates of the
+        # original observations (especially time), except the ID, which is overwritten
+        # and taken from the x_in dataset
+        pseudo_obs = self.sim.observations.isel(id=[0])
+        pseudo_obs = pseudo_obs.drop(["exposure","survival"])
+        pseudo_obs["id"] = x_in["id"]
+        
+        self.sim.config.data_structure.survival.observed = False
+        self.sim.observations = pseudo_obs
 
         # ensure correct coordinate order with x_in and raise errors early
         self.sim.model_parameters["x_in"] = self.sim.parse_input("x_in", x_in)
 
-        self.sim.config.data_structure.survival.observed = False
-        self.sim.observations = self.sim.observations.sel(id=self.sim.coordinates["id"])
 
         # fix time after observations have been set. The outcome of the simulation
         # can dependend on the time vector, because in e.g. IT models, the time resolution
@@ -63,6 +81,19 @@ class ECxEstimator:
             "msg": np.nan
         })
 
+        self.figure_profile_and_effect = None
+        self.figure_loss_curve = None
+
+
+    def _assert_posterior(self):
+        try:
+            p = self.sim.inferer.idata.posterior
+        except AttributeError:
+            raise GutsBaseError(
+                "Using mode='mode' or mode='draws', but sim did not contain a posterior. " + 
+                "('sim.inferer.idata.posterior'). " + self._parameter_msg
+            )
+
 
     
     def _evaluate(self, factor, theta):
@@ -95,25 +126,128 @@ class ECxEstimator:
         sample = {k: v["data"] for k, v in sample.to_dict()["data_vars"].items()}
         return sample
 
-    def plot_loss_curve(self):
-        posterior_mean = self._posterior_mean()
+    def plot_loss_curve(self, 
+        mode: Literal["draws", "mean", "manual"] = "draws", 
+        draws: Optional[int] = None, 
+        parameters: Optional[Dict[str,float|List[float]]] = None,
+        log_x0: float = 0.0, 
+        force_draws: bool = False
+    ):
+        """
+        Parameters
+        ----------
+
+        mode : Literal['draws', 'mean', 'manual']
+            mode of estimation. mode='mean' takes the mean of the posterior and estimate
+            the ECx for this singular value. mode='draws' takes samples from the posterior
+            and estimate the ECx for each of the parameter draws. mode='manual' takes
+            a parameter set (Dict) in the parameters argument and uses that for estimation. 
+            Default: 'draws'
+        
+        draws : int
+            Number of draws to take from the posterior. Only takes effect if mode='draw'.
+            Raises an exception if draws < 100, because this is insufficient for a 
+            reasonable uncertainty estimate. Default: None (using all samples from the
+            posterior)
+        
+        parameters : Dict[str,float|list[float]]
+            a parameter dictionary passed used as model parameters for finding the ECx
+            value. Default: None
+
+        
+        log_x0 : float
+            the starting value for the multiplication factor of the exposure profile for
+            the minimization algorithm. This value is on the log scale. This means, 
+            exp(log_x0=0.0) = 1.0, which means that the log_x0=0.0 will start at an
+            unmodified exposure profile. Default: 0.0
+        
+        force_draws : bool
+            Force the estimate method to accept a number of draws less than 100. Default: False
+
+        """
+        draws = self._check_mode_and_draws_and_parameters(mode, draws, parameters, force_draws)
 
-        factor = np.linspace(-2,2, 100)
-        y = list(map(partial(self._loss, theta=posterior_mean), factor))
 
+        factor = np.linspace(-2,2, 100) + log_x0
         fig, ax = plt.subplots(1,1, sharey=True, figsize=(4, 3))
+        
+        for i in tqdm(range(draws)):
+            if mode == "draws":
+                sample = self._posterior_sample(i)
+            elif mode == "mean":
+                sample = self._posterior_mean()
+            elif mode == "manual":
+                sample = parameters
+            else: 
+                raise NotImplementedError(
+                    f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"
+                )
+            
+            y = list(map(partial(self._loss, theta=sample), factor))
+
+            ax.plot(
+                np.exp(factor), y, 
+                color="black",
+            )
+
         ax.plot(
-            np.exp(factor), y, 
-            color="black",
+            [], [], color="black",
             label=f"$\ell = S(t={self.time},x_{{in}}=C_{{ext}} \cdot \phi) - {self.x}$"
         )
         ax.set_ylabel("Loss ($\ell$)")
         ax.set_xlabel("Multiplication factor ($\phi$)")
         ax.set_title(f"ID: {self.sim.coordinates['id'][0]}")
-        ax.set_ylim(0, np.max(y) * 1.25)
+        ax.set_ylim(0, ax.get_ylim()[1] * 1.25)
         ax.legend(frameon=False)
         fig.tight_layout()
 
+        self.figure_loss_curve = fig
+
+    def _check_mode_and_draws_and_parameters(self, mode, draws, parameters, force_draws):
+
+        if mode == "draws":
+            self._assert_posterior()
+
+            if draws is None:
+                draws = (
+                    self.sim.inferer.idata.posterior.sizes["chain"] * 
+                    self.sim.inferer.idata.posterior.sizes["draw"]
+                )
+            elif draws < 100 and not force_draws:
+                raise GutsBaseError(
+                    "draws must be larger than 100. Preferably > 1000. " +
+                    f"If you don't want uncertainty assessment of the {self._name} " +
+                    "estimates, use mode='mean'. If you really want to use less than " +
+                    "100 draws, use force_draws=True at your own risk."
+                )
+            else:
+                pass
+            
+            warnings.warn(
+                "Values passed to 'parameters' don't have an effect in mode='draws'"
+            )
+
+        elif mode == "mean":
+            self._assert_posterior()
+
+            draws = 1
+
+            warnings.warn(
+                "Values passed to 'parameters' don't have an effect in mode='draws'"
+            )
+
+        elif mode == "manual":
+            draws = 1
+            if parameters is None:
+                raise GutsBaseError(self._parameter_msg)
+        else:
+            raise GutsBaseError(
+                f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"
+            )
+
+        return draws
+
+
     def estimate(
         self, 
         mode: Literal["draws", "mean", "manual"] = "draws", 
@@ -124,6 +258,7 @@ class ECxEstimator:
         optimizer_tol: float = 1e-5,
         method: str = "cobyla", 
         show_plot: bool = True,
+        force_draws: bool = False,
         **optimizer_kwargs
     ):
         """The minimizer for the EC_x operates on the unbounded linear scale, estimating 
@@ -177,48 +312,15 @@ class ECxEstimator:
         show_plot : bool
             Show the results plot of the lpx. Default: True
         
+        force_draws : bool
+            Force the estimate method to accept a number of draws less than 100. Default: False
+
         optimizer_kwargs :
             Additional arguments to pass to the optimizer
 
         """
         x0_tries = np.array([0.0, -1.0, 1.0, -2.0, 2.0]) + log_x0
-
-        if mode == "draws":
-            if draws is None:
-                draws = (
-                    self.sim.inferer.idata.posterior.sizes["chain"] * 
-                    self.sim.inferer.idata.posterior.sizes["draw"]
-                )
-            elif draws < 100:
-                raise ValueError(
-                    "draws must be larger than 100. Preferably > 1000. "
-                    f"If you don't want uncertainty assessment of the {self._name} "
-                    "estimates, use mode='mean'"
-                )
-            else:
-                pass
-            
-            warnings.warn(
-                "Values passed to 'parameters' don't have an effect in mode='draws'"
-            )
-
-        elif mode == "mean":
-            draws = 1
-
-            warnings.warn(
-                "Values passed to 'parameters' don't have an effect in mode='draws'"
-            )
-
-        elif mode == "manual":
-            draws = 1
-            if parameters is None:
-                raise ValueError(
-                    "parameters need to be provided if mode='manual'"
-                )
-        else:
-            raise NotImplementedError(
-                f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"
-            )
+        draws = self._check_mode_and_draws_and_parameters(mode, draws, parameters, force_draws)
 
         self._mode = mode
         mult_factor = []
@@ -310,7 +412,7 @@ class ECxEstimator:
         self.sim.dispatch_constructor()
 
         if self._mode is None:
-            raise RuntimeError(
+            raise GutsBaseError(
                 "Run .estimate() before plot_profile_and_effect()"
             )
         elif self._mode == "mean" or self._mode == "draws":
@@ -375,6 +477,8 @@ class ECxEstimator:
         ax2.set_ylim(0, None)
         fig.tight_layout()
 
+        self.figure_profile_and_effect = fig
+
         self.sim.coordinates["time"] = coordinates_backup
         self.sim.dispatch_constructor()
 
@@ -396,4 +500,10 @@ class LPxEstimator(ECxEstimator):
     ):
         x_in = sim.model_parameters["x_in"].sel(id=[id])
         time = sim.coordinates["time"][-1]
-        super().__init__(sim=sim, effect="survival", x=x, id=id, time=time, x_in=x_in)
+        super().__init__(
+            sim=sim, 
+            effect="survival", 
+            x=x, 
+            time=time, 
+            x_in=x_in
+        )

guts_base/sim/mempy.py

@@ -1,44 +1,64 @@
 import pathlib
-from typing import Dict, Optional, Literal
+from typing import Dict, Optional, Literal, Protocol, TypedDict, List
 import re
-
+import os
 import numpy as np
 import pandas as pd
 import xarray as xr
-from pymob import SimulationBase
 from pymob.sim.config import Config, DataVariable, Datastructure
 from pymob.sim.parameters import Param
 from guts_base.sim import GutsBase
-from mempy.model import (
-    Model, 
-    RED_IT, 
-    RED_SD,
-    RED_IT_DA,
-    RED_SD_DA,
-    RED_IT_IA,
-    RED_SD_IA,
-    BufferGUTS_IT,
-    BufferGUTS_IT_CA,
-    BufferGUTS_IT_DA
-)
 
 __all__ = [
     "PymobSimulator",
 ]
 
+class ParamsInfoDict(TypedDict):
+    name: str
+    min: float
+    max: float
+    initial: float
+    vary: bool
+    prior: str
+
+class StateVariablesDict(TypedDict):
+    dimensions: List[str]
+    observed: bool
+    y0: List[float]
+
+class Model(Protocol):
+    extra_dim: Optional[str]
+    params_info: Dict[str, ParamsInfoDict]
+    state_variables: Dict[str, StateVariablesDict]
+    _params_info_defaults: Dict[str, ParamsInfoDict]
+    _it_model: bool
+
+    @staticmethod
+    def _rhs_jax():
+        raise NotImplementedError
+        
+    @staticmethod
+    def _solver_post_processing():
+        raise NotImplementedError
+
+    @staticmethod
+    def _likelihood_func_jax():
+        raise NotImplementedError
+
+
 class PymobSimulator(GutsBase):
 
     @classmethod
-    def from_mempy(
+    def from_model_and_dataset(
         cls,
-        exposure_data: Dict,
-        survival_data: Dict,
         model: Model,
+        exposure_data: Dict[str, pd.DataFrame],
+        survival_data: pd.DataFrame,
         info_dict: Dict = {},
         pymob_config: Optional[Config] = None,
         output_directory: str|pathlib.Path = pathlib.Path("output/pymob"),
         default_prior: Literal["uniform", "lognorm"] = "lognorm",
-    ) -> SimulationBase:
+    ) -> "PymobSimulator":
         """Construct a PymobSimulator from the 
         """
 
@@ -46,7 +66,7 @@ class PymobSimulator(GutsBase):
             cfg = Config()
             # Configure: The configuration can be overridden in a subclass to override the 
             # configuration
-            cls.configure(config=cfg)
+            cls._configure(config=cfg)
         else:
             cfg = pymob_config
 
@@ -55,6 +75,14 @@ class PymobSimulator(GutsBase):
 
         cfg.case_study.output = str(output_directory)
 
+        # overrides scenario path. This means the scenario is also expected in the
+        # same folder
+        cfg.case_study.scenario_path_override = str(output_directory)
+        cfg.case_study.scenario = output_directory.stem
+        cfg.case_study.data = cfg.case_study.output_path
+        cfg.case_study.observations = "observations.nc"
+        cfg.create_directory(directory="results", force=True)
+        
         # parse observations
         # obs can be simply subset by selection obs.sel(substance="Exposure-Dime")
         observations = xr.combine_by_coords([
@@ -62,9 +90,19 @@ class PymobSimulator(GutsBase):
             cls._survival_data_to_xarray(survival_data)
         ])
 
+        observations.to_netcdf(
+            os.path.join(cfg.case_study.output_path, cfg.case_study.observations)
+        )
+
         # configure model and likelihood function
-        cfg.simulation.model = type(model).__name__
-        cfg.inference_numpyro.user_defined_error_model = str(model._likelihood_func_jax.__name__)
+        # extract the fully qualified name of the model module.name
+        cfg.simulation.model_class = "{module}.{name}".format(
+            module=model.__module__, name=type(model).__name__
+        )
+        cfg.inference_numpyro.user_defined_error_model = "{module}.{name}".format(
+            module=model._likelihood_func_jax.__module__, 
+            name=model._likelihood_func_jax.__name__
+        )
 
         # derive data structure and params from the model instance
         cls._set_data_structure(config=cfg, model=model)
@@ -75,35 +113,37 @@ class PymobSimulator(GutsBase):
         cfg.simulation.y0 = [f"{k}={v['y0']}" for k, v in model.state_variables.items() if "y0" in v]
 
         # create a simulation object
+        # It is essential that all post processing tasks are done in self.setup()
+        # which is extended below. This ensures that the simulation can also be run
+        # from automated tools like pymob-infer
         sim = cls(config=cfg)
-        sim.config.create_directory(directory="results", force=True)
-
-        # initialize
-        sim.load_modules()
-        sim.set_logger()
-
-        sim.initialize(input={"observations": observations, "model": model})
-        
-        sim.validate()
-        sim.dispatch_constructor()
-
-
+        sim.setup()
         return sim
 
-    def initialize(self, input=None):
-        self.model = input["model"]._rhs_jax
-        self.solver_post_processing = input["model"]._solver_post_processing
+    def reset_observations(self):
+        """Resets the observations to the original observations after using .from_mempy(...)
+        This also resets the sim.coordinates dictionary.
+        """
+
+        self.observations = self._obs_backup
 
-        super().initialize(input=input)
+    def setup(self, **evaluator_kwargs):
+        super().setup(**evaluator_kwargs)
+        self._obs_backup = self.observations.copy(deep=True)
 
 
     @classmethod
-    def configure(cls, config: Config):
+    def _configure(cls, config: Config):
         """This is normally set in the configuration file passed to a SimulationBase class.
         Since the mempy to pymob converter initializes pymob.SimulationBase from scratch
         (without using a config file), the necessary settings have to be specified here.
         """
         config.case_study.output = "results"
+        config.case_study.simulation = "PymobSimulator"
+
+        # this must be named guts_base,  whihc is the name of the pip package and
+        # this regulates which packages are loaded.
+        config.case_study.name = "guts_base"
 
         config.simulation.x_dimension = "time"
         config.simulation.batch_dimension = "id"
@@ -132,33 +172,6 @@ class PymobSimulator(GutsBase):
         config.inference_numpyro.svi_iterations = 10_000
         config.inference_numpyro.svi_learning_rate = 0.001
 
-    @staticmethod
-    def _exposure_data_to_xarray(exposure_data: Dict[str, pd.DataFrame], dim: str):
-        """
-        TODO: Currently no rect interpolation
-        """
-        arrays = {}
-        for key, df in exposure_data.items():
-            # this override is necessary to make all dimensions work out
-            df.index.name = "time"
-            arrays.update({
-                key: df.to_xarray().to_dataarray(dim="id", name=key)
-            }) 
-
-        exposure_array = xr.Dataset(arrays).to_array(dim=dim, name="exposure")
-        exposure_array = exposure_array.transpose("id", "time", ...)
-        return xr.Dataset({"exposure": exposure_array})
-
-    @staticmethod
-    def _survival_data_to_xarray(survival_data: pd.DataFrame):
-        # TODO: survival name is currently not kept because the raw data is not transferred from the survival
-        survival_data.index.name = "time"
-        
-        survival_array = survival_data.to_xarray().to_dataarray(dim="id", name="survival")
-        survival_array = survival_array.transpose("id", "time", ...)
-        arrays = {"survival": survival_array}
-        return xr.Dataset(arrays)
-
     @classmethod
     def _set_data_structure(cls, config: Config, model: Model):
         """Takes a dictionary that is specified in the model and uses only keys that
@@ -179,10 +192,7 @@ class PymobSimulator(GutsBase):
     def _set_params(cls, config: Config, model: Model, default_prior: str):
         params_info = model.params_info
 
-        if isinstance(model, (
-            RED_IT, RED_IT_DA, RED_IT_IA, 
-            BufferGUTS_IT, BufferGUTS_IT_CA, BufferGUTS_IT_DA
-        )):
+        if model._it_model:
             eps = config.jaxsolver.atol * 10
             params_info["eps"] = {'name':'eps', 'initial':eps, 'vary':False}
 
@@ -210,6 +220,11 @@ class PymobSimulator(GutsBase):
             _init = group["initial"].values.astype(float)
             _free = group["vary"].values
 
+            if isinstance(_min, np.ma.core.MaskedConstant):
+                _min = None
+            if isinstance(_max, np.ma.core.MaskedConstant):
+                _max = None
+            
             # TODO: allow for parsing one N-D prior from multiple priors
             # TODO: Another choice would be to parse vary=False priors as deterministic
             #       and use a composite prior from a deterministic and a free prior as

guts_base/sim/report.py

@@ -52,7 +52,6 @@ class GutsReport(Report):
                 sim=sim,
                 effect="survival", 
                 x=row.x,
-                id=None, 
                 time=row.time, 
                 x_in=P[row.scenario], 
             )

guts_base/sim/utils.py

@@ -0,0 +1,10 @@
+class GutsBaseError(Exception):
+    """Exception raised for custom error scenarios.
+
+    Attributes:
+        message -- explanation of the error
+    """
+
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

{guts_base-0.8.6.dist-info → guts_base-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 0.8.6
+Version: 1.0.0
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -692,8 +692,7 @@ License-File: LICENSE
 Requires-Dist: openpyxl>=3.1.3
 Requires-Dist: Bottleneck>=1.5.0
 Requires-Dist: expydb>=0.6.0
-Requires-Dist: mempyguts>=1.5.0
-Requires-Dist: pymob[interactive,numpyro]<0.6.0,>=0.4.1
+Requires-Dist: pymob[interactive,numpyro]<0.6.0,>=0.5.10
 Provides-Extra: dev
 Requires-Dist: pytest>=7.3; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

guts_base-1.0.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+guts_base/__init__.py,sha256=ulUbdy3eks46Fl2VAVRRymWiAmzDOj_pqRCBpItSnMI,227
+guts_base/mod.py,sha256=AzOCg1A8FP5EtVfp-66HT7G7h_wnHkenieaxTc9qCyk,5796
+guts_base/plot.py,sha256=rjIzyPUikOtubjWI5mX_ZY8ARWl2NiHDmwAZAdoaPS8,5693
+guts_base/prob.py,sha256=ITwo5dAGMHr5xTldilHMbKU6AFsWo4_ZwbfaXh97Gew,5443
+guts_base/data/__init__.py,sha256=JBgft1DTledwvB5hRZnyGiKWv-RXo1OIpb5kJXloOmo,826
+guts_base/data/expydb.py,sha256=Kcc6CeZMl3oEelk5UBN9VEfwgNF3CzTh13ooVkufAjE,8218
+guts_base/data/generator.py,sha256=rGOZU3B0Ho8V6KtfjcAmely8lnlqNFV8cRyGboayTRc,2910
+guts_base/data/openguts.py,sha256=WvhYl_AOdvNgzrcVS2f_PYbXNH_wSAz2uIBSR6BMSh0,11078
+guts_base/data/preprocessing.py,sha256=qggYkx2x62ingU1BNhJFyL1eQdFQsDJR2lefVfVWW2U,1732
+guts_base/data/survival.py,sha256=U-Ehloo8vnD81VeIglXLEUHX9lt7SjtEs2YEB0D9FHE,5096
+guts_base/data/time_of_death.py,sha256=hwngUwfRP3u8WmD3dHyXrphuu5d8ZJTKyBovGRwAHNQ,21014
+guts_base/data/utils.py,sha256=u3gGDJK15MfRUP4iIxsS-I1oqxD2qH_ugsT7o_Eac18,236
+guts_base/sim/__init__.py,sha256=5VgzsOXjMsylfWy4neeovZBG1w6G6p_tFaIfhnIeLPM,415
+guts_base/sim/base.py,sha256=7u7gj6HQSCtFUXrrX-ngfWsWnFEMk5NrDVJH0CIolAs,28960
+guts_base/sim/constructors.py,sha256=Kz9FHIH3EHsSIKd9sQgHa3eveniFifFlk1Hf-QR69Pg,875
+guts_base/sim/ecx.py,sha256=F2ImQbtJjP57udebY2c_vtOf4gB3yKSje0P8s9VIbtQ,18858
+guts_base/sim/mempy.py,sha256=IHd87UrmdXpC7y7q0IjYQJH075frjbp2a-dMVBeqZ0U,10164
+guts_base/sim/report.py,sha256=swTAp1qNTjDwWh-YOq_TLqtSxjQvjdwaNVHpEW8kXK4,1959
+guts_base/sim/utils.py,sha256=Qj_FPH6kywVxOwgCerS7w5CyuYR9HKmvBWFpmxwDFgk,256
+guts_base-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+guts_base-1.0.0.dist-info/METADATA,sha256=g8sJM482NTXEGv7dJKbLVujO_sRzkpg3fuHadmDMdhc,45406
+guts_base-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guts_base-1.0.0.dist-info/entry_points.txt,sha256=icsHzG2jQ90ZS7XvLsI5Qj0-qGuPv2T0RBVN5daGCPU,183
+guts_base-1.0.0.dist-info/top_level.txt,sha256=PxhBgUd4r39W_VI4FyJjARwKbV5_glgCVnd6v_zAGdE,10
+guts_base-1.0.0.dist-info/RECORD,,

guts_base-0.8.6.dist-info/RECORD

@@ -1,24 +0,0 @@
-guts_base/__init__.py,sha256=dYv5zH5jYPdPZXIzku6YPkvB47XD8qaTlY-0olh-4cA,208
-guts_base/mod.py,sha256=aLb09E-6CwgKgq0GbwIT_Alv167cVFA5zAxwx80F1aE,7454
-guts_base/plot.py,sha256=rjIzyPUikOtubjWI5mX_ZY8ARWl2NiHDmwAZAdoaPS8,5693
-guts_base/prob.py,sha256=k1b-gc8yZNg8DMnxJHJzCy8Pud8_qEygGkrnmS2AcMY,14004
-guts_base/sim.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-guts_base/data/__init__.py,sha256=U5sJJgPwEVHVGTLeZNwl8VKLIgn1twpDNkOCMRSV1Nk,808
-guts_base/data/expydb.py,sha256=Kcc6CeZMl3oEelk5UBN9VEfwgNF3CzTh13ooVkufAjE,8218
-guts_base/data/generator.py,sha256=fos7y-xxTlBVpYsHD_2kdYSH40KILPUQ_Jy0mwjO5jc,2897
-guts_base/data/openguts.py,sha256=WvhYl_AOdvNgzrcVS2f_PYbXNH_wSAz2uIBSR6BMSh0,11078
-guts_base/data/preprocessing.py,sha256=qggYkx2x62ingU1BNhJFyL1eQdFQsDJR2lefVfVWW2U,1732
-guts_base/data/survival.py,sha256=yNNZ7MabzrMeqPHOa8-LPxCgsIN4_X0aj_ANmeC9Wd8,4878
-guts_base/data/time_of_death.py,sha256=hwngUwfRP3u8WmD3dHyXrphuu5d8ZJTKyBovGRwAHNQ,21014
-guts_base/data/utils.py,sha256=u3gGDJK15MfRUP4iIxsS-I1oqxD2qH_ugsT7o_Eac18,236
-guts_base/sim/__init__.py,sha256=vgZu2oi4RHIQuLS19570xBdLQasL75puxabGrbLuIGA,276
-guts_base/sim/base.py,sha256=lxfHQ57pXKz1ZGnFqOIoeUplzvFWM1OjDX0xYQpSgaw,20921
-guts_base/sim/ecx.py,sha256=IvZQnmMs3FLX6unuj7mPv2AaZ7l-S4TJmYmPI4fXE1k,14573
-guts_base/sim/mempy.py,sha256=xsA3Q7jQrdcmQZJzKBdQnr8yZk-f36YgbLlV-VvJpxg,9514
-guts_base/sim/report.py,sha256=D_6eoSvjdcsDtB0PlmNkzC1LRk_7WXzb_T6D6AZjQNE,1985
-guts_base-0.8.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-guts_base-0.8.6.dist-info/METADATA,sha256=n0OWLZd2CZWg7j7M2sqcXfFuiOSPqSG60KvQ9IuoqHM,45437
-guts_base-0.8.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guts_base-0.8.6.dist-info/entry_points.txt,sha256=icsHzG2jQ90ZS7XvLsI5Qj0-qGuPv2T0RBVN5daGCPU,183
-guts_base-0.8.6.dist-info/top_level.txt,sha256=PxhBgUd4r39W_VI4FyJjARwKbV5_glgCVnd6v_zAGdE,10
-guts_base-0.8.6.dist-info/RECORD,,