refactoring and other refinement edits

Author: lindakladivova

gui/wxpython/jupyter_notebook/dialogs.py

@@ -1,5 +1,5 @@
 """
-@package jupyter_notebook.dialog
+@package jupyter_notebook.dialogs
 
 @brief Integration of Jupyter Notebook to GUI.
 
@@ -14,22 +14,21 @@
 @author Linda Karlovska <linda.karlovska seznam.cz>
 """
 
+import os
 from pathlib import Path
-import grass.script as gs
 
 import wx
 
+from grass.workflows.directory import get_default_jupyter_workdir
+
 
 class JupyterStartDialog(wx.Dialog):
-    """Dialog for selecting working directory and Jupyter startup options."""
+    """Dialog for selecting Jupyter startup options."""
 
     def __init__(self, parent):
-        wx.Dialog.__init__(
-            self, parent, title=_("Start Jupyter Notebook"), size=(500, 300)
-        )
-        env = gs.gisenv()
-        mapset_path = Path(env["GISDBASE"]) / env["LOCATION_NAME"] / env["MAPSET"]
-        self.default_dir = mapset_path / "notebooks"
+        super().__init__(parent, title=_("Start Jupyter Notebook"), size=(500, 300))
+
+        self.default_dir = get_default_jupyter_workdir()
 
         self.selected_dir = self.default_dir
         self.create_template = True
@@ -59,7 +58,7 @@ def __init__(self, parent):
         dir_sizer.Add(self.dir_picker, 0, wx.EXPAND | wx.ALL, 5)
         sizer.Add(dir_sizer, 0, wx.EXPAND | wx.ALL, 10)
 
-        # Jupyter startup section
+        # Template preference section
         options_box = wx.StaticBox(self, label=_("Options"))
         options_sizer = wx.StaticBoxSizer(options_box, wx.VERTICAL)
 
@@ -84,7 +83,6 @@ def __init__(self, parent):
 
         sizer.Add(options_sizer, 0, wx.EXPAND | wx.LEFT | wx.RIGHT, 10)
 
-        # OK / Cancel buttons
         btns = self.CreateSeparatedButtonSizer(wx.OK | wx.CANCEL)
         sizer.Add(btns, 0, wx.EXPAND | wx.ALL, 10)
 
@@ -105,7 +103,16 @@ def OnRadioToggle(self, event):
     def GetValues(self):
         """Return selected working directory and template preference."""
         if self.radio_custom.GetValue():
-            self.selected_dir = Path(self.dir_picker.GetPath())
+            path = Path(self.dir_picker.GetPath())
+
+            if not os.access(path, os.W_OK) or not os.access(path, os.X_OK):
+                wx.MessageBox(
+                    _("You do not have permission to write to the selected directory."),
+                    _("Error"),
+                    wx.ICON_ERROR,
+                )
+                return None
+            self.selected_dir = path
         else:
             self.selected_dir = self.default_dir
 

gui/wxpython/jupyter_notebook/panel.py

@@ -19,8 +19,7 @@
 import wx
 
 from main_window.page import MainPageBase
-from grass.workflows.directory import JupyterDirectoryManager
-from grass.workflows.server import JupyterServerInstance, JupyterServerRegistry
+from grass.workflows.environment import JupyterEnvironment
 
 from .notebook import JupyterAuiNotebook
 from .toolbars import JupyterToolbar
@@ -47,13 +46,9 @@ def __init__(
         self._giface = giface
         self.statusbar = statusbar
         self.workdir = workdir
-
         self.SetName("Jupyter")
 
-        self.directory_manager = JupyterDirectoryManager(
-            workdir=self.workdir, create_template=create_template
-        )
-        self.server_manager = JupyterServerInstance(workdir=self.workdir)
+        self.env = JupyterEnvironment(self.workdir, create_template)
 
         self.toolbar = JupyterToolbar(parent=self)
         self.aui_notebook = JupyterAuiNotebook(parent=self)
@@ -72,31 +67,38 @@ def _layout(self):
         self.Layout()
 
     def SetUpNotebookInterface(self):
-        """Start server and load files available in a working directory."""
-        # Prepare the working directory (find all existing files, copy a template file if needed)
-        self.directory_manager.prepare_files()
-
-        # Start the Jupyter server in the specified working directory
-        self.server_manager.start_server()
-
-        # Register server to server registry
-        JupyterServerRegistry.get().register(self.server_manager)
-
-        # Update the status bar with server info
-        status_msg = _(
-            "Jupyter server has started at {url} (PID: {pid}) in working directory {dir}"
-        ).format(
-            url=self.server_manager.server_url,
-            pid=self.server_manager.pid,
-            dir=self.workdir,
-        )
-        self.SetStatusText(status_msg, 0)
+        """Setup Jupyter notebook environment and load initial notebooks."""
+        try:
+            self.env.setup()
+        except Exception as e:
+            wx.MessageBox(
+                _("Failed to start Jupyter environment:\n{}").format(str(e)),
+                _("Startup Error"),
+                wx.ICON_ERROR,
+            )
+            return
 
-        # Load all existing files found in the working directory as separate tabs
-        for fname in self.directory_manager.files:
-            url = self.server_manager.get_url(fname.name)
+        # Load notebook tabs
+        for fname in self.env.directory.files:
+            try:
+                url = self.env.server.get_url(fname.name)
+            except RuntimeError as e:
+                wx.MessageBox(
+                    _("Failed to get Jupyter server URLt:\n{}").format(str(e)),
+                    _("Startup Error"),
+                    wx.ICON_ERROR,
+                )
+                return
             self.aui_notebook.AddPage(url=url, title=fname.name)
 
+        self.SetStatusText(
+            _("Jupyter server started at {url} (PID: {pid}), directory: {dir}").format(
+                url=self.env.server.server_url,
+                pid=self.env.server.pid,
+                dir=str(self.workdir),
+            )
+        )
+
     def Switch(self, file_name):
         """
         Switch to existing notebook tab.
@@ -114,9 +116,16 @@ def Open(self, file_name):
         Open a Jupyter notebook to a new tab and switch to it.
         :param file_name: Name of the .ipynb file (e.g., 'example.ipynb') (str).
         """
-        url = self.server_manager.get_url(file_name)
-        self.aui_notebook.AddPage(url=url, title=file_name)
-        self.aui_notebook.SetSelection(self.aui_notebook.GetPageCount() - 1)
+        try:
+            url = self.env.server.get_url(file_name)
+            self.aui_notebook.AddPage(url=url, title=file_name)
+            self.aui_notebook.SetSelection(self.aui_notebook.GetPageCount() - 1)
+        except RuntimeError as e:
+            wx.MessageBox(
+                _("Failed to get Jupyter server URL:\n{}").format(str(e)),
+                _("URL Error"),
+                wx.ICON_ERROR,
+            )
 
     def OpenOrSwitch(self, file_name):
         """
@@ -136,7 +145,7 @@ def Import(self, source_path, new_name=None):
         :param new_name: Optional new name for the imported file (str).
         """
         try:
-            path = self.directory_manager.import_file(source_path, new_name=new_name)
+            path = self.env.directory.import_file(source_path, new_name=new_name)
             self.Open(path.name)
             self.SetStatusText(_("File '{}' imported and opened.").format(path.name), 0)
         except Exception as e:
@@ -169,7 +178,7 @@ def OnImport(self, event=None):
 
             source_path = Path(dlg.GetPath())
             file_name = source_path.name
-            target_path = self.directory_manager.workdir / file_name
+            target_path = self.workdir / file_name
 
             # File is already in the working directory
             if source_path.resolve() == target_path.resolve():
@@ -222,7 +231,7 @@ def OnExport(self, event=None):
             destination_path = Path(dlg.GetPath())
 
             try:
-                self.directory_manager.export_file(
+                self.env.directory.export_file(
                     file_name, destination_path, overwrite=True
                 )
                 self.SetStatusText(
@@ -254,7 +263,7 @@ def OnCreate(self, event=None):
                 return
 
             try:
-                path = self.directory_manager.create_new_notebook(new_name=name)
+                path = self.env.directory.create_new_notebook(new_name=name)
             except Exception as e:
                 wx.MessageBox(
                     _("Failed to create notebook:\n{}").format(str(e)),
@@ -287,25 +296,25 @@ def OnCloseWindow(self, event):
                 event.Veto()
             return
 
-        if self.server_manager:
-            try:
-                # Stop the Jupyter server
-                self.server_manager.stop_server()
-
-                # Unregister server from server registry
-                JupyterServerRegistry.get().unregister(self.server_manager)
-                self.SetStatusText(_("Jupyter server has been stopped."), 0)
-            except RuntimeError as e:
-                wx.MessageBox(
-                    _("Failed to stop the Jupyter server:\n{}").format(str(e)),
-                    _("Error"),
-                    wx.ICON_ERROR | wx.OK,
-                )
-                self.SetStatusText(_("Failed to stop Jupyter server."), 0)
+        # Get server info
+        url = self.env.server.server_url
+        pid = self.env.server.pid
 
-        # Clean up the server manager
-        if hasattr(self.GetParent(), "jupyter_server_manager"):
-            self.GetParent().jupyter_server_manager = None
-
-        # Close the notebook panel
+        # Stop server and close panel
+        try:
+            self.env.stop()
+        except RuntimeError as e:
+            wx.MessageBox(
+                _("Failed to stop Jupyter server at {url} (PID: {pid}):\n{err}").format(
+                    url=url, pid=pid, err=str(e)
+                ),
+                caption=_("Error"),
+                style=wx.ICON_ERROR | wx.OK,
+            )
+            return
+        self.SetStatusText(
+            _("Jupyter server at {url} (PID: {pid}) has been stopped").format(
+                url=url, pid=pid
+            )
+        )
         self._onCloseWindow(event)

gui/wxpython/main_window/frame.py

@@ -907,7 +907,7 @@ def OnGModeler(self, event=None, cmd=None):
         self.mainnotebook.AddPage(gmodeler_panel, _("Graphical Modeler"))
 
     def OnJupyterNotebook(self, event=None, cmd=None):
-        """Launch Jupyter Notebook page. See OnJupyterNotebook documentation"""
+        """Launch Jupyter Notebook interface."""
         from jupyter_notebook.panel import JupyterPanel
         from jupyter_notebook.dialogs import JupyterStartDialog
 
@@ -921,6 +921,9 @@ def OnJupyterNotebook(self, event=None, cmd=None):
         values = dlg.GetValues()
         dlg.Destroy()
 
+        if not values:
+            return
+
         workdir = values["directory"]
         create_template = values["create_template"]
 
@@ -939,7 +942,7 @@ def OnJupyterNotebook(self, event=None, cmd=None):
         self.mainnotebook.AddPage(jupyter_panel, _("Jupyter Notebook"))
 
     def OnShowJupyterInfo(self, event=None):
-        """Show information dialog when Jupyter Notebook is not installed."""
+        """Show information dialog when Jupyter Notebook is not available."""
         if sys.platform.startswith("win"):
             message = _(
                 "Jupyter Notebook is currently not included in the Windows GRASS build process.\n"
@@ -2457,10 +2460,17 @@ def _closeWindow(self, event):
                 event.Veto()
             return
 
-        from grass.workflows import JupyterServerRegistry
-
-        JupyterServerRegistry.get().stop_all_servers()
+        # Stop all running Jupyter servers before destroying the GUI
+        from grass.workflows import JupyterEnvironment
 
+        try:
+            JupyterEnvironment.stop_all()
+        except RuntimeError as e:
+            wx.MessageBox(
+                _("Failed to stop Jupyter servers:\n{}").format(str(e)),
+                caption=_("Error"),
+                style=wx.ICON_ERROR | wx.OK,
+            )
         self.DisplayCloseAll()
 
         self._auimgr.UnInit()

python/grass/workflows/Makefile

@@ -5,7 +5,7 @@ include $(MODULE_TOPDIR)/include/Make/Python.make
 
 DSTDIR = $(ETC)/python/grass/workflows
 TEMPLATE_FILES = template_notebooks/welcome.ipynb template_notebooks/new.ipynb
-MODULES = server directory
+MODULES = server directory environment
 
 PYFILES = $(patsubst %,$(DSTDIR)/%.py,$(MODULES) __init__)
 PYCFILES = $(patsubst %,$(DSTDIR)/%.pyc,$(MODULES) __init__)

python/grass/workflows/__init__.py

@@ -15,7 +15,7 @@
 
 This module provides functionality for:
 - Starting and stopping local Jupyter Notebook servers inside a GRASS session
-- Managing notebook directories linked to specific GRASS mapsets
+- Managing notebook working directories
 - Creating default notebook templates for users
 - Supporting integration with the GUI (e.g., wxGUI) and other tools
 
@@ -32,10 +32,13 @@
 
 from .server import JupyterServerInstance, JupyterServerRegistry
 from .directory import JupyterDirectoryManager
+from .environment import JupyterEnvironment
 
 __all__ = [
     "Directory",
+    "Environment",
     "JupyterDirectoryManager",
+    "JupyterEnvironment",
     "JupyterServerInstance",
     "JupyterServerRegistry",
     "Server",