def parameters_deserializer(p_json: str):
values = loads(p_json)
result = Parameters(
current_hospitalized=values["current_hospitalized"],
hospitalized=Disposition(*values["hospitalized"]),
icu=Disposition(*values["icu"]),
relative_contact_rate=values["relative_contact_rate"],
ventilated=Disposition(*values["ventilated"]),
current_date=parse_date(values["current_date"]),
date_first_hospitalized=values["date_first_hospitalized"],
doubling_time=values["doubling_time"],
infectious_days=values["infectious_days"],
market_share=values["market_share"],
max_y_axis=values["max_y_axis"],
n_days=values["n_days"],
population=values["population"],
recovered=values["recovered"],
region=values["region"],
)
for key, value in values.items():
if result.__dict__[key] != value and key not in ("dispositions",
"hospitalized", "icu",
"ventilated",
"current_date"):
result.__dict__[key] = value
return result
def create_params_from_file(file):
"""
Create CHIME Parameters object from input config file
:param file:
:return:
"""
# Update sys.arg so we can call cli.parse_args()
sys.argv = [sys.argv[0], '--file', file]
a = cli.parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
infectious_days=a.infectious_days,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
population=a.population,
hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days),
icu=Disposition(a.icu_rate, a.icu_days),
ventilated=Disposition(a.ventilated_rate, a.ventilated_days),
)
if a.date_first_hospitalized is None:
p.doubling_time = a.doubling_time
else:
p.date_first_hospitalized = a.date_first_hospitalized
return p
def get_parameters_for_region(region_population,
region_cases,
num_days=60,
param_override=None):
if param_override is None:
param_override = {}
p = dict(
ChainMap(
{
# Hospital Market Share (0.00001 - 1.0)
"market_share": 1.0,
# Currently Known Regional Infections (>=0)
"known_infected": region_cases,
# Number of days to project >= 0
"n_days": num_days,
# Seems like a viz thing
"as_date": False,
},
DEFAULT_PARAMS,
param_override))
p['current_hospitalized'] = None # Unused for regional calculation
p['hospitalized'] = RateLos(p['hospitalized_rate'], p['hospitalized_los'])
del p['hospitalized_rate']
del p['hospitalized_los']
p['icu'] = RateLos(p['icu_rate'], p['icu_los'])
del p['icu_rate']
del p['icu_los']
p['ventilated'] = RateLos(p['ventilated_rate'], p['ventilated_los'])
del p['ventilated_rate']
del p['ventilated_los']
detection_probability = p['detection_probability']
del p['detection_probability']
p['population'] = region_population
chime_params = Parameters(**p)
chime_params.detection_probability = detection_probability
return chime_params
def update_parameters(i, *input_values) -> List[dict]:
"""Reads html form outputs and converts them to a parameter instance
Returns Parameters
"""
inputs_dict = SidebarCallbacks.get_formated_values(i, input_values)
dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None
dfh = inputs_dict["date_first_hospitalized"] if not dt else None
pars = Parameters(
current_hospitalized=inputs_dict["current_hospitalized"],
date_first_hospitalized=dfh,
doubling_time=dt,
hospitalized=Disposition.create(
days=inputs_dict["hospitalized_los"],
rate=inputs_dict["hospitalized_rate"] / 100,
),
icu=Disposition(
days=inputs_dict["icu_los"],
rate=inputs_dict["icu_rate"] / 100,
),
infectious_days=inputs_dict["infectious_days"],
market_share=inputs_dict["market_share"] / 100,
n_days=inputs_dict["n_days"],
population=inputs_dict["population"],
recovered=0, #FIXME input or pass through from defaults is required!
relative_contact_rate=inputs_dict["relative_contact_rate"] / 100,
ventilated=Disposition.create(
days=inputs_dict["ventilated_los"],
rate=inputs_dict["ventilated_rate"] / 100,
),
max_y_axis=inputs_dict.get("max_y_axis_value", None),
)
return [{"inputs_dict": inputs_dict, "parameters": parameters_serializer(pars)}]
def update_parameters(*input_values, **kwargs) -> List[str]:
"""Reads html form outputs and converts them to a parameter instance
Returns Parameters
"""
inputs_dict = Sidebar.get_formated_values(input_values)
dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None
dfh = inputs_dict["date_first_hospitalized"] if not dt else None
pars = Parameters(
population=inputs_dict["population"],
current_hospitalized=inputs_dict["current_hospitalized"],
date_first_hospitalized=dfh,
doubling_time=dt,
hospitalized=Disposition(
inputs_dict["hospitalized_rate"] / 100, inputs_dict["hospitalized_los"]
),
icu=Disposition(inputs_dict["icu_rate"] / 100, inputs_dict["icu_los"]),
infectious_days=inputs_dict["infectious_days"],
market_share=inputs_dict["market_share"] / 100,
n_days=inputs_dict["n_days"],
relative_contact_rate=inputs_dict["relative_contact_rate"] / 100,
ventilated=Disposition(
inputs_dict["ventilated_rate"] / 100, inputs_dict["ventilated_los"]
),
max_y_axis=inputs_dict.get("max_y_axis_value", None),
)
return [parameters_serializer(pars)]
def post_args():
args = request.json
args['hospitalized'] = RateLos(args['hospitalized_rate'],
args['hospitalized_los'])
args['icu'] = RateLos(args['icu_rate'], args['icu_los'])
args['ventilated'] = RateLos(args['ventilated_rate'],
args['ventilated_los'])
del args['hospitalized_rate']
del args['hospitalized_los']
del args['icu_rate']
del args['icu_los']
del args['ventilated_rate']
del args['ventilated_los']
p = Parameters(**args)
m = SimSirModel(p)
files = []
prefix = datetime.now().strftime("%Y.%m.%d.%H.%M.")
for df, name in (
(m.raw_df, "raw"),
(m.admits_df, "admits"),
(m.census_df, "census"),
):
filename = path.join(gettempdir(), prefix + name + ".csv")
df.to_csv(filename)
files.append(filename)
zipfilename = path.join(gettempdir(), prefix + 'result.zip')
with ZipFile(zipfilename, 'w') as zip:
for file in files:
zip.write(file, path.basename(file))
return send_file(zipfilename)
def main():
"""Main."""
my_args = parse_args()
my_args_dict = vars(my_args)
# Update sys.arg so we can call cli.parse_args()
sys.argv = [sys.argv[0], '--file', my_args_dict['file']]
a = cli.parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
date_first_hospitalized=a.date_first_hospitalized,
doubling_time=a.doubling_time,
infectious_days=a.infectious_days,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
population=a.population,
hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days),
icu=Disposition(a.icu_rate, a.icu_days),
ventilated=Disposition(a.ventilated_rate, a.ventilated_days),
)
m = Model(p)
for df, name in (
(m.sim_sir_w_date_df, "sim_sir_w_date"),
(m.admits_df, "projected_admits"),
(m.census_df, "projected_census"),
):
df.to_csv(f"{p.current_date}_{name}.csv")
def main():
"""Main."""
a = parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
doubling_time=a.doubling_time,
known_infected=a.known_infected,
market_share=a.market_share,
relative_contact_rate=a.relative_contact_rate,
susceptible=a.susceptible,
n_days=a.n_days,
hospitalized=RateLos(a.hospitalized_rate, a.hospitalized_los),
icu=RateLos(a.icu_rate, a.icu_los),
ventilated=RateLos(a.ventilated_rate, a.ventilated_los),
)
raw_df = DataFrame({
"Susceptible": p.susceptible_v,
"Infected": p.infected_v,
"Recovered": p.recovered_v,
})
admits_df = build_admissions_df(p)
census_df = build_census_df(admits_df, p)
prefix = a.prefix
for df, name in (
(raw_df, "raw"),
(admits_df, "admits"),
(census_df, "census"),
):
df.to_csv(prefix + name + ".csv")
def create_app(context: str = 'prod') -> DashAppInstance:
"""
create_app initializes the app instance
Args:
context (str, optional): One of either 'prod', 'dev', 'testing.
Defaults to 'prod' where dash.Dash.run_server(debug=False).
Change to 'dev' or 'test' to set debug to true.
Returns:
Env: Config variables based on context argument received
DashAppInstance: Dash instance with appropriate configuration settings
"""
Env = from_object(context)
LANGUAGE = Env.LANG
body = Root(
LANGUAGE,
Parameters.create(os.environ, []),
)
App = Dash(
__name__,
external_stylesheets=body.external_stylesheets,
external_scripts=body.external_scripts,
)
App.title = Env.CHIME_TITLE
App.layout = body.html
wrap_callbacks(App)
return Env, App
def main():
"""Main."""
a = parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
doubling_time=a.doubling_time,
known_infected=a.known_infected,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
susceptible=a.susceptible,
hospitalized=RateLos(a.hospitalized_rate, a.hospitalized_los),
icu=RateLos(a.icu_rate, a.icu_los),
ventilated=RateLos(a.ventilated_rate, a.ventilated_los),
)
m = SimSirModel(p)
prefix = a.prefix
for df, name in (
(m.raw_df, "raw"),
(m.admits_df, "admits"),
(m.census_df, "census"),
):
df.to_csv(prefix + name + ".csv")
def sim_chimes(scenarios: str, p: Parameters = None):
"""
Run many chime simulations.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None. These settings are just
for the base parameter values. We can run stuff over ranges as we see it.
:param scenarios:
:param params:
:return:
"""
base_input_params_dict = vars(p)
# Create a range of social distances
soc_dists = np.arange(0.05, 0.60, 0.05)
# array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, 0.6 ])
num_scenarios = len(soc_dists)
# We can store outputs any way we want. For this demo, just going to
# use a master list. # This will be a list of dicts of the
# result dataframes (+ 1 dict containing the scenario inputs)
results_list = []
for sd_pct in soc_dists:
sim_scenario = '{}{:.0f}'.format(scenarios, 100 * sd_pct)
# Update the parameters for this scenario
p.relative_contact_rate = sd_pct
input_params_dict = vars(p)
# Run the model
m = Model.SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
# Append results to results list
results_list.append(results.copy())
return results_list
def parse_form_parameters(**kwargs) -> Tuple[Parameters, Dict[str, Any]]:
"""Reads html form outputs and converts them to a parameter instance
Returns Parameters and as_date argument
"""
pars = Parameters(
current_hospitalized=kwargs["current_hospitalized"],
doubling_time=kwargs["doubling_time"],
known_infected=kwargs["known_infected"],
market_share=kwargs["market_share"] / 100,
relative_contact_rate=kwargs["relative_contact_rate"] / 100,
susceptible=kwargs["susceptible"],
hospitalized=RateLos(kwargs["hospitalized_rate"] / 100,
kwargs["hospitalized_los"]),
icu=RateLos(kwargs["icu_rate"] / 100, kwargs["icu_los"]),
ventilated=RateLos(kwargs["ventilated_rate"] / 100,
kwargs["ventilated_los"]),
max_y_axis=kwargs["max_y_axis_value"],
n_days=kwargs["n_days"],
)
return pars
def parameters_deserializer(p_json: str):
values = loads(p_json)
dates = {
key: parse_date(values[key]).date() if values[key] else None
for key in (
"current_date",
"date_first_hospitalized",
"mitigation_date",
)
}
return Parameters(
current_date=dates["current_date"],
current_hospitalized=values["current_hospitalized"],
hospitalized=Disposition.create(
days=values["hospitalized"][0],
rate=values["hospitalized"][1],
),
icu=Disposition.create(
days=values["icu"][0],
rate=values["icu"][1],
),
infectious_days=values["infectious_days"],
date_first_hospitalized=dates["date_first_hospitalized"],
doubling_time=values["doubling_time"],
market_share=values["market_share"],
max_y_axis=values["max_y_axis"],
mitigation_date=dates["mitigation_date"],
n_days=values["n_days"],
population=values["population"],
recovered=values["recovered"],
region=values["region"],
relative_contact_rate=values["relative_contact_rate"],
ventilated=Disposition.create(
days=values["ventilated"][0],
rate=values["ventilated"][1],
),
)
def sim_chimes(
scenarios: str,
params: Parameters = None,
current_hospitalized: int = None,
doubling_time: float = None,
known_infected: int = None,
relative_contact_rate: float = None,
susceptible: int = None,
hospitalized: RateLos = None,
icu: RateLos = None,
ventilated: RateLos = None,
market_share: float = None,
n_days: int = None,
recovery_days: float = None,
):
"""
Run many chime simulations.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None. These settings are just
for the base parameter values. We can run stuff over ranges as we see it.
:param scenarios:
:param params:
:param current_hospitalized:
:param doubling_time:
:param known_infected:
:param relative_contact_rate:
:param susceptible:
:param hospitalized:
:param icu:
:param ventilated:
:param market_share:
:param n_days:
:param recovery_days:
:return:
"""
if params is not None:
params_dict = vars(params)
else:
params_dict = {
"current_hospitalized": None,
"doubling_time": None,
"known_infected": None,
"relative_contact_rate": None,
"susceptible": None,
"hospitalized": None,
"icu": None,
"ventilated": None,
"market_share": None,
"n_days": None,
"recovery_days": None,
}
# Check for parameter updates passed
vals_passed = {
key: value
for (key, value) in vars().items()
if key not in ['scenario', 'params']
}
for key, value in vals_passed.items():
if value is not None:
params_dict[key] = value
# Create Parameters object
p = Parameters(
current_hospitalized=params_dict['current_hospitalized'],
doubling_time=params_dict['doubling_time'],
known_infected=params_dict['known_infected'],
market_share=params_dict['market_share'],
n_days=params_dict['n_days'],
relative_contact_rate=params_dict['relative_contact_rate'],
susceptible=params_dict['susceptible'],
hospitalized=params_dict['hospitalized'],
icu=params_dict['icu'],
ventilated=params_dict['ventilated'],
)
base_input_params_dict = vars(p)
# Create a range of social distances
soc_dists = np.arange(0.05, 0.60, 0.05)
# array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55,
# 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85])
num_scenarios = len(soc_dists)
# We can store outputs any way we want. For this demo, just going to
# use a master list. # This will be a list of dicts of the
# result dataframes (+ 1 dict containing the scenario inputs)
results_list = []
for sdpct in soc_dists:
sim_scenario = '{}{:.0f}'.format(scenarios, 100 * sdpct)
# Update the parameters for this scenario
p.relative_contact_rate = sdpct
input_params_dict = vars(p)
# Run the model
m = SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
# Append results to results list
results_list.append(results.copy())
return results_list
def sim_chime(
sim_scenario: str,
params: Parameters = None,
current_hospitalized: int = None,
doubling_time: float = None,
known_infected: int = None,
relative_contact_rate: float = None,
susceptible: int = None,
hospitalized: RateLos = None,
icu: RateLos = None,
ventilated: RateLos = None,
market_share: float = None,
n_days: int = None,
recovery_days: float = None,
):
"""
Run one chime simulation.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None.
:param sim_scenario:
:param params:
:param current_hospitalized:
:param doubling_time:
:param known_infected:
:param relative_contact_rate:
:param susceptible:
:param hospitalized:
:param icu:
:param ventilated:
:param market_share:
:param n_days:
:param recovery_days:
:return:
"""
if params is not None:
params_dict = vars(params)
else:
params_dict = {
"current_hospitalized": None,
"doubling_time": None,
"known_infected": None,
"relative_contact_rate": None,
"susceptible": None,
"hospitalized": None,
"icu": None,
"ventilated": None,
"market_share": None,
"n_days": None,
"recovery_days": None,
}
# Check for parameter updates passed
vals_passed = {
key: value
for (key, value) in vars().items()
if key not in ['scenario', 'params']
}
for key, value in vals_passed.items():
if value is not None:
params_dict[key] = value
# Create Parameters object
p = Parameters(
current_hospitalized=params_dict['current_hospitalized'],
doubling_time=params_dict['doubling_time'],
known_infected=params_dict['known_infected'],
market_share=params_dict['market_share'],
n_days=params_dict['n_days'],
relative_contact_rate=params_dict['relative_contact_rate'],
susceptible=params_dict['susceptible'],
hospitalized=params_dict['hospitalized'],
icu=params_dict['icu'],
ventilated=params_dict['ventilated'],
)
input_params_dict = vars(p)
# Run the model
m = SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
return results
return results_list
if __name__ == "__main__":
a = parse_args()
scenario = a.scenario
output_path = a.output_path
if a.use_defaults:
p = Parameters(
current_hospitalized=DEFAULTS.current_hospitalized,
doubling_time=DEFAULTS.doubling_time,
known_infected=DEFAULTS.known_infected,
market_share=DEFAULTS.market_share,
n_days=DEFAULTS.n_days,
relative_contact_rate=DEFAULTS.relative_contact_rate,
susceptible=DEFAULTS.region.susceptible,
hospitalized=RateLos(DEFAULTS.hospitalized.rate,
DEFAULTS.hospitalized.length_of_stay),
icu=RateLos(DEFAULTS.icu.rate, DEFAULTS.icu.length_of_stay),
ventilated=RateLos(DEFAULTS.ventilated.rate,
DEFAULTS.ventilated.length_of_stay),
)
else:
p = Parameters(
current_hospitalized=a.current_hospitalized,
doubling_time=a.doubling_time,
known_infected=a.known_infected,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
susceptible=a.susceptible,
from penn_chime.models import SimSirModel
from penn_chime.charts import (
build_admits_chart,
build_census_chart,
build_descriptions,
build_sim_sir_w_date_chart,
build_table,
)
# This is somewhat dangerous:
# Hide the main menu with "Rerun", "run on Save", "clear cache", and "record a screencast"
# This should not be hidden in prod, but removed
# In dev, this should be shown
st.markdown(hide_menu_style, unsafe_allow_html=True)
d = Parameters.create(os.environ, [])
p = display_sidebar(st, d)
m = SimSirModel(p)
display_header(st, m, p)
st.subheader("New Admissions")
st.markdown(
"Projected number of **daily** COVID-19 admissions. \n\n _NOTE: Now including estimates of prior admissions for comparison._"
)
admits_chart = build_admits_chart(alt=alt,
admits_floor_df=m.admits_floor_df,
max_y_axis=p.max_y_axis)
st.altair_chart(admits_chart, use_container_width=True)
st.markdown(
build_descriptions(chart=admits_chart,
def get_model_from_params(parameters, region_results):
p = get_model_params(parameters, region_results)
print(p)
params_obj = Parameters(**p)
m = penn_chime.models.SimSirModel(params_obj)
return m, p
# Update sys.arg so we can call cli.parse_args()
sys.argv = [sys.argv[0], '--file', my_args_dict['file']]
scenario = my_args.scenario
output_path = my_args.output_path
# Read chime params from configuration file
a = cli.parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
date_first_hospitalized=a.date_first_hospitalized,
doubling_time=a.doubling_time,
infectious_days=a.infectious_days,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
population=a.population,
hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days),
icu=Disposition(a.icu_rate, a.icu_days),
ventilated=Disposition(a.ventilated_rate, a.ventilated_days),
)
if my_args.scenarios is None:
# Just running one scenario
results = sim_chime(scenario, p)
if not a.quiet:
print("Scenario: {}\n".format(results['scenario_str']))
print("\nInput parameters")
print("{}".format(50 * '-'))
def test_cypress_defaults():
"""Ensure the cypress defaults have been updated."""
# TODO how to make this work when the module is installed?
_ = Parameters.create({"PARAMETERS": "./defaults/cypress.cfg"}, [])
