m_strat.gui.dag.exec_graph

  1from random import randint
  2
  3import dearpygui.dearpygui as dpg
  4
  5from api.dag.node import ExecutionNode
  6from api.logger import m_log
  7from api.project_management import ProjectManager
  8from gui.dag.pm_triggered_window import PmTriggeredWindow
  9
 10
 11class UIExecNode:
 12    """Handes UI element of Execution Node within graph"""
 13
 14    def __init__(
 15        self, node_id, blueprint_name, param_id, parent_editor="main_editor", pos=None
 16    ):
 17        self.id = node_id
 18        self.blueprint_name = blueprint_name
 19        self.param_id = param_id
 20        self.tag = dpg.generate_uuid()
 21        self.parent_editor = parent_editor
 22
 23        self.in_pin_tag = dpg.generate_uuid()
 24        self.out_pin_tag = dpg.generate_uuid()
 25        if pos:
 26            initial_position = pos
 27        else:
 28            initial_position = [200 + (randint(0, 6) * 20), 200 + (randint(0, 6) * 20)]
 29
 30        # Visual layout
 31        with dpg.node(
 32            label=self.id, tag=self.tag, parent=self.parent_editor, pos=initial_position
 33        ):
 34            # Input Pin
 35            with dpg.node_attribute(
 36                tag=self.in_pin_tag,
 37                attribute_type=dpg.mvNode_Attr_Input,
 38                shape=dpg.mvNode_PinShape_TriangleFilled,
 39            ):
 40                dpg.add_text(" ")
 41            # Output Pin
 42            with dpg.node_attribute(
 43                tag=self.out_pin_tag,
 44                attribute_type=dpg.mvNode_Attr_Output,
 45                shape=dpg.mvNode_PinShape_TriangleFilled,
 46            ):
 47                dpg.add_text(" ")
 48
 49
 50class UIExecGraph(PmTriggeredWindow):
 51    """Manages a single DAG at a time, allowing for adding and remove of nodes, etc."""
 52
 53    def __init__(
 54        self,
 55        inspector,
 56        project_manager: ProjectManager,
 57        graph_name=None,
 58        load_graph=False,
 59    ):
 60        super().__init__(project_manager)
 61
 62        self.inspector = inspector
 63        self._pm = project_manager
 64
 65        self.graph_name = graph_name
 66        self.graph_target = f"graphs.{graph_name}"
 67
 68        self.nodes = {}
 69        self.pins = {}
 70        self.edges = {}
 71        self.tag = "node_space_win"
 72        self.editor_tag = "main_editor"
 73        with dpg.window(label="Node Space", tag=self.tag):
 74            with dpg.node_editor(
 75                tag=self.editor_tag,
 76                callback=self._on_link,
 77                delink_callback=self._on_delink,
 78            ):
 79                pass
 80
 81        with dpg.handler_registry():
 82            dpg.add_key_press_handler(
 83                key=dpg.mvKey_Delete, callback=self._on_delete_node
 84            )
 85            dpg.add_mouse_click_handler(callback=self._on_canvas_click)
 86
 87        if load_graph:
 88            self.load_graph_target()
 89
 90    def load_graph_target(self, graph_name=None):
 91        """Loads the graph designated by graph_name within the project or refreshes current graph rendering"""
 92        if graph_name is not None:
 93            self.graph_name = graph_name
 94            self.graph_target = f"graphs.{graph_name}"
 95
 96        nodes: ExecutionNode = self._pm.execute_command(
 97            target_obj=self.graph_target, target_func="get_nodes"
 98        )
 99        edges = self._pm.execute_command(
100            target_obj=self.graph_target, target_func="get_edges"
101        )
102        self.nodes = {}
103        id_to_ui = {}
104        self.pins = {}
105        self.edges = {}
106        dpg.delete_item("main_editor", children_only=True)
107        for node in nodes.values():
108            ui_node = UIExecNode(
109                node.id, node.blueprint_name, node.param_id, "main_editor", node.pos
110            )
111            self.nodes[ui_node.tag] = ui_node
112            self.pins[ui_node.in_pin_tag] = ui_node
113            self.pins[ui_node.out_pin_tag] = ui_node
114            id_to_ui[node.id] = ui_node
115
116        for from_node_id, to_node_id in edges:
117            from_tag = id_to_ui[from_node_id].out_pin_tag
118            to_tag = id_to_ui[to_node_id].in_pin_tag
119
120            new_edge_tag = dpg.add_node_link(from_tag, to_tag, parent="main_editor")
121            self.edges[new_edge_tag] = (from_node_id, to_node_id)
122
123    def node_pos_to_api(self):
124        if not self.graph_target:
125            return
126        nodes: dict = self._pm.execute_command(
127            target_obj=self.graph_target, target_func="get_nodes", do_params={}
128        )
129        if not nodes:
130            return
131        for ui_node in self.nodes.values():
132            pos = dpg.get_item_pos(ui_node.tag)
133            next_node: ExecutionNode = nodes.get(ui_node.id)
134            if next_node:
135                next_node.pos = pos
136            else:
137                m_log.warning(
138                    f"Could not find Node: {ui_node.id} when sending UI graph space locations to API"
139                )
140
141    def generate_node_id(self, blueprint_name):
142        existing = self._pm.execute_command(
143            target_obj=self.graph_target,
144            target_func="get_node",
145            do_params={"node_id": blueprint_name},
146        )
147        copy_no = 0
148        out_id = blueprint_name
149        while existing:
150            copy_no += 1
151            out_id = f"{blueprint_name}_{copy_no}"
152            existing = self._pm.execute_command(
153                target_obj=self.graph_target,
154                target_func="get_node",
155                do_params={"node_id": out_id},
156            )
157        return out_id
158
159    def add_node(self, blueprint_name, param_id="EMPTY"):
160        node_id = self.generate_node_id(blueprint_name)
161        self._pm.execute_command(
162            target_obj=self.graph_target,
163            target_func="create_add_new_node",
164            do_params={
165                "node_id": node_id,
166                "blueprint_name": blueprint_name,
167                "param_id": param_id,
168            },
169        )
170        new_node = self._pm.execute_command(
171            target_obj=self.graph_target,
172            target_func="get_node",
173            do_params={"node_id": node_id},
174        )
175        if not new_node:
176            m_log.error(f"Failed to create new_node {node_id} with {blueprint_name}")
177            return
178        ui_node = UIExecNode(node_id, blueprint_name, param_id, "main_editor")
179        self.nodes[ui_node.tag] = ui_node
180        self.pins[ui_node.in_pin_tag] = ui_node
181        self.pins[ui_node.out_pin_tag] = ui_node
182
183    def _on_link(self, sender, app_data):
184        node_tag_from, node_tag_to = app_data[0], app_data[1]
185        node_from, node_to = self.pins[node_tag_from], self.pins[node_tag_to]
186        if not node_from or not node_to:
187            m_log.warning(
188                f"Reference missing for node link {node_from if node_from else '[EMPTY]'} ---> {node_to if node_to else '[EMPTY]'} \n...Aborting"
189            )
190            self.load_graph_target()
191            return
192        if node_from == node_to:
193            m_log.warning(f"Cannot link node to itself, {node_from} ... Aborting")
194            return
195
196        self._pm.execute_command(
197            target_obj=self.graph_target,
198            target_func="add_edge",
199            do_params={"node_from": node_from.id, "node_to": node_to.id},
200        )
201        edge_tag = dpg.add_node_link(node_tag_from, node_tag_to, parent=sender)
202        self.edges[edge_tag] = (node_from.id, node_to.id)
203
204    def _on_delink(self, sender, app_data):
205        edge_tag = app_data
206        if edge_tag not in self.edges:
207            self.load_graph_target()
208            return
209        node_from_id, node_to_id = self.edges.pop(edge_tag)
210        self._pm.execute_command(
211            target_obj=self.graph_target,
212            target_func="remove_edge",
213            do_params={"node_from": node_from_id, "node_to": node_to_id},
214        )
215        dpg.delete_item(edge_tag)
216
217    def _on_delete_node(self, sender, app_data):
218        sel_nodes = dpg.get_selected_nodes("main_editor")
219        for node_tag in sel_nodes:
220            if node_tag not in self.nodes:
221                continue
222            if self.nodes[node_tag].id == "start":
223                m_log.warning("Cannot Delete Start node, ignored request")
224                continue
225            node = self.nodes.pop(node_tag)
226            self._pm.execute_command(
227                target_obj=self.graph_target,
228                target_func="remove_node",
229                do_params={"node_id": node.id},
230            )
231            self.pins.pop(node.in_pin_tag, None)
232            self.pins.pop(node.out_pin_tag, None)
233            del_edge = [
234                edge_tag
235                for edge_tag, (src, dst) in self.edges.items()
236                if src == node.id or dst == node.id
237            ]
238            for edge in del_edge:
239                self.edges.pop(edge, None)
240            dpg.delete_item(node.tag)
241        for link_tag in dpg.get_selected_links("main_editor"):
242            if link_tag in self.edges:
243                self._on_delink(sender, link_tag)
244
245    def _on_canvas_click(self, sender, app_data):
246        if not dpg.is_item_hovered("main_editor"):
247            return
248
249        selected = dpg.get_selected_nodes("main_editor")
250        if selected:
251            node_tag = selected[0]
252            if node_tag in self.nodes:
253                self.inspector.inspect(
254                    self.nodes[node_tag], graph_context=self.graph_target
255                )
256
257    def on_pm_changed(self):
258        pm_inactive = self._pm is None
259        dpg.configure_item(self.editor_tag, show=not pm_inactive)
260        if pm_inactive:
261            dpg.delete_item(self.editor_tag, children_only=True)
262            self.nodes.clear()
263            self.pins.clear()
264            self.edges.clear()
265
266    def recenter_graph(self):
267        self.node_pos_to_api()
268        api_nodes = self._pm.execute_command(
269            target_obj=self.graph_target, target_func="get_nodes"
270        )
271        if not api_nodes or "start" not in api_nodes:
272            return
273        start_pos = api_nodes["start"].pos
274        x_change = 50 - start_pos[0]
275        y_change = 50 - start_pos[1]
276        for node in api_nodes.values():
277            node.pos = [node.pos[0] + x_change, node.pos[1] + y_change]
278        if dpg.does_item_exist(self.editor_tag):
279            dpg.delete_item(self.editor_tag)
280        with dpg.node_editor(
281            tag=self.editor_tag,
282            parent=self.tag,
283            callback=self._on_link,
284            delink_callback=self._on_delink,
285        ):
286            pass
287        self.load_graph_target()
class UIExecNode:
12class UIExecNode:
13    """Handes UI element of Execution Node within graph"""
14
15    def __init__(
16        self, node_id, blueprint_name, param_id, parent_editor="main_editor", pos=None
17    ):
18        self.id = node_id
19        self.blueprint_name = blueprint_name
20        self.param_id = param_id
21        self.tag = dpg.generate_uuid()
22        self.parent_editor = parent_editor
23
24        self.in_pin_tag = dpg.generate_uuid()
25        self.out_pin_tag = dpg.generate_uuid()
26        if pos:
27            initial_position = pos
28        else:
29            initial_position = [200 + (randint(0, 6) * 20), 200 + (randint(0, 6) * 20)]
30
31        # Visual layout
32        with dpg.node(
33            label=self.id, tag=self.tag, parent=self.parent_editor, pos=initial_position
34        ):
35            # Input Pin
36            with dpg.node_attribute(
37                tag=self.in_pin_tag,
38                attribute_type=dpg.mvNode_Attr_Input,
39                shape=dpg.mvNode_PinShape_TriangleFilled,
40            ):
41                dpg.add_text(" ")
42            # Output Pin
43            with dpg.node_attribute(
44                tag=self.out_pin_tag,
45                attribute_type=dpg.mvNode_Attr_Output,
46                shape=dpg.mvNode_PinShape_TriangleFilled,
47            ):
48                dpg.add_text(" ")

