m_strat.gui.project_window

  1import os
  2
  3import dearpygui.dearpygui as dpg
  4
  5from api.logger import m_log
  6from api.project_management.project_manager import ProjectManager
  7from gui.dag.pm_triggered_window import PmTriggeredWindow
  8from gui.gui_helpers import dialog_for_user_input, tk_ask_directory
  9
 10usr_pth = os.path.expanduser("~")
 11INIT_PATH = os.path.join(usr_pth, "Documents")
 12if not os.path.exists(INIT_PATH):
 13    INIT_PATH = os.path.join(usr_pth, "My Documents")
 14    if not os.path.exists(INIT_PATH):
 15        INIT_PATH = usr_pth
 16usr_pth = None
 17
 18
 19class ProjectWindow(PmTriggeredWindow):
 20    def __init__(self, project_manager, app_manager):
 21        super().__init__(project_manager)
 22        self.tag = "project_window"
 23        self.app_manager = app_manager
 24        self.open_proj_dialog_tag = "proj_open_dialog"
 25        self.new_proj_dialog_tag = "proj_new_dialog"
 26
 27        with dpg.window(
 28            label="Project Manager",
 29            tag=self.tag,
 30            width=370,
 31            height=500,
 32            no_close=False,
 33            pos=[10, 30],
 34        ):
 35            dpg.add_spacer(height=25)
 36            dpg.add_text("Project Control")
 37            dpg.add_spacer(height=8)
 38
 39            # Project metadata/status display
 40            self.status_text = dpg.add_text("Status: No Project Loaded")
 41            self.path_text = dpg.add_text("Path: None")
 42            dpg.add_spacer(height=12)
 43
 44            # Basic administrative actions
 45            dpg.add_button(
 46                label="New Project...", callback=self._on_new_project, width=-1
 47            )
 48            dpg.add_button(
 49                label="Open Project...", callback=self._on_open_project, width=-1
 50            )
 51            self.save_btn = dpg.add_button(
 52                label="Save Project Changes",
 53                callback=self._on_save_project,
 54                width=-1,
 55                enabled=False,
 56                show=False,
 57            )
 58
 59            dpg.add_spacer(height=16)
 60            dpg.add_separator()
 61            dpg.add_spacer(height=8)
 62
 63            # Pipeline (Graph) list management
 64            self.pipeline_group = "pipeline_features_group"
 65            with dpg.group(tag=self.pipeline_group, show=False):
 66                dpg.add_text("Project Pipelines (Graphs)")
 67                self.graph_listbox = dpg.add_listbox(
 68                    items=[], width=-1, num_items=5, callback=self._on_graph_select
 69                )
 70
 71                with dpg.group(horizontal=True) as btn_grp:
 72                    self.create_graph_btn = dpg.add_button(
 73                        label="Create Pipeline",
 74                        callback=self._on_create_graph,
 75                        enabled=False,
 76                    )
 77                    self.duplicate_graph_btn = dpg.add_button(
 78                        label="Duplicate",
 79                        callback=self._on_duplicate_graph,
 80                        enabled=False,
 81                    )
 82                    self.rename_graph_btn = dpg.add_button(
 83                        label="Rename",
 84                        callback=self._on_rename_graph,
 85                        enabled=False,
 86                    )
 87                    dpg.add_spacer(width=12, parent=btn_grp)
 88                    self.delete_graph_btn = dpg.add_button(
 89                        label="Delete",
 90                        callback=self._on_delete_graph,
 91                        enabled=False,
 92                    )
 93                dpg.add_text("Execution Control")
 94                self.run_btn = dpg.add_button(
 95                    label="Run Pipeline",
 96                    callback=self._on_run_pipeline,
 97                    width=-1,
 98                    enabled=False,
 99                )
