m_strat.gui.dag.node_inspector

  1import ast
  2
  3import dearpygui.dearpygui as dpg
  4
  5from api.dag.node import ExecutionNode
  6from api.logger import m_log as log
  7from api.project_management import ProjectManager
  8from gui.dag.pm_triggered_window import PmTriggeredWindow
  9
 10CREATE_NEW_PARAMS_PROMPT = "(Create New Node Params)"
 11
 12
 13class NodeInspector(PmTriggeredWindow):
 14    """Allows for the inspection of Nodes that are within the DAG, mainly for altering their parameters"""
 15
 16    def __init__(self, project_manager: ProjectManager, graph_context="graphs.Model"):
 17        super().__init__(project_manager)
 18        self.tag = "node_inspector"
 19        self.active_node = None
 20        self._pm = project_manager
 21        self.active_param_id = None
 22        self.graph_context = graph_context
 23        self.type_mapping = {
 24            "int": int,
 25            "float": float,
 26            "bool": bool,
 27            "str": str,
 28            "list": list,
 29            # "set": set, Removed, incompatible with YAML
 30            "bytes": bytes,
 31        }
 32
 33        self.disp_lib = {
 34            int: lambda m_params: dpg.add_input_int(**m_params),
 35            float: lambda m_params: dpg.add_input_float(**m_params),
 36            bool: lambda m_params: dpg.add_checkbox(**m_params),
 37            str: lambda m_params: dpg.add_input_text(**m_params),
 38            list: lambda m_params: dpg.add_input_text(**m_params),
 39            # set: lambda m_params: dpg.add_input_text(**m_params),
 40            bytes: lambda m_params: dpg.add_input_text(**m_params),
 41        }
 42        self.new_param_popup = "new_node_param_popup"
 43        with dpg.window(
 44            label="Node Inspector", tag=self.tag, width=320, height=600, no_close=False, pos=[1260, 30]
 45        ):
 46            self.content_group = dpg.add_group()
 47        with dpg.window(
 48            label="New Node Parameter Config",
 49            modal=True,
 50            show=False,
 51            tag=self.new_param_popup,
 52            width=350,
 53            height=130,
 54        ):
 55            self.new_profile_name_input = dpg.add_input_text(
 56                hint="Parameter_id Name", width=-1
 57            )
 58            dpg.add_spacer(height=6)
 59            dpg.add_button(
 60                label="Create", callback=self._on_create_node_param_submit, width=100
 61            )
 62            dpg.add_button(
 63                label="Cancel",
 64                callback=lambda: dpg.configure_item(self.new_param_popup, show=False),
 65                width=100,
 66            )
 67        self.pm_toggled_gui_items.append(self.content_group)
 68
 69    def _on_create_node_param_submit(self, sender, app_data):
 70        new_profile_name = dpg.get_value(self.new_profile_name_input).strip()
 71        if not new_profile_name:
 72            return
 73
 74        existing_ids = (
 75            self._pm.execute_command(
 76                target_obj="param_manager", target_func="get_all_node_param_ids"
 77            )
 78            or []
 79        )
 80        if new_profile_name in existing_ids:
 81            self.app_manager.on_show_pop_up(
 82                "Duplicate Name", f"The profile '{new_profile_name}' already exists"
 83            )
 84            return
 85
 86        new_profile_name = new_profile_name.replace(" ", "_")
 87        default_params = {
 88            k: (False if v is bool else v()) for k, v in self.schema.items()
 89        }
 90        try:
 91            self._pm.execute_command(
 92                target_obj="param_manager",
 93                target_func="add_node_params",
 94                do_params={"param_id": new_profile_name, "params": default_params},
 95            )
 96            self._pm.execute_command(
 97                target_obj=self.graph_context,
 98                target_func="change_node_param_template",
 99                do_params={
100                    "node_id": self.active_node.id,
101                    "new_param_id": new_profile_name,
102                },
103            )
104        except Exception as e:
105            log.error(f"Failed to create node_params: {e}")
106            dpg.configure_item(self.new_param_popup, show=False)
107            return
108
109        dpg.set_value(self.new_profile_name_input, "")
110        dpg.configure_item(self.new_param_popup, show=False)
111
112        self.active_node.param_id = new_profile_name
113        self.inspect(self.active_node)
114
115    def _on_param_value_changed(self, sender, app_data, user_data):
116        target_type = self.schema.get(user_data, None)
117        parsed_val = self._parse_input(app_data, target_type)
118        self._pm.execute_command(
119            target_obj="param_manager",
120            target_func="update_node_param_field",
121            do_params={
122                "param_id": self.active_node.param_id,
123                "param_key": user_data,
124                "param_value": parsed_val,
125            },
126        )
127
128    def _on_key_selection_toggle(self, sender, app_data):
129        is_custom = app_data == "Custom..."
130        dpg.configure_item(self.custom_name_input, show=is_custom)
131        dpg.configure_item(self.custom_type_combo, show=is_custom)
132
133    def _toggle_creator_visibility(self, sender, app_data):
134        is_shown = dpg.get_item_configuration(self.creator_group)["show"]
135        dpg.configure_item(self.creator_group, show=not is_shown)
136
137    def _parse_input(self, raw_val, schema_type=None, param_name="", with_log=False):
138        """Attempts to parse the inputs if they are a string in case the type do not match"""
139        if not raw_val or not isinstance(raw_val, str) or schema_type is str:
140            return raw_val
141        try:
142            parsed_val = ast.literal_eval(raw_val)
143            # if isinstance(parsed_val, dict) and not parsed_val and schema_type is set:
144            #     parsed_val = set()
145            if with_log and schema_type and not isinstance(parsed_val, schema_type):
146                log.warning(
147                    f"{param_name}: Type mismatch {type(parsed_val).__name__} but schema expects {schema_type.__name__}"
148                )
149
150            return parsed_val
151        except (ValueError, SyntaxError) as e:
152            if with_log:
153                log.info(f"Type did not parse, val:{raw_val} \n Due to:\n{e}")
154            return raw_val
155
156    def _on_add_node_param_submit(self, sender, app_data):
157        selected_key = dpg.get_value(self.add_param_combo)
158        if not selected_key:
159            return
160
161        if selected_key == "Custom...":
162            field_name = dpg.get_value(self.custom_name_input).strip()
163            type_str = dpg.get_value(self.custom_type_combo)
164            chosen_type = self.type_mapping.get(type_str, str)
165        else:
166            field_name = selected_key
167            chosen_type = self.schema.get(field_name, str)
168
169        if not field_name:
170            return
171
172        default_value = False if chosen_type is bool else chosen_type()
173
174        self._pm.execute_command(
175            target_obj="param_manager",
176            target_func="update_node_param_field",
177            do_params={
178                "param_id": self.active_node.param_id,
179                "param_key": field_name,
180                "param_value": default_value,
181            },
182        )
183        self.inspect(self.active_node)
184
185    def _render_param_creator(self, parent_group):
186        unassigned_schema_keys = [k for k in self.schema.keys() if k not in self.params]
187        dropdown_options = unassigned_schema_keys + ["Custom..."]
188
189        self.creator_group = dpg.add_group(parent=parent_group, show=False)
190
191        with dpg.group(parent=self.creator_group):
192            dpg.add_spacer(height=6)
193            dpg.add_separator()
194            dpg.add_spacer(height=6)
195            dpg.add_text("Add Missing or Custom Field:", color=[150, 255, 150])
196
197            self.add_param_combo = dpg.add_combo(
198                items=dropdown_options, callback=self._on_key_selection_toggle, width=-1
199            )
200
201            self.custom_name_input = dpg.add_input_text(
202                hint="Enter Field Name", show=False, width=-1
203            )
204
205            self.custom_type_combo = dpg.add_combo(
206                items=list(self.type_mapping.keys()), show=False, width=-1
207            )
208
209            dpg.add_spacer(height=6)
210            dpg.add_button(
211                label="Commit Parameter",
212                callback=self._on_add_node_param_submit,
213                width=-1,
214            )
215
216    def on_param_select_change(self, sender, app_data):
217        if app_data == CREATE_NEW_PARAMS_PROMPT:
218            dpg.configure_item(self.new_param_popup, show=True)
219        else:
220            self.active_param_id = app_data
221            self._pm.execute_command(
222                target_obj=self.graph_context,
223                target_func="change_node_param_template",
224                do_params={"node_id": self.active_node.id, "new_param_id": app_data},
225            )
226            self.active_node.param_id = app_data
227            self.inspect(self.active_node)
228
229    def inspect(self, exec_node: ExecutionNode, graph_context=None):
230        if graph_context:
231            self.graph_context = graph_context
232        self.active_node = exec_node
233        self.schema = (
234            self._pm.execute_command(
235                target_obj="bp_reg",
236                target_func="get_schema",
237                do_params={"name": exec_node.blueprint_name},
238            )
239            or {}
240        )
241        self.params = (
242            self._pm.execute_command(
243                target_obj="param_manager",
244                target_func="get_node_params",
245                do_params={"param_id": exec_node.param_id},
246            )
247            or {}
248        )
249
250        all_param_names = (
251            self._pm.execute_command(
252                target_obj="param_manager", target_func="get_all_node_param_ids"
253            )
254            or []
255        )
256
257        dpg.delete_item(self.content_group, children_only=True)
258
259        dpg.add_text(
260            "Inspecting Node:", color=[150, 200, 255], parent=self.content_group
261        )
262        dpg.add_text(
263            f"[{exec_node.id}]\nType: {exec_node.blueprint_name}",
264            parent=self.content_group,
265        )
266        dpg.add_spacer(height=8, parent=self.content_group)
267
268        dpg.add_text("Active Parameter Profile:", parent=self.content_group)
269        dpg.add_combo(
270            items=all_param_names + [CREATE_NEW_PARAMS_PROMPT],
271            default_value=exec_node.param_id,
272            callback=self.on_param_select_change,
273            parent=self.content_group,
274            width=-1,
275        )
276        dpg.add_spacer(height=16, parent=self.content_group)
277        dpg.add_separator(parent=self.content_group)
278        dpg.add_spacer(height=8, parent=self.content_group)
279
280        if not self.params and exec_node.param_id == "EMPTY":
281            dpg.add_text(
282                "This node is currently using the default EMPTY profile.\nSelect or create a new profile from the dropdown above to edit parameters.",
283                wrap=300,
284                color=[200, 200, 200],
285                parent=self.content_group,
286            )
287
288        for key, value in self.params.items():
289            val_type = self.schema.get(key, type(value))
290            ui_display = self.disp_lib.get(val_type, dpg.add_input_text)
291
292            dpg.add_text(f"{key}:", parent=self.content_group)
293
294            widget_config = {
295                "default_value": value,
296                "parent": self.content_group,
297                "callback": self._on_param_value_changed,
298                "user_data": key,
299                "width": -1,
300            }
301            if val_type is bool:
302                widget_config.pop("width", None)
303                widget_config["default_value"] = bool(value)
304            # elif val_type is set and value == set():
305            #     widget_config["default_value"] = "{}"
306
307            ui_display(widget_config)
308            dpg.add_spacer(height=6, parent=self.content_group)
309
310        dpg.add_separator(parent=self.content_group)
311        dpg.add_spacer(height=8, parent=self.content_group)
312
313        dpg.add_button(
314            label="+ Assign New Field",
315            parent=self.content_group,
316            callback=self._toggle_creator_visibility,
317            width=-1,
318            enabled=exec_node.param_id != "EMPTY",
319        )
320
321        self._render_param_creator(parent_group=self.content_group)
322
323    def on_pm_changed(self):
324        super().on_pm_changed()
325        if self._pm is None:
326            dpg.delete_item(self.content_group, children_only=True)
327            self.active_node = None
328            self.active_param_id = None
CREATE_NEW_PARAMS_PROMPT = '(Create New Node Params)'
class NodeInspector(gui.dag.pm_triggered_window.PmTriggeredWindow):
 14class NodeInspector(PmTriggeredWindow):
 15    """Allows for the inspection of Nodes that are within the DAG, mainly for altering their parameters"""
 16
 17    def __init__(self, project_manager: ProjectManager, graph_context="graphs.Model"):
 18        super().__init__(project_manager)
 19        self.tag = "node_inspector"
 20        self.active_node = None
 21        self._pm = project_manager
 22        self.active_param_id = None
 23        self.graph_context = graph_context
 24        self.type_mapping = {
 25            "int": int,
 26            "float": float,
 27            "bool": bool,
 28            "str": str,
 29            "list": list,
 30            # "set": set, Removed, incompatible with YAML
 31            "bytes": bytes,
 32        }
 33
 34        self.disp_lib = {
 35            int: lambda m_params: dpg.add_input_int(**m_params),
 36            float: lambda m_params: dpg.add_input_float(**m_params),
 37            bool: lambda m_params: dpg.add_checkbox(**m_params),
 38            str: lambda m_params: dpg.add_input_text(**m_params),
 39            list: lambda m_params: dpg.add_input_text(**m_params),
 40            # set: lambda m_params: dpg.add_input_text(**m_params),
 41            bytes: lambda m_params: dpg.add_input_text(**m_params),
 42        }
 43        self.new_param_popup = "new_node_param_popup"
 44        with dpg.window(
 45            label="Node Inspector", tag=self.tag, width=320, height=600, no_close=False, pos=[1260, 30]
 46        ):
 47            self.content_group = dpg.add_group()
 48        with dpg.window(
 49            label="New Node Parameter Config",
 50            modal=True,
 51            show=False,
 52            tag=self.new_param_popup,
 53            width=350,
 54            height=130,
 55        ):
 56            self.new_profile_name_input = dpg.add_input_text(
 57                hint="Parameter_id Name", width=-1
 58            )
 59            dpg.add_spacer(height=6)
 60            dpg.add_button(
 61                label="Create", callback=self._on_create_node_param_submit, width=100
 62            )
 63            dpg.add_button(
 64                label="Cancel",
 65                callback=lambda: dpg.configure_item(self.new_param_popup, show=False),
 66                width=100,
 67            )
 68        self.pm_toggled_gui_items.append(self.content_group)
 69
 70    def _on_create_node_param_submit(self, sender, app_data):
 71        new_profile_name = dpg.get_value(self.new_profile_name_input).strip()
 72        if not new_profile_name:
 73            return
 74
 75        existing_ids = (
 76            self._pm.execute_command(
 77                target_obj="param_manager", target_func="get_all_node_param_ids"
 78            )
 79            or []
 80        )
 81        if new_profile_name in existing_ids:
 82            self.app_manager.on_show_pop_up(
 83                "Duplicate Name", f"The profile '{new_profile_name}' already exists"
 84            )
 85            return
 86
 87        new_profile_name = new_profile_name.replace(" ", "_")
 88        default_params = {
 89            k: (False if v is bool else v()) for k, v in self.schema.items()
 90        }
 91        try:
 92            self._pm.execute_command(
 93                target_obj="param_manager",
 94                target_func="add_node_params",
 95                do_params={"param_id": new_profile_name, "params": default_params},
 96            )
 97            self._pm.execute_command(
 98                target_obj=self.graph_context,
 99                target_func="change_node_param_template",
100                do_params={
101                    "node_id": self.active_node.id,
102                    "new_param_id": new_profile_name,
103                },
104            )
105        except Exception as e:
106            log.error(f"Failed to create node_params: {e}")
107            dpg.configure_item(self.new_param_popup, show=False)
108            return
109
110        dpg.set_value(self.new_profile_name_input, "")
111        dpg.configure_item(self.new_param_popup, show=False)
112
113        self.active_node.param_id = new_profile_name
114        self.inspect(self.active_node)
115
116    def _on_param_value_changed(self, sender, app_data, user_data):
117        target_type = self.schema.get(user_data, None)
118        parsed_val = self._parse_input(app_data, target_type)
119        self._pm.execute_command(
120            target_obj="param_manager",
121            target_func="update_node_param_field",
122            do_params={
123                "param_id": self.active_node.param_id,
124                "param_key": user_data,
125                "param_value": parsed_val,
126            },
127        )
128
129    def _on_key_selection_toggle(self, sender, app_data):
130        is_custom = app_data == "Custom..."
131        dpg.configure_item(self.custom_name_input, show=is_custom)
132        dpg.configure_item(self.custom_type_combo, show=is_custom)
133
134    def _toggle_creator_visibility(self, sender, app_data):
135        is_shown = dpg.get_item_configuration(self.creator_group)["show"]
136        dpg.configure_item(self.creator_group, show=not is_shown)
137
138    def _parse_input(self, raw_val, schema_type=None, param_name="", with_log=False):
139        """Attempts to parse the inputs if they are a string in case the type do not match"""
140        if not raw_val or not isinstance(raw_val, str) or schema_type is str:
141            return raw_val
142        try:
143            parsed_val = ast.literal_eval(raw_val)
144            # if isinstance(parsed_val, dict) and not parsed_val and schema_type is set:
145            #     parsed_val = set()
146            if with_log and schema_type and not isinstance(parsed_val, schema_type):
147                log.warning(
148                    f"{param_name}: Type mismatch {type(parsed_val).__name__} but schema expects {schema_type.__name__}"
149                )
150
151            return parsed_val
152        except (ValueError, SyntaxError) as e:
153            if with_log:
154                log.info(f"Type did not parse, val:{raw_val} \n Due to:\n{e}")
155            return raw_val
156
157    def _on_add_node_param_submit(self, sender, app_data):
158        selected_key = dpg.get_value(self.add_param_combo)
159        if not selected_key:
160            return
161
162        if selected_key == "Custom...":
163            field_name = dpg.get_value(self.custom_name_input).strip()
164            type_str = dpg.get_value(self.custom_type_combo)
165            chosen_type = self.type_mapping.get(type_str, str)
166        else:
167            field_name = selected_key
168            chosen_type = self.schema.get(field_name, str)
169
170        if not field_name:
171            return
172
173        default_value = False if chosen_type is bool else chosen_type()
174
175        self._pm.execute_command(
176            target_obj="param_manager",
177            target_func="update_node_param_field",
178            do_params={
179                "param_id": self.active_node.param_id,
180                "param_key": field_name,
181                "param_value": default_value,
182            },
183        )
184        self.inspect(self.active_node)
185
186    def _render_param_creator(self, parent_group):
187        unassigned_schema_keys = [k for k in self.schema.keys() if k not in self.params]
188        dropdown_options = unassigned_schema_keys + ["Custom..."]
189
190        self.creator_group = dpg.add_group(parent=parent_group, show=False)
191
192        with dpg.group(parent=self.creator_group):
193            dpg.add_spacer(height=6)
194            dpg.add_separator()
195            dpg.add_spacer(height=6)
196            dpg.add_text("Add Missing or Custom Field:", color=[150, 255, 150])
197
198            self.add_param_combo = dpg.add_combo(
199                items=dropdown_options, callback=self._on_key_selection_toggle, width=-1
200            )
201
202            self.custom_name_input = dpg.add_input_text(
203                hint="Enter Field Name", show=False, width=-1
204            )
205
206            self.custom_type_combo = dpg.add_combo(
207                items=list(self.type_mapping.keys()), show=False, width=-1
208            )
209
210            dpg.add_spacer(height=6)
211            dpg.add_button(
212                label="Commit Parameter",
213                callback=self._on_add_node_param_submit,
214                width=-1,
215            )
216
217    def on_param_select_change(self, sender, app_data):
218        if app_data == CREATE_NEW_PARAMS_PROMPT:
219            dpg.configure_item(self.new_param_popup, show=True)
220        else:
221            self.active_param_id = app_data
222            self._pm.execute_command(
223                target_obj=self.graph_context,
224                target_func="change_node_param_template",
225                do_params={"node_id": self.active_node.id, "new_param_id": app_data},
226            )
227            self.active_node.param_id = app_data
228            self.inspect(self.active_node)
229
230    def inspect(self, exec_node: ExecutionNode, graph_context=None):
231        if graph_context:
232            self.graph_context = graph_context
233        self.active_node = exec_node
234        self.schema = (
235            self._pm.execute_command(
236                target_obj="bp_reg",
237                target_func="get_schema",
238                do_params={"name": exec_node.blueprint_name},
239            )
240            or {}
241        )
242        self.params = (
243            self._pm.execute_command(
244                target_obj="param_manager",
245                target_func="get_node_params",
246                do_params={"param_id": exec_node.param_id},
247            )
248            or {}
249        )
250
251        all_param_names = (
252            self._pm.execute_command(
253                target_obj="param_manager", target_func="get_all_node_param_ids"
254            )
255            or []
256        )
257
258        dpg.delete_item(self.content_group, children_only=True)
259
260        dpg.add_text(
261            "Inspecting Node:", color=[150, 200, 255], parent=self.content_group
262        )
263        dpg.add_text(
264            f"[{exec_node.id}]\nType: {exec_node.blueprint_name}",
265            parent=self.content_group,
266        )
267        dpg.add_spacer(height=8, parent=self.content_group)
268
269        dpg.add_text("Active Parameter Profile:", parent=self.content_group)
270        dpg.add_combo(
271            items=all_param_names + [CREATE_NEW_PARAMS_PROMPT],
272            default_value=exec_node.param_id,
273            callback=self.on_param_select_change,
274            parent=self.content_group,
275            width=-1,
276        )
277        dpg.add_spacer(height=16, parent=self.content_group)
278        dpg.add_separator(parent=self.content_group)
279        dpg.add_spacer(height=8, parent=self.content_group)
280
281        if not self.params and exec_node.param_id == "EMPTY":
282            dpg.add_text(
283                "This node is currently using the default EMPTY profile.\nSelect or create a new profile from the dropdown above to edit parameters.",
284                wrap=300,
285                color=[200, 200, 200],
286                parent=self.content_group,
287            )
288
289        for key, value in self.params.items():
290            val_type = self.schema.get(key, type(value))
291            ui_display = self.disp_lib.get(val_type, dpg.add_input_text)
292
293            dpg.add_text(f"{key}:", parent=self.content_group)
294
295            widget_config = {
296                "default_value": value,
297                "parent": self.content_group,
298                "callback": self._on_param_value_changed,
299                "user_data": key,
300                "width": -1,
301            }
302            if val_type is bool:
303                widget_config.pop("width", None)
304                widget_config["default_value"] = bool(value)
305            # elif val_type is set and value == set():
306            #     widget_config["default_value"] = "{}"
307
308            ui_display(widget_config)
309            dpg.add_spacer(height=6, parent=self.content_group)
310
311        dpg.add_separator(parent=self.content_group)
312        dpg.add_spacer(height=8, parent=self.content_group)
313
314        dpg.add_button(
315            label="+ Assign New Field",
316            parent=self.content_group,
317            callback=self._toggle_creator_visibility,
318            width=-1,
319            enabled=exec_node.param_id != "EMPTY",
320        )
321
322        self._render_param_creator(parent_group=self.content_group)
323
324    def on_pm_changed(self):
325        super().on_pm_changed()
326        if self._pm is None:
327            dpg.delete_item(self.content_group, children_only=True)
328            self.active_node = None
329            self.active_param_id = None