Handes UI element of Execution Node within graph

UIExecNode( node_id, blueprint_name, param_id, parent_editor='main_editor', pos=None)
15    def __init__(
16        self, node_id, blueprint_name, param_id, parent_editor="main_editor", pos=None
17    ):
18        self.id = node_id
19        self.blueprint_name = blueprint_name
20        self.param_id = param_id
21        self.tag = dpg.generate_uuid()
22        self.parent_editor = parent_editor
23
24        self.in_pin_tag = dpg.generate_uuid()
25        self.out_pin_tag = dpg.generate_uuid()
26        if pos:
27            initial_position = pos
28        else:
29            initial_position = [200 + (randint(0, 6) * 20), 200 + (randint(0, 6) * 20)]
30
31        # Visual layout
32        with dpg.node(
33            label=self.id, tag=self.tag, parent=self.parent_editor, pos=initial_position
34        ):
35            # Input Pin
36            with dpg.node_attribute(
37                tag=self.in_pin_tag,
38                attribute_type=dpg.mvNode_Attr_Input,
39                shape=dpg.mvNode_PinShape_TriangleFilled,
40            ):
41                dpg.add_text(" ")
42            # Output Pin
43            with dpg.node_attribute(
44                tag=self.out_pin_tag,
45                attribute_type=dpg.mvNode_Attr_Output,
46                shape=dpg.mvNode_PinShape_TriangleFilled,
47            ):
48                dpg.add_text(" ")
id
blueprint_name
param_id
tag
parent_editor
in_pin_tag
out_pin_tag
class UIExecGraph(gui.dag.pm_triggered_window.PmTriggeredWindow):
 51class UIExecGraph(PmTriggeredWindow):
 52    """Manages a single DAG at a time, allowing for adding and remove of nodes, etc."""
 53
 54    def __init__(
 55        self,
 56        inspector,
 57        project_manager: ProjectManager,
 58        graph_name=None,
 59        load_graph=False,
 60    ):
 61        super().__init__(project_manager)
 62
 63        self.inspector = inspector
 64        self._pm = project_manager
 65
 66        self.graph_name = graph_name
 67        self.graph_target = f"graphs.{graph_name}"
 68
 69        self.nodes = {}
 70        self.pins = {}
 71        self.edges = {}
 72        self.tag = "node_space_win"
 73        self.editor_tag = "main_editor"
 74        with dpg.window(label="Node Space", tag=self.tag):
 75            with dpg.node_editor(
 76                tag=self.editor_tag,
 77                callback=self._on_link,
 78                delink_callback=self._on_delink,
 79            ):
 80                pass
 81
 82        with dpg.handler_registry():
 83            dpg.add_key_press_handler(
 84                key=dpg.mvKey_Delete, callback=self._on_delete_node
 85            )
 86            dpg.add_mouse_click_handler(callback=self._on_canvas_click)
 87
 88        if load_graph:
 89            self.load_graph_target()
 90
 91    def load_graph_target(self, graph_name=None):
 92        """Loads the graph designated by graph_name within the project or refreshes current graph rendering"""
 93        if graph_name is not None:
 94            self.graph_name = graph_name
 95            self.graph_target = f"graphs.{graph_name}"
 96
 97        nodes: ExecutionNode = self._pm.execute_command(
 98            target_obj=self.graph_target, target_func="get_nodes"
 99        )
100        edges = self._pm.execute_command(
101            target_obj=self.graph_target, target_func="get_edges"
102        )
103        self.nodes = {}
104        id_to_ui = {}
105        self.pins = {}
106        self.edges = {}
107        dpg.delete_item("main_editor", children_only=True)
108        for node in nodes.values():
109            ui_node = UIExecNode(
110                node.id, node.blueprint_name, node.param_id, "main_editor", node.pos
111            )
112            self.nodes[ui_node.tag] = ui_node
113            self.pins[ui_node.in_pin_tag] = ui_node
114            self.pins[ui_node.out_pin_tag] = ui_node
115            id_to_ui[node.id] = ui_node
116
117        for from_node_id, to_node_id in edges:
118            from_tag = id_to_ui[from_node_id].out_pin_tag
119            to_tag = id_to_ui[to_node_id].in_pin_tag
120
121            new_edge_tag = dpg.add_node_link(from_tag, to_tag, parent="main_editor")
122            self.edges[new_edge_tag] = (from_node_id, to_node_id)
123
124    def node_pos_to_api(self):
125        if not self.graph_target:
126            return
127        nodes: dict = self._pm.execute_command(
128            target_obj=self.graph_target, target_func="get_nodes", do_params={}
129        )
130        if not nodes:
131            return
132        for ui_node in self.nodes.values():
133            pos = dpg.get_item_pos(ui_node.tag)
134            next_node: ExecutionNode = nodes.get(ui_node.id)
135            if next_node:
136                next_node.pos = pos
137            else:
138                m_log.warning(
139                    f"Could not find Node: {ui_node.id} when sending UI graph space locations to API"
140                )
141
142    def generate_node_id(self, blueprint_name):
143        existing = self._pm.execute_command(
144            target_obj=self.graph_target,
145            target_func="get_node",
146            do_params={"node_id": blueprint_name},
147        )
148        copy_no = 0
149        out_id = blueprint_name
150        while existing:
151            copy_no += 1
152            out_id = f"{blueprint_name}_{copy_no}"
153            existing = self._pm.execute_command(
154                target_obj=self.graph_target,
155                target_func="get_node",
156                do_params={"node_id": out_id},
157            )
158        return out_id
159
160    def add_node(self, blueprint_name, param_id="EMPTY"):
161        node_id = self.generate_node_id(blueprint_name)
162        self._pm.execute_command(
163            target_obj=self.graph_target,
164            target_func="create_add_new_node",
165            do_params={
166                "node_id": node_id,
167                "blueprint_name": blueprint_name,
168                "param_id": param_id,
169            },
170        )
171        new_node = self._pm.execute_command(
172            target_obj=self.graph_target,
173            target_func="get_node",
174            do_params={"node_id": node_id},
175        )
176        if not new_node:
177            m_log.error(f"Failed to create new_node {node_id} with {blueprint_name}")
178            return
179        ui_node = UIExecNode(node_id, blueprint_name, param_id, "main_editor")
180        self.nodes[ui_node.tag] = ui_node
181        self.pins[ui_node.in_pin_tag] = ui_node
182        self.pins[ui_node.out_pin_tag] = ui_node
183
184    def _on_link(self, sender, app_data):
185        node_tag_from, node_tag_to = app_data[0], app_data[1]
186        node_from, node_to = self.pins[node_tag_from], self.pins[node_tag_to]
187        if not node_from or not node_to:
188            m_log.warning(
189                f"Reference missing for node link {node_from if node_from else '[EMPTY]'} ---> {node_to if node_to else '[EMPTY]'} \n...Aborting"
190            )
191            self.load_graph_target()
192            return
193        if node_from == node_to:
194            m_log.warning(f"Cannot link node to itself, {node_from} ... Aborting")
195            return
196
197        self._pm.execute_command(
198            target_obj=self.graph_target,
199            target_func="add_edge",
200            do_params={"node_from": node_from.id, "node_to": node_to.id},
201        )
202        edge_tag = dpg.add_node_link(node_tag_from, node_tag_to, parent=sender)
203        self.edges[edge_tag] = (node_from.id, node_to.id)
204
205    def _on_delink(self, sender, app_data):
206        edge_tag = app_data
207        if edge_tag not in self.edges:
208            self.load_graph_target()
209            return
210        node_from_id, node_to_id = self.edges.pop(edge_tag)
211        self._pm.execute_command(
212            target_obj=self.graph_target,
213            target_func="remove_edge",
214            do_params={"node_from": node_from_id, "node_to": node_to_id},
215        )
216        dpg.delete_item(edge_tag)
217
218    def _on_delete_node(self, sender, app_data):
219        sel_nodes = dpg.get_selected_nodes("main_editor")
220        for node_tag in sel_nodes:
221            if node_tag not in self.nodes:
222                continue
223            if self.nodes[node_tag].id == "start":
224                m_log.warning("Cannot Delete Start node, ignored request")
225                continue
226            node = self.nodes.pop(node_tag)
227            self._pm.execute_command(
228                target_obj=self.graph_target,
229                target_func="remove_node",
230                do_params={"node_id": node.id},
231            )
232            self.pins.pop(node.in_pin_tag, None)
233            self.pins.pop(node.out_pin_tag, None)
234            del_edge = [
235                edge_tag
236                for edge_tag, (src, dst) in self.edges.items()
237                if src == node.id or dst == node.id
238            ]
239            for edge in del_edge:
240                self.edges.pop(edge, None)
241            dpg.delete_item(node.tag)
242        for link_tag in dpg.get_selected_links("main_editor"):
243            if link_tag in self.edges:
244                self._on_delink(sender, link_tag)
245
246    def _on_canvas_click(self, sender, app_data):
247        if not dpg.is_item_hovered("main_editor"):
248            return
249
250        selected = dpg.get_selected_nodes("main_editor")
251        if selected:
252            node_tag = selected[0]
253            if node_tag in self.nodes:
254                self.inspector.inspect(
255                    self.nodes[node_tag], graph_context=self.graph_target
256                )
257
258    def on_pm_changed(self):
259        pm_inactive = self._pm is None
260        dpg.configure_item(self.editor_tag, show=not pm_inactive)
261        if pm_inactive:
262            dpg.delete_item(self.editor_tag, children_only=True)
263            self.nodes.clear()
264            self.pins.clear()
265            self.edges.clear()
266
267    def recenter_graph(self):
268        self.node_pos_to_api()
269        api_nodes = self._pm.execute_command(
270            target_obj=self.graph_target, target_func="get_nodes"
271        )
272        if not api_nodes or "start" not in api_nodes:
273            return
274        start_pos = api_nodes["start"].pos
275        x_change = 50 - start_pos[0]
276        y_change = 50 - start_pos[1]
277        for node in api_nodes.values():
278            node.pos = [node.pos[0] + x_change, node.pos[1] + y_change]
279        if dpg.does_item_exist(self.editor_tag):
280            dpg.delete_item(self.editor_tag)
281        with dpg.node_editor(
282            tag=self.editor_tag,
283            parent=self.tag,
284            callback=self._on_link,
285            delink_callback=self._on_delink,
286        ):
287            pass
288        self.load_graph_target()