100
101        self.pm_toggled_gui_items.extend(
102            [
103                self.save_btn,
104                self.create_graph_btn,
105                self.duplicate_graph_btn,
106                self.rename_graph_btn,
107                self.graph_listbox,
108            ]
109        )
110        self.pm = project_manager
111
112    def _on_duplicate_graph(self, sender, app_data):
113        selected_graph = dpg.get_value(self.graph_listbox)
114        if not selected_graph:
115            return
116
117    def _on_rename_graph(self, sender, app_daat):
118        selected_graph = dpg.get_value(self.graph_listbox)
119        if not selected_graph:
120            return
121
122    def _on_new_project(self, sender, app_data):
123        folder_path = tk_ask_directory(
124            {
125                "title": "Select an empty folder for your new project",
126                "initialdir": INIT_PATH,
127            }
128        )
129        if not folder_path:
130            m_log.info("New project aborted: No folder selected.")
131            return
132
133        if not os.path.exists(folder_path) or len(os.listdir(folder_path)) > 0:
134            m_log.warning("New project aborted: Folder does not exist or is not empty.")
135            msg = "The project folder selected does not exists, is not empty or was invalid, try again!"
136            self.app_manager.on_show_pop_up(
137                window_title="Project Folder Invalid",
138                msg=msg,
139                on_ok=None,
140                on_cancel=None,
141                show_cancel=False,
142            )
143            return
144        try:
145            new_pm = ProjectManager(folder_path, load=False)
146        except Exception as e:
147            m_log.error(f"Failed to create new project: {e}")
148            return
149
150        self.app_manager.set_pm(new_pm)
151        self.pm = new_pm
152
153    def on_pm_changed(self):
154        super().on_pm_changed()
155
156        if self.pm:
157            dpg.configure_item(self.pipeline_group, show=True)
158            has_graphs = len(self.pm.graphs) > 0
159            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
160            dpg.set_value(self.path_text, f"Path: {self.pm.project_path}")
161            dpg.set_value(self.status_text, "Status: Project Active")
162
163            dpg.configure_item(self.run_btn, enabled=has_graphs)
164            dpg.configure_item(self.delete_graph_btn, enabled=has_graphs)
165            dpg.configure_item(self.duplicate_graph_btn, enabled=has_graphs)
166            dpg.configure_item(self.rename_graph_btn, enabled=has_graphs)
167            dpg.configure_item(self.save_btn, show=True)
168            dpg.configure_item(self.pipeline_group, show=True)
169
170            if has_graphs:
171                init_graph_open = list(self.pm.graphs.keys())[0]
172                self.app_manager.on_load_graph(init_graph_open)
173                dpg.set_value(self.graph_listbox, init_graph_open)
174        else:
175            dpg.configure_item(self.pipeline_group, show=False)
176            dpg.configure_item(self.graph_listbox, items=[])
177            dpg.set_value(self.path_text, "Path: None")
178            dpg.set_value(self.status_text, "Status: No Project Loaded")
179            dpg.configure_item(self.run_btn, enabled=False)
180            dpg.configure_item(self.delete_graph_btn, enabled=False)
181            dpg.configure_item(self.duplicate_graph_btn, enabled=False)
182            dpg.configure_item(self.rename_graph_btn, enabled=False)
183            dpg.configure_item(self.save_btn, show=False)
184            dpg.configure_item(self.pipeline_group, show=False)
185
186    def _on_open_project(self, sender, app_data):
187        folder_path = tk_ask_directory(
188            {"title": "Select Existing Project Folder", "initialdir": INIT_PATH}
189        )
190        if not folder_path:
191            m_log.info("Open project aborted: No folder selected.")
192            return
193        if not os.path.exists(folder_path) or len(os.listdir(folder_path)) == 0:
194            m_log.warning("Open project aborted: Folder does not exist or is empty.")
195            msg = "The project folder selected does not exists, is empty or was invalid, try again!"
196            self.app_manager.on_show_pop_up(
197                window_title="Project Folder Invalid",
198                msg=msg,
199                on_ok=None,
200                on_cancel=None,
201                show_cancel=False,
202            )
203            return
204        try:
205            new_pm = ProjectManager(folder_path, load=True)
206        except Exception as e:
207            m_log.error(f"Failed to load project path (Incorrect folder?):{e}")
208            return
209
210        self.app_manager.set_pm(new_pm)
211        self.pm = new_pm
212
213    def _on_save_project(self, sender, app_data):
214        if self.pm:
215            self.app_manager.window_exec_graph.node_pos_to_api()
216            self.pm.save_project()
217
218    def _on_graph_select(self, sender, app_data):
219        selected_graph = app_data
220        self.app_manager.on_load_graph(selected_graph)
221        dpg.configure_item(self.run_btn, enabled=True)
222        dpg.configure_item(self.delete_graph_btn, enabled=True)
223        dpg.configure_item(self.duplicate_graph_btn, enabled=True)
224        dpg.configure_item(self.rename_graph_btn, enabled=True)
225
226    def _on_create_graph(self, sender, app_data):
227
228        def on_create_confirmed(new_graph_name: str):
229            new_graph_name = new_graph_name.strip()
230            if not new_graph_name:
231                m_log.info("Create graph aborted: Empty name provided.")
232                return
233            try:
234                self.pm.add_graph(new_graph_name)
235            except ValueError as e:
236                m_log.error("Failed To create new graph: {e}")
237                self.app_manager.on_show_pop_up(
238                    "Error", f"Failed to create new graph: {e}"
239                )
240                return
241
242            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
243
244        dialog_for_user_input(
245            header="Create New Pipeline",
246            msg="Enter a unique name for this pipeline:",
247            val_type=str,
248            on_confirm=on_create_confirmed,
249        )
250
251    def _on_delete_graph(self, sender, app_data):
252        selected_graph = dpg.get_value(self.graph_listbox)
253        if not selected_graph:
254            m_log.info("Delete graph aborted: No graph selected.")
255            return
256        self.pm.delete_graph(selected_graph)
257
258        if self.app_manager.window_exec_graph.graph_name == selected_graph:
259            self.app_manager.window_exec_graph.graph_name = None
260            self.app_manager.window_exec_graph.graph_target = None
261            dpg.delete_item("main_editor", children_only=True)
262            self.app_manager.window_exec_graph.nodes.clear()
263            self.app_manager.window_exec_graph.pins.clear()
264            self.app_manager.window_exec_graph.edges.clear()
265
266        dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
267        dpg.set_value(self.graph_listbox, "")
268        dpg.configure_item(self.run_btn, enabled=False)
269        dpg.configure_item(self.delete_graph_btn, enabled=False)
270        dpg.configure_item(self.duplicate_graph_btn, enabled=False)
271        dpg.configure_item(self.rename_graph_btn, enabled=False)
272
273    def _on_duplicate_graph(self, sender, app_data):
274        selected_graph = dpg.get_value(self.graph_listbox)
275        if not selected_graph:
276            m_log.info("Duplicate graph aborted: No graph selected.")
277            return
278
279        def on_duplicate_confirmed(new_graph_name: str):
280            new_graph_name = new_graph_name.strip()
281            self.app_manager
282            if not new_graph_name:
283                m_log.info("Duplicate graph aborted: Empty name provided.")
284                return
285            try:
286                if self.app_manager.window_exec_graph.graph_name == selected_graph:
287                    self.app_manager.window_exec_graph.node_pos_to_api()
288                self.pm.duplicate_graph(selected_graph, new_graph_name)
289            except Exception as e:
290                m_log.error(f"Failed to duplicate graph: {e}")
291                self.app_manager.on_show_pop_up(
292                    "Error", f"Failed to duplicate graph: {e}"
293                )
294                return
295            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
296            m_log.info(
297                f"Successfully duplicated '{selected_graph}' to '{new_graph_name}'"
298            )
299
300        dialog_for_user_input(
301            header="Duplicate Pipeline",
302            msg=f"Enter a unique name for the duplicate of '{selected_graph}':",
303            val_type=str,
304            on_confirm=on_duplicate_confirmed,
305        )
306
307    def _on_rename_graph(self, sender, app_data):
308        selected_graph = dpg.get_value(self.graph_listbox)
309        if not selected_graph:
310            m_log.info("Rename graph aborted: No graph selected.")
311            return
312
313        def on_rename_confirmed(new_graph_name: str):
314            new_graph_name = new_graph_name.strip()
315            if not new_graph_name:
316                m_log.info("Rename graph aborted: Empty name provided.")
317                return
318            try:
319                if self.app_manager.window_exec_graph.graph_name == selected_graph:
320                    self.app_manager.window_exec_graph.node_pos_to_api()
321
322                self.pm.rename_graph(selected_graph, new_graph_name)
323
324                if self.app_manager.window_exec_graph.graph_name == selected_graph:
325                    self.app_manager.window_exec_graph.graph_name = None
326                    self.app_manager.window_exec_graph.graph_target = None
327
328            except Exception as e:
329                m_log.error(f"Failed to rename graph: {e}")
330                self.app_manager.on_show_pop_up("Error", f"Failed to rename graph: {e}")
331                return
332            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
333            dpg.set_value(self.graph_listbox, new_graph_name)
334            self.app_manager.on_load_graph(new_graph_name)
335            m_log.info(f"Successfully renamed '{selected_graph}' to '{new_graph_name}'")
336
337        dialog_for_user_input(
338            header="Rename Pipeline",
339            msg=f"Enter a new unique name for '{selected_graph}':",
340            val_type=str,
341            on_confirm=on_rename_confirmed,
342        )
343
344    def _on_run_pipeline(self, sender, app_data):
345        selected_graph = dpg.get_value(self.graph_listbox)
346        if not selected_graph:
347            m_log.warning("Run pipeline aborted: No pipeline selected.")
348            self.app_manager.on_show_pop_up(
349                "Error", "Please select a pipeline from the list first."
350            )
351            return
352        exec_lbl = f"run_{selected_graph}"
353        try:
354            if self.pm.executors.get(exec_lbl, None) is None:
355                self.pm.create_executor(
356                    graph_name=selected_graph,
357                    exec_lbl=exec_lbl,
358                    executor_type_name="Sequential",
359                )
360            self.pm.run_executor(exec_lbl)
361            m_log.success("Pipeline started")
362
363        except Exception as e:
364            self.app_manager.on_show_pop_up(
365                window_title="Execution Failed", msg=f"Error running pipeline: {str(e)}"
366            )
usr_pth = None
INIT_PATH = 'C:\\Users\\pvita\\Documents'
class ProjectWindow(gui.dag.pm_triggered_window.PmTriggeredWindow):
 20class ProjectWindow(PmTriggeredWindow):
 21    def __init__(self, project_manager, app_manager):
 22        super().__init__(project_manager)
 23        self.tag = "project_window"
 24        self.app_manager = app_manager
 25        self.open_proj_dialog_tag = "proj_open_dialog"
 26        self.new_proj_dialog_tag = "proj_new_dialog"
 27
 28        with dpg.window(
 29            label="Project Manager",
 30            tag=self.tag,
 31            width=370,
 32            height=500,
 33            no_close=False,
 34            pos=[10, 30],
 35        ):
 36            dpg.add_spacer(height=25)
 37            dpg.add_text("Project Control")
 38            dpg.add_spacer(height=8)
 39
 40            # Project metadata/status display
 41            self.status_text = dpg.add_text("Status: No Project Loaded")
 42            self.path_text = dpg.add_text("Path: None")
 43            dpg.add_spacer(height=12)
 44
 45            # Basic administrative actions
 46            dpg.add_button(
 47                label="New Project...", callback=self._on_new_project, width=-1
 48            )
 49            dpg.add_button(
 50                label="Open Project...", callback=self._on_open_project, width=-1
 51            )
 52            self.save_btn = dpg.add_button(
 53                label="Save Project Changes",
 54                callback=self._on_save_project,
 55                width=-1,
 56                enabled=False,
 57                show=False,
 58            )
 59
 60            dpg.add_spacer(height=16)
 61            dpg.add_separator()
 62            dpg.add_spacer(height=8)
 63
 64            # Pipeline (Graph) list management
 65            self.pipeline_group = "pipeline_features_group"
 66            with dpg.group(tag=self.pipeline_group, show=False):
 67                dpg.add_text("Project Pipelines (Graphs)")
 68                self.graph_listbox = dpg.add_listbox(
 69                    items=[], width=-1, num_items=5, callback=self._on_graph_select
 70                )
 71
 72                with dpg.group(horizontal=True) as btn_grp:
 73                    self.create_graph_btn = dpg.add_button(
 74                        label="Create Pipeline",
 75                        callback=self._on_create_graph,
 76                        enabled=False,
 77                    )
 78                    self.duplicate_graph_btn = dpg.add_button(
 79                        label="Duplicate",
 80                        callback=self._on_duplicate_graph,
 81                        enabled=False,
 82                    )
 83                    self.rename_graph_btn = dpg.add_button(
 84                        label="Rename",
 85                        callback=self._on_rename_graph,
 86                        enabled=False,
 87                    )
 88                    dpg.add_spacer(width=12, parent=btn_grp)
 89                    self.delete_graph_btn = dpg.add_button(
 90                        label="Delete",
 91                        callback=self._on_delete_graph,
 92                        enabled=False,
 93                    )
 94                dpg.add_text("Execution Control")
 95                self.run_btn = dpg.add_button(
 96                    label="Run Pipeline",
 97                    callback=self._on_run_pipeline,
 98                    width=-1,
 99                    enabled=False,
100                )
101
102        self.pm_toggled_gui_items.extend(
103            [
104                self.save_btn,
105                self.create_graph_btn,
106                self.duplicate_graph_btn,
107                self.rename_graph_btn,
108                self.graph_listbox,
109            ]
110        )
111        self.pm = project_manager
112
113    def _on_duplicate_graph(self, sender, app_data):
114        selected_graph = dpg.get_value(self.graph_listbox)
115        if not selected_graph:
116            return
117
118    def _on_rename_graph(self, sender, app_daat):
119        selected_graph = dpg.get_value(self.graph_listbox)
120        if not selected_graph:
121            return
122
123    def _on_new_project(self, sender, app_data):
124        folder_path = tk_ask_directory(
125            {
126                "title": "Select an empty folder for your new project",
127                "initialdir": INIT_PATH,
128            }
129        )
130        if not folder_path:
131            m_log.info("New project aborted: No folder selected.")
132            return
133
134        if not os.path.exists(folder_path) or len(os.listdir(folder_path)) > 0:
135            m_log.warning("New project aborted: Folder does not exist or is not empty.")
136            msg = "The project folder selected does not exists, is not empty or was invalid, try again!"
137            self.app_manager.on_show_pop_up(
138                window_title="Project Folder Invalid",
139                msg=msg,
140                on_ok=None,
141                on_cancel=None,
142                show_cancel=False,
143            )
144            return
145        try:
146            new_pm = ProjectManager(folder_path, load=False)
147        except Exception as e:
148            m_log.error(f"Failed to create new project: {e}")
149            return
150
151        self.app_manager.set_pm(new_pm)
152        self.pm = new_pm
153
154    def on_pm_changed(self):
155        super().on_pm_changed()
156
157        if self.pm:
158            dpg.configure_item(self.pipeline_group, show=True)
159            has_graphs = len(self.pm.graphs) > 0
160            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
161            dpg.set_value(self.path_text, f"Path: {self.pm.project_path}")
162            dpg.set_value(self.status_text, "Status: Project Active")
163
164            dpg.configure_item(self.run_btn, enabled=has_graphs)
165            dpg.configure_item(self.delete_graph_btn, enabled=has_graphs)
166            dpg.configure_item(self.duplicate_graph_btn, enabled=has_graphs)
167            dpg.configure_item(self.rename_graph_btn, enabled=has_graphs)
168            dpg.configure_item(self.save_btn, show=True)
169            dpg.configure_item(self.pipeline_group, show=True)
170
171            if has_graphs:
172                init_graph_open = list(self.pm.graphs.keys())[0]
173                self.app_manager.on_load_graph(init_graph_open)
174                dpg.set_value(self.graph_listbox, init_graph_open)
175        else:
176            dpg.configure_item(self.pipeline_group, show=False)
177            dpg.configure_item(self.graph_listbox, items=[])
178            dpg.set_value(self.path_text, "Path: None")
179            dpg.set_value(self.status_text, "Status: No Project Loaded")
180            dpg.configure_item(self.run_btn, enabled=False)
181            dpg.configure_item(self.delete_graph_btn, enabled=False)
182            dpg.configure_item(self.duplicate_graph_btn, enabled=False)
183            dpg.configure_item(self.rename_graph_btn, enabled=False)
184            dpg.configure_item(self.save_btn, show=False)
185            dpg.configure_item(self.pipeline_group, show=False)
186
187    def _on_open_project(self, sender, app_data):
188        folder_path = tk_ask_directory(
189            {"title": "Select Existing Project Folder", "initialdir": INIT_PATH}
190        )
191        if not folder_path:
192            m_log.info("Open project aborted: No folder selected.")
193            return
194        if not os.path.exists(folder_path) or len(os.listdir(folder_path)) == 0:
195            m_log.warning("Open project aborted: Folder does not exist or is empty.")
196            msg = "The project folder selected does not exists, is empty or was invalid, try again!"
197            self.app_manager.on_show_pop_up(
198                window_title="Project Folder Invalid",
199                msg=msg,
200                on_ok=None,
201                on_cancel=None,
202                show_cancel=False,
203            )
204            return
205        try:
206            new_pm = ProjectManager(folder_path, load=True)
207        except Exception as e:
208            m_log.error(f"Failed to load project path (Incorrect folder?):{e}")
209            return
210
211        self.app_manager.set_pm(new_pm)
212        self.pm = new_pm
213
214    def _on_save_project(self, sender, app_data):
215        if self.pm:
216            self.app_manager.window_exec_graph.node_pos_to_api()
217            self.pm.save_project()
218
219    def _on_graph_select(self, sender, app_data):
220        selected_graph = app_data
221        self.app_manager.on_load_graph(selected_graph)
222        dpg.configure_item(self.run_btn, enabled=True)
223        dpg.configure_item(self.delete_graph_btn, enabled=True)
224        dpg.configure_item(self.duplicate_graph_btn, enabled=True)
225        dpg.configure_item(self.rename_graph_btn, enabled=True)
226
227    def _on_create_graph(self, sender, app_data):
228
229        def on_create_confirmed(new_graph_name: str):
230            new_graph_name = new_graph_name.strip()
231            if not new_graph_name:
232                m_log.info("Create graph aborted: Empty name provided.")
233                return
234            try:
235                self.pm.add_graph(new_graph_name)
236            except ValueError as e:
237                m_log.error("Failed To create new graph: {e}")
238                self.app_manager.on_show_pop_up(
239                    "Error", f"Failed to create new graph: {e}"
240                )
241                return
242
243            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
244
245        dialog_for_user_input(
246            header="Create New Pipeline",
247            msg="Enter a unique name for this pipeline:",
248            val_type=str,
249            on_confirm=on_create_confirmed,
250        )
251
252    def _on_delete_graph(self, sender, app_data):
253        selected_graph = dpg.get_value(self.graph_listbox)
254        if not selected_graph:
255            m_log.info("Delete graph aborted: No graph selected.")
256            return
257        self.pm.delete_graph(selected_graph)
258
259        if self.app_manager.window_exec_graph.graph_name == selected_graph:
260            self.app_manager.window_exec_graph.graph_name = None
261            self.app_manager.window_exec_graph.graph_target = None
262            dpg.delete_item("main_editor", children_only=True)
263            self.app_manager.window_exec_graph.nodes.clear()
264            self.app_manager.window_exec_graph.pins.clear()
265            self.app_manager.window_exec_graph.edges.clear()
266
267        dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
268        dpg.set_value(self.graph_listbox, "")
269        dpg.configure_item(self.run_btn, enabled=False)
270        dpg.configure_item(self.delete_graph_btn, enabled=False)
271        dpg.configure_item(self.duplicate_graph_btn, enabled=False)
272        dpg.configure_item(self.rename_graph_btn, enabled=False)
273
274    def _on_duplicate_graph(self, sender, app_data):
275        selected_graph = dpg.get_value(self.graph_listbox)
276        if not selected_graph:
277            m_log.info("Duplicate graph aborted: No graph selected.")
278            return
279
280        def on_duplicate_confirmed(new_graph_name: str):
281            new_graph_name = new_graph_name.strip()
282            self.app_manager
283            if not new_graph_name:
284                m_log.info("Duplicate graph aborted: Empty name provided.")
285                return
286            try:
287                if self.app_manager.window_exec_graph.graph_name == selected_graph:
288                    self.app_manager.window_exec_graph.node_pos_to_api()
289                self.pm.duplicate_graph(selected_graph, new_graph_name)
290            except Exception as e:
291                m_log.error(f"Failed to duplicate graph: {e}")
292                self.app_manager.on_show_pop_up(
293                    "Error", f"Failed to duplicate graph: {e}"
294                )
295                return
296            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
297            m_log.info(
298                f"Successfully duplicated '{selected_graph}' to '{new_graph_name}'"
299            )
300
301        dialog_for_user_input(
302            header="Duplicate Pipeline",
303            msg=f"Enter a unique name for the duplicate of '{selected_graph}':",
304            val_type=str,
305            on_confirm=on_duplicate_confirmed,
306        )
307
308    def _on_rename_graph(self, sender, app_data):
309        selected_graph = dpg.get_value(self.graph_listbox)
310        if not selected_graph:
311            m_log.info("Rename graph aborted: No graph selected.")
312            return
313
314        def on_rename_confirmed(new_graph_name: str):
315            new_graph_name = new_graph_name.strip()
316            if not new_graph_name:
317                m_log.info("Rename graph aborted: Empty name provided.")
318                return
319            try:
320                if self.app_manager.window_exec_graph.graph_name == selected_graph:
321                    self.app_manager.window_exec_graph.node_pos_to_api()
322
323                self.pm.rename_graph(selected_graph, new_graph_name)
324
325                if self.app_manager.window_exec_graph.graph_name == selected_graph:
326                    self.app_manager.window_exec_graph.graph_name = None
327                    self.app_manager.window_exec_graph.graph_target = None
328
329            except Exception as e:
330                m_log.error(f"Failed to rename graph: {e}")
331                self.app_manager.on_show_pop_up("Error", f"Failed to rename graph: {e}")
332                return
333            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
334            dpg.set_value(self.graph_listbox, new_graph_name)
335            self.app_manager.on_load_graph(new_graph_name)
336            m_log.info(f"Successfully renamed '{selected_graph}' to '{new_graph_name}'")
337
338        dialog_for_user_input(
339            header="Rename Pipeline",
340            msg=f"Enter a new unique name for '{selected_graph}':",
341            val_type=str,
342            on_confirm=on_rename_confirmed,
343        )
344
345    def _on_run_pipeline(self, sender, app_data):
346        selected_graph = dpg.get_value(self.graph_listbox)
347        if not selected_graph:
348            m_log.warning("Run pipeline aborted: No pipeline selected.")
349            self.app_manager.on_show_pop_up(
350                "Error", "Please select a pipeline from the list first."
351            )
352            return
353        exec_lbl = f"run_{selected_graph}"
354        try:
355            if self.pm.executors.get(exec_lbl, None) is None:
356                self.pm.create_executor(
357                    graph_name=selected_graph,
358                    exec_lbl=exec_lbl,
359                    executor_type_name="Sequential",
360                )
361            self.pm.run_executor(exec_lbl)
362            m_log.success("Pipeline started")
363
364        except Exception as e:
365            self.app_manager.on_show_pop_up(
366                window_title="Execution Failed", msg=f"Error running pipeline: {str(e)}"
367            )

Inherited class for all GUIs to add events when project is loaded

ProjectWindow(project_manager, app_manager)
 21    def __init__(self, project_manager, app_manager):
 22        super().__init__(project_manager)
 23        self.tag = "project_window"
 24        self.app_manager = app_manager
 25        self.open_proj_dialog_tag = "proj_open_dialog"
 26        self.new_proj_dialog_tag = "proj_new_dialog"
 27
 28        with dpg.window(
 29            label="Project Manager",
 30            tag=self.tag,
 31            width=370,
 32            height=500,
 33            no_close=False,
 34            pos=[10, 30],
 35        ):
 36            dpg.add_spacer(height=25)
 37            dpg.add_text("Project Control")
 38            dpg.add_spacer(height=8)
 39
 40            # Project metadata/status display
 41            self.status_text = dpg.add_text("Status: No Project Loaded")
 42            self.path_text = dpg.add_text("Path: None")
 43            dpg.add_spacer(height=12)
 44
 45            # Basic administrative actions
 46            dpg.add_button(
 47                label="New Project...", callback=self._on_new_project, width=-1
 48            )
 49            dpg.add_button(
 50                label="Open Project...", callback=self._on_open_project, width=-1
 51            )
 52            self.save_btn = dpg.add_button(
 53                label="Save Project Changes",
 54                callback=self._on_save_project,
 55                width=-1,
 56                enabled=False,
 57                show=False,
 58            )
 59
 60            dpg.add_spacer(height=16)
 61            dpg.add_separator()
 62            dpg.add_spacer(height=8)
 63
 64            # Pipeline (Graph) list management
 65            self.pipeline_group = "pipeline_features_group"
 66            with dpg.group(tag=self.pipeline_group, show=False):
 67                dpg.add_text("Project Pipelines (Graphs)")
 68                self.graph_listbox = dpg.add_listbox(
 69                    items=[], width=-1, num_items=5, callback=self._on_graph_select
 70                )
 71
 72                with dpg.group(horizontal=True) as btn_grp:
 73                    self.create_graph_btn = dpg.add_button(
 74                        label="Create Pipeline",
 75                        callback=self._on_create_graph,
 76                        enabled=False,
 77                    )
 78                    self.duplicate_graph_btn = dpg.add_button(
 79                        label="Duplicate",
 80                        callback=self._on_duplicate_graph,
 81                        enabled=False,
 82                    )
 83                    self.rename_graph_btn = dpg.add_button(
 84                        label="Rename",
 85                        callback=self._on_rename_graph,
 86                        enabled=False,
 87                    )
 88                    dpg.add_spacer(width=12, parent=btn_grp)
 89                    self.delete_graph_btn = dpg.add_button(
 90                        label="Delete",
 91                        callback=self._on_delete_graph,
 92                        enabled=False,
 93                    )
 94                dpg.add_text("Execution Control")
 95                self.run_btn = dpg.add_button(
 96                    label="Run Pipeline",
 97                    callback=self._on_run_pipeline,
 98                    width=-1,
 99                    enabled=False,
100                )
101
102        self.pm_toggled_gui_items.extend(
103            [
104                self.save_btn,
105                self.create_graph_btn,
106                self.duplicate_graph_btn,
107                self.rename_graph_btn,
108                self.graph_listbox,
109            ]
110        )
111        self.pm = project_manager
tag
app_manager
open_proj_dialog_tag
new_proj_dialog_tag
pm
14    @property
15    def pm(self):
16        return self._pm
def on_pm_changed(self):
154    def on_pm_changed(self):
155        super().on_pm_changed()
156
157        if self.pm:
158            dpg.configure_item(self.pipeline_group, show=True)
159            has_graphs = len(self.pm.graphs) > 0
160            dpg.configure_item(self.graph_listbox, items=list(self.pm.graphs.keys()))
161            dpg.set_value(self.path_text, f"Path: {self.pm.project_path}")
162            dpg.set_value(self.status_text, "Status: Project Active")
163
164            dpg.configure_item(self.run_btn, enabled=has_graphs)
165            dpg.configure_item(self.delete_graph_btn, enabled=has_graphs)
166            dpg.configure_item(self.duplicate_graph_btn, enabled=has_graphs)
167            dpg.configure_item(self.rename_graph_btn, enabled=has_graphs)
168            dpg.configure_item(self.save_btn, show=True)
169            dpg.configure_item(self.pipeline_group, show=True)
170
171            if has_graphs:
172                init_graph_open = list(self.pm.graphs.keys())[0]
173                self.app_manager.on_load_graph(init_graph_open)
174                dpg.set_value(self.graph_listbox, init_graph_open)
175        else:
176            dpg.configure_item(self.pipeline_group, show=False)
177            dpg.configure_item(self.graph_listbox, items=[])
178            dpg.set_value(self.path_text, "Path: None")
179            dpg.set_value(self.status_text, "Status: No Project Loaded")
180            dpg.configure_item(self.run_btn, enabled=False)
181            dpg.configure_item(self.delete_graph_btn, enabled=False)
182            dpg.configure_item(self.duplicate_graph_btn, enabled=False)
183            dpg.configure_item(self.rename_graph_btn, enabled=False)
184            dpg.configure_item(self.save_btn, show=False)
185            dpg.configure_item(self.pipeline_group, show=False)