def trigger_param(event):
"""Trigger a parameter"""
pipeline = state.get_user_state().get(app, {}).get("pipeline")
if not pipeline:
raise ValueError("No pipeline is available")
pipeline.param.trigger(trigger)
def __init__(self, report_from_set_up, initial_values):
"""Set initial values based on previous stage"""
# Add elements as parameters
for label, element in ELEMENT_OPTIONS.items():
self.param._add_parameter(
element, param.Integer(0, label=label, bounds=(0, 100)))
self.param._add_parameter(
f"{element}_quality",
param.Selector(QUALITY_OPTIONS, label=f"{label} Quality"),
)
super().__init__()
# Initialize parameter values
self.report_from_set_up = report_from_set_up
self.model_result = None
self._state = state.get_user_state().setdefault(APP, {})
self.element_widgets = self.layout_element_widgets()
self.visible_elements = {}
self._initialize_qualities(
reservoir_quality={
ELEMENT_OPTIONS[k]: initial_values["reservoir_quality"]
for k in initial_values["composition"]
},
default=initial_values["reservoir_quality"],
)
self._initialize_composition(
composition={
ELEMENT_OPTIONS[k]: v
for k, v in initial_values["composition"].items()
})
def __init__(self, initial_filter_classes, report_from_composition,
net_gross):
"""Set initial values based on previous stage"""
# Add filter classes as parameters
for bblock, filter_classes in FILTER_CLASS_PARAMS.items():
for fclass, values in filter_classes.values():
for label, param_name in values.items():
if label.startswith("Ignore "):
self.param._add_parameter(
param_name, param.Boolean(False, label=label))
else:
value = initial_filter_classes[bblock][fclass].get(
label, 0)
self.param._add_parameter(
param_name,
param.Integer(value, label=label, bounds=(0, 100)),
)
super().__init__()
# Set up other parameters
self.model_result = None
self._state = state.get_user_state().setdefault(APP, {})
self.report_from_composition = report_from_composition
self.estimate_net_gross()
def __init__(self, scenario_names, *args, **kwargs):
"""Initialize values of stage"""
super().__init__()
self._report_cfg = config.app.report[CFG.report]
self._state = state.get_user_state().setdefault(APP, {})
self.scenario_names = scenario_names
self.scenario_selector = pn.widgets.CrossSelector(
name="Choose scenarios",
value=self.scenario_names,
options=self.scenario_names,
definition_order=False,
)
self.scenarios = self._state["scenarios"].copy()
def view():
"""Add stages defined in config to a workflow pipeline"""
stages_cfg = config.app.stages[APP]
pipeline = pn.pipeline.Pipeline(debug=logger.is_dev)
state.get_user_state().setdefault(APP, {})["pipeline"] = pipeline
for stage in CFG.stages:
pipeline.add_stage(
stages_cfg[stage].label,
stages.get_stage(APP, stage),
**stages.get_params(APP, stage),
)
# Use pipeline.layout to render the default layout or use pipeline.title,
# .buttons, .network, .stage etc to create a custom layout
return [pn.layout.Spacer(height=30), pipeline.error, pipeline.stage]
def __init__(self, report_from_set_up, initial_values):
"""Set initial values based on previous stage"""
# Add elements as parameters
for label, element in ELEMENT_OPTIONS.items():
self.param._add_parameter(
element, param.Integer(0, label=label, bounds=(0, 100)))
super().__init__()
self.report_from_set_up = report_from_set_up
self._state = state.get_user_state().setdefault(APP, {})
self._initial_filter_classes = initial_values["filter_classes"]
for building_block_type, value in initial_values["composition"].items(
):
setattr(self, building_block_type.replace(" ", "_").lower(), value)
def _update_view_factory(header_canvas,
view_canvas,
sidebar_menu,
app,
view,
button=None):
"""Create a callback that can update the canvas"""
if button is not None:
(state.get_user_state().setdefault(app,
{}).setdefault("update_view",
{})[view]) = button
def update_view(event):
"""Update canvas to show the given app/view"""
header_canvas.object = f"#### {CFG[app].label}"
sidebar_menu.active = [sidebar_menu._names.index(CFG[app].label)]
view_canvas[:] = get_view(app=app, view=view)
return update_view
def __init__(self, report_from_composition, net_gross):
"""Set initial values based on previous stage"""
super().__init__()
self._state = state.get_user_state().setdefault(APP, {})
self._state.setdefault("scenarios", {})
self._current_scenario_name = None
self.net_gross = net_gross
self.report_from_composition = report_from_composition
self.scenario_name = f"Scenario {len(self._state['scenarios']) + 1}"
self.data = charts.data_as_dataframe(report_from_composition, CFG.columns)
try:
session_id = pn.state.curdoc.session_context.id
logger.insights(f"New result: {self.net_gross}, SessionID: {session_id}")
logger.insights(
f"SessionID: {session_id}, Choices: {report_from_composition}"
)
except AttributeError as e:
logger.error(f"SessionID not available: {e}")
logger.insights(f"New result: {self.net_gross}")
logger.insights(f"Choices: {report_from_composition}")