Allows for the inspection of Nodes that are within the DAG, mainly for altering their parameters

NodeInspector( project_manager: api.project_management.project_manager.ProjectManager, graph_context='graphs.Model')
17    def __init__(self, project_manager: ProjectManager, graph_context="graphs.Model"):
18        super().__init__(project_manager)
19        self.tag = "node_inspector"
20        self.active_node = None
21        self._pm = project_manager
22        self.active_param_id = None
23        self.graph_context = graph_context
24        self.type_mapping = {
25            "int": int,
26            "float": float,
27            "bool": bool,
28            "str": str,
29            "list": list,
30            # "set": set, Removed, incompatible with YAML
31            "bytes": bytes,
32        }
33
34        self.disp_lib = {
35            int: lambda m_params: dpg.add_input_int(**m_params),
36            float: lambda m_params: dpg.add_input_float(**m_params),
37            bool: lambda m_params: dpg.add_checkbox(**m_params),
38            str: lambda m_params: dpg.add_input_text(**m_params),
39            list: lambda m_params: dpg.add_input_text(**m_params),
40            # set: lambda m_params: dpg.add_input_text(**m_params),
41            bytes: lambda m_params: dpg.add_input_text(**m_params),
42        }
43        self.new_param_popup = "new_node_param_popup"
44        with dpg.window(
45            label="Node Inspector", tag=self.tag, width=320, height=600, no_close=False, pos=[1260, 30]
46        ):
47            self.content_group = dpg.add_group()
48        with dpg.window(
49            label="New Node Parameter Config",
50            modal=True,
51            show=False,
52            tag=self.new_param_popup,
53            width=350,
54            height=130,
55        ):
56            self.new_profile_name_input = dpg.add_input_text(
57                hint="Parameter_id Name", width=-1
58            )
59            dpg.add_spacer(height=6)
60            dpg.add_button(
61                label="Create", callback=self._on_create_node_param_submit, width=100
62            )
63            dpg.add_button(
64                label="Cancel",
65                callback=lambda: dpg.configure_item(self.new_param_popup, show=False),
66                width=100,
67            )
68        self.pm_toggled_gui_items.append(self.content_group)
tag
active_node
active_param_id
graph_context
type_mapping
disp_lib
new_param_popup
def on_param_select_change(self, sender, app_data):
217    def on_param_select_change(self, sender, app_data):
218        if app_data == CREATE_NEW_PARAMS_PROMPT:
219            dpg.configure_item(self.new_param_popup, show=True)
220        else:
221            self.active_param_id = app_data
222            self._pm.execute_command(
223                target_obj=self.graph_context,
224                target_func="change_node_param_template",
225                do_params={"node_id": self.active_node.id, "new_param_id": app_data},
226            )
227            self.active_node.param_id = app_data
228            self.inspect(self.active_node)
def inspect(self, exec_node: api.dag.node.ExecutionNode, graph_context=None):
230    def inspect(self, exec_node: ExecutionNode, graph_context=None):
231        if graph_context:
232            self.graph_context = graph_context
233        self.active_node = exec_node
234        self.schema = (
235            self._pm.execute_command(
236                target_obj="bp_reg",
237                target_func="get_schema",
238                do_params={"name": exec_node.blueprint_name},
239            )
240            or {}
241        )
242        self.params = (
243            self._pm.execute_command(
244                target_obj="param_manager",
245                target_func="get_node_params",
246                do_params={"param_id": exec_node.param_id},
247            )
248            or {}
249        )
250
251        all_param_names = (
252            self._pm.execute_command(
253                target_obj="param_manager", target_func="get_all_node_param_ids"
254            )
255            or []
256        )
257
258        dpg.delete_item(self.content_group, children_only=True)
259
260        dpg.add_text(
261            "Inspecting Node:", color=[150, 200, 255], parent=self.content_group
262        )
263        dpg.add_text(
264            f"[{exec_node.id}]\nType: {exec_node.blueprint_name}",
265            parent=self.content_group,
266        )
267        dpg.add_spacer(height=8, parent=self.content_group)
268
269        dpg.add_text("Active Parameter Profile:", parent=self.content_group)
270        dpg.add_combo(
271            items=all_param_names + [CREATE_NEW_PARAMS_PROMPT],
272            default_value=exec_node.param_id,
273            callback=self.on_param_select_change,
274            parent=self.content_group,
275            width=-1,
276        )
277        dpg.add_spacer(height=16, parent=self.content_group)
278        dpg.add_separator(parent=self.content_group)
279        dpg.add_spacer(height=8, parent=self.content_group)
280
281        if not self.params and exec_node.param_id == "EMPTY":
282            dpg.add_text(
283                "This node is currently using the default EMPTY profile.\nSelect or create a new profile from the dropdown above to edit parameters.",
284                wrap=300,
285                color=[200, 200, 200],
286                parent=self.content_group,
287            )
288
289        for key, value in self.params.items():
290            val_type = self.schema.get(key, type(value))
291            ui_display = self.disp_lib.get(val_type, dpg.add_input_text)
292
293            dpg.add_text(f"{key}:", parent=self.content_group)
294
295            widget_config = {
296                "default_value": value,
297                "parent": self.content_group,
298                "callback": self._on_param_value_changed,
299                "user_data": key,
300                "width": -1,
301            }
302            if val_type is bool:
303                widget_config.pop("width", None)
304                widget_config["default_value"] = bool(value)
305            # elif val_type is set and value == set():
306            #     widget_config["default_value"] = "{}"
307
308            ui_display(widget_config)
309            dpg.add_spacer(height=6, parent=self.content_group)
310
311        dpg.add_separator(parent=self.content_group)
312        dpg.add_spacer(height=8, parent=self.content_group)
313
314        dpg.add_button(
315            label="+ Assign New Field",
316            parent=self.content_group,
317            callback=self._toggle_creator_visibility,
318            width=-1,
319            enabled=exec_node.param_id != "EMPTY",
320        )
321
322        self._render_param_creator(parent_group=self.content_group)
def on_pm_changed(self):
324    def on_pm_changed(self):
325        super().on_pm_changed()
326        if self._pm is None:
327            dpg.delete_item(self.content_group, children_only=True)
328            self.active_node = None
329            self.active_param_id = None