Manages a single DAG at a time, allowing for adding and remove of nodes, etc.

UIExecGraph( inspector, project_manager: api.project_management.project_manager.ProjectManager, graph_name=None, load_graph=False)
54    def __init__(
55        self,
56        inspector,
57        project_manager: ProjectManager,
58        graph_name=None,
59        load_graph=False,
60    ):
61        super().__init__(project_manager)
62
63        self.inspector = inspector
64        self._pm = project_manager
65
66        self.graph_name = graph_name
67        self.graph_target = f"graphs.{graph_name}"
68
69        self.nodes = {}
70        self.pins = {}
71        self.edges = {}
72        self.tag = "node_space_win"
73        self.editor_tag = "main_editor"
74        with dpg.window(label="Node Space", tag=self.tag):
75            with dpg.node_editor(
76                tag=self.editor_tag,
77                callback=self._on_link,
78                delink_callback=self._on_delink,
79            ):
80                pass
81
82        with dpg.handler_registry():
83            dpg.add_key_press_handler(
84                key=dpg.mvKey_Delete, callback=self._on_delete_node
85            )
86            dpg.add_mouse_click_handler(callback=self._on_canvas_click)
87
88        if load_graph:
89            self.load_graph_target()
inspector
graph_name
graph_target
nodes
pins
edges
tag
editor_tag
def load_graph_target(self, graph_name=None):
 91    def load_graph_target(self, graph_name=None):
 92        """Loads the graph designated by graph_name within the project or refreshes current graph rendering"""
 93        if graph_name is not None:
 94            self.graph_name = graph_name
 95            self.graph_target = f"graphs.{graph_name}"
 96
 97        nodes: ExecutionNode = self._pm.execute_command(
 98            target_obj=self.graph_target, target_func="get_nodes"
 99        )
100        edges = self._pm.execute_command(
101            target_obj=self.graph_target, target_func="get_edges"
102        )
103        self.nodes = {}
104        id_to_ui = {}
105        self.pins = {}
106        self.edges = {}
107        dpg.delete_item("main_editor", children_only=True)
108        for node in nodes.values():
109            ui_node = UIExecNode(
110                node.id, node.blueprint_name, node.param_id, "main_editor", node.pos
111            )
112            self.nodes[ui_node.tag] = ui_node
113            self.pins[ui_node.in_pin_tag] = ui_node
114            self.pins[ui_node.out_pin_tag] = ui_node
115            id_to_ui[node.id] = ui_node
116
117        for from_node_id, to_node_id in edges:
118            from_tag = id_to_ui[from_node_id].out_pin_tag
119            to_tag = id_to_ui[to_node_id].in_pin_tag
120
121            new_edge_tag = dpg.add_node_link(from_tag, to_tag, parent="main_editor")
122            self.edges[new_edge_tag] = (from_node_id, to_node_id)

Loads the graph designated by graph_name within the project or refreshes current graph rendering

def node_pos_to_api(self):
124    def node_pos_to_api(self):
125        if not self.graph_target:
126            return
127        nodes: dict = self._pm.execute_command(
128            target_obj=self.graph_target, target_func="get_nodes", do_params={}
129        )
130        if not nodes:
131            return
132        for ui_node in self.nodes.values():
133            pos = dpg.get_item_pos(ui_node.tag)
134            next_node: ExecutionNode = nodes.get(ui_node.id)
135            if next_node:
136                next_node.pos = pos
137            else:
138                m_log.warning(
139                    f"Could not find Node: {ui_node.id} when sending UI graph space locations to API"
140                )
def generate_node_id(self, blueprint_name):
142    def generate_node_id(self, blueprint_name):
143        existing = self._pm.execute_command(
144            target_obj=self.graph_target,
145            target_func="get_node",
146            do_params={"node_id": blueprint_name},
147        )
148        copy_no = 0
149        out_id = blueprint_name
150        while existing:
151            copy_no += 1
152            out_id = f"{blueprint_name}_{copy_no}"
153            existing = self._pm.execute_command(
154                target_obj=self.graph_target,
155                target_func="get_node",
156                do_params={"node_id": out_id},
157            )
158        return out_id
def add_node(self, blueprint_name, param_id='EMPTY'):
160    def add_node(self, blueprint_name, param_id="EMPTY"):
161        node_id = self.generate_node_id(blueprint_name)
162        self._pm.execute_command(
163            target_obj=self.graph_target,
164            target_func="create_add_new_node",
165            do_params={
166                "node_id": node_id,
167                "blueprint_name": blueprint_name,
168                "param_id": param_id,
169            },
170        )
171        new_node = self._pm.execute_command(
172            target_obj=self.graph_target,
173            target_func="get_node",
174            do_params={"node_id": node_id},
175        )
176        if not new_node:
177            m_log.error(f"Failed to create new_node {node_id} with {blueprint_name}")
178            return
179        ui_node = UIExecNode(node_id, blueprint_name, param_id, "main_editor")
180        self.nodes[ui_node.tag] = ui_node
181        self.pins[ui_node.in_pin_tag] = ui_node
182        self.pins[ui_node.out_pin_tag] = ui_node
def on_pm_changed(self):
258    def on_pm_changed(self):
259        pm_inactive = self._pm is None
260        dpg.configure_item(self.editor_tag, show=not pm_inactive)
261        if pm_inactive:
262            dpg.delete_item(self.editor_tag, children_only=True)
263            self.nodes.clear()
264            self.pins.clear()
265            self.edges.clear()
def recenter_graph(self):
267    def recenter_graph(self):
268        self.node_pos_to_api()
269        api_nodes = self._pm.execute_command(
270            target_obj=self.graph_target, target_func="get_nodes"
271        )
272        if not api_nodes or "start" not in api_nodes:
273            return
274        start_pos = api_nodes["start"].pos
275        x_change = 50 - start_pos[0]
276        y_change = 50 - start_pos[1]
277        for node in api_nodes.values():
278            node.pos = [node.pos[0] + x_change, node.pos[1] + y_change]
279        if dpg.does_item_exist(self.editor_tag):
280            dpg.delete_item(self.editor_tag)
281        with dpg.node_editor(
282            tag=self.editor_tag,
283            parent=self.tag,
284            callback=self._on_link,
285            delink_callback=self._on_delink,
286        ):
287            pass
288        self.load_graph_target()