type notations and smaller refactoring, creating some global variables

Author: lindakladivova

gui/wxpython/jupyter_notebook/dialogs.py

@@ -17,8 +17,7 @@
 from pathlib import Path
 import wx
 
-from .utils import get_project_jupyter_storage
-from .storage import WELCOME_NOTEBOOK_NAME
+from .storage import WELCOME_NOTEBOOK_NAME, get_project_jupyter_storage
 
 
 class JupyterStartDialog(wx.Dialog):

gui/wxpython/jupyter_notebook/environment.py

@@ -22,50 +22,63 @@
 
 
 class JupyterEnvironment:
-    """Orchestrates storage manager and Jupyter server lifecycle.
+    """Orchestrates storage manager and Jupyter server lifecycle."""
 
-    :param storage: Storage for notebooks
-    :param create_template: Whether to create template notebooks
-    """
+    def __init__(self, storage: Path | None, create_template: bool) -> None:
+        """Initialize Jupyter environment.
 
-    def __init__(self, storage, create_template):
+        :param storage: Storage path for notebooks
+        :param create_template: Whether to create template notebooks
+        """
         self.storage_manager = JupyterStorageManager(storage, create_template)
         self.server = JupyterServerInstance(storage)
 
-    def setup(self):
+    def setup(self) -> None:
         """Prepare files and start server."""
         # Prepare files
         self.storage_manager.prepare_files()
 
         # Start server
         self.server.start_server()
 
-    def stop(self):
+    def stop(self) -> None:
         """Stop server and unregister it."""
         self.server.stop_server()
         JupyterServerRegistry.get().unregister(self.server)
 
     @classmethod
-    def stop_all(cls):
+    def stop_all(cls) -> None:
         """Stop all running Jupyter servers and unregister them."""
         JupyterServerRegistry.get().stop_all_servers()
 
     @property
-    def server_url(self):
-        """Get server URL."""
+    def server_url(self) -> str | None:
+        """Get server URL.
+
+        :return: Server URL or None if server is not available
+        """
         return self.server.server_url if self.server else None
 
     @property
-    def pid(self):
-        """Get server process ID."""
+    def pid(self) -> int | None:
+        """Get server process ID.
+
+        :return: Process ID or None if server is not running
+        """
         return self.server.pid if self.server else None
 
     @property
-    def storage(self):
-        """Get Jupyter notebook storage."""
+    def storage(self) -> Path | None:
+        """Get Jupyter notebook storage path.
+
+        :return: Storage path or None if storage manager is not available
+        """
         return self.storage_manager.storage if self.storage_manager else None
 
     @property
     def files(self) -> list[Path]:
-        """Return list of notebook files."""
+        """Return list of notebook files.
+
+        :return: List of notebook file paths
+        """
         return self.storage_manager.files if self.storage_manager else []

gui/wxpython/jupyter_notebook/frame.py

@@ -30,15 +30,26 @@ class JupyterFrame(wx.Frame):
 
     def __init__(
         self,
-        parent,
+        parent: wx.Window,
         giface,
-        action="integrated",
-        storage=None,
-        create_template=False,
-        id=wx.ID_ANY,
-        title=_("Jupyter Notebook"),
+        action: str = "integrated",
+        storage: Path | None = None,
+        create_template: bool = False,
+        id: int = wx.ID_ANY,
+        title: str = _("Jupyter Notebook"),
         **kwargs,
-    ):
+    ) -> None:
+        """Initialize Jupyter frame.
+
+        :param parent: Parent window
+        :param giface: GRASS interface
+        :param action: Mode - "integrated" or "browser"
+        :param storage: Storage path for notebooks
+        :param create_template: Whether to create template notebooks
+        :param id: Window ID
+        :param title: Frame title
+        :param kwargs: Additional arguments passed to wx.Frame
+        """
         super().__init__(parent=parent, id=id, title=title, **kwargs)
 
         self.SetName("JupyterFrame")
@@ -110,7 +121,8 @@ def __init__(
 
         self._layout()
 
-    def _layout(self):
+    def _layout(self) -> None:
+        """Setup frame layout and size."""
         if self.panel:
             sizer = wx.BoxSizer(wx.VERTICAL)
             sizer.Add(self.panel, 1, wx.EXPAND)
@@ -120,7 +132,11 @@ def _layout(self):
 
             self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 
-    def OnCloseWindow(self, event):
+    def OnCloseWindow(self, event: wx.CloseEvent) -> None:
+        """Handle window close event.
+
+        :param event: Close event
+        """
         if self.panel and hasattr(self.panel, "OnCloseWindow"):
             self.panel.OnCloseWindow(event)
 

gui/wxpython/jupyter_notebook/notebook.py

@@ -39,19 +39,19 @@ class JupyterAuiNotebook(aui.AuiNotebook):
 
     def __init__(
         self,
-        parent,
-        agwStyle=aui.AUI_NB_DEFAULT_STYLE
+        parent: wx.Window,
+        agwStyle: int = aui.AUI_NB_DEFAULT_STYLE
         | aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
         | aui.AUI_NB_TAB_EXTERNAL_MOVE
         | aui.AUI_NB_BOTTOM
         | wx.NO_BORDER,
-    ):
-        """
-        Wrapper for the notebook widget that manages notebook pages.
+    ) -> None:
+        """Initialize AUI notebook for Jupyter with WebView tabs.
 
+        :param parent: Parent window
+        :param agwStyle: AUI notebook style flags
         :raises ImportError: If wx.html2 is not available
         """
-
         if not WX_HTML2_AVAILABLE:
             msg = "wx.html2 is not available"
             raise ImportError(msg)
@@ -64,9 +64,8 @@ def __init__(
 
         self.Bind(aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.OnPageClose)
 
-    def _hide_top_ui(self, event):
-        """
-        Inject CSS via JS into the Jupyter page to hide top UI elements.
+    def _hide_top_ui(self, event: html.WebViewEvent) -> None:
+        """Inject CSS via JS into the Jupyter page to hide top UI elements.
 
         Works for both:
         - Jupyter Notebook 6 and older (classic interface)
@@ -76,6 +75,8 @@ def _hide_top_ui(self, event):
         Some UI elements may be created dynamically after page load,
         so the script ensures the CSS/JS is applied once elements exist.
         Duplicate injection is prevented by checking for a unique style ID.
+
+        :param event: WebView loaded event
         """
         webview = event.GetEventObject()
 
@@ -112,21 +113,23 @@ def _hide_top_ui(self, event):
 
         webview.RunScript(js)
 
-    def AddPage(self, url, title):
-        """
-        Add a new aui notebook page with a Jupyter WebView.
-        :param url: URL of the Jupyter file (str).
-        :param title: Tab title (str).
+    def AddPage(self, url: str, title: str) -> None:
+        """Add a new AUI notebook page with a Jupyter WebView.
 
+        :param url: URL of the Jupyter file
+        :param title: Tab title
         :raises NotImplementedError: If wx.html2.WebView is not functional on this system
         """
         browser = html.WebView.New(self)
         wx.CallAfter(browser.LoadURL, url)
         wx.CallAfter(browser.Bind, html.EVT_WEBVIEW_LOADED, self._hide_top_ui)
         super().AddPage(browser, title)
 
-    def OnPageClose(self, event):
-        """Close the aui notebook page with confirmation dialog."""
+    def OnPageClose(self, event: aui.AuiNotebookEvent) -> None:
+        """Close the AUI notebook page with confirmation dialog.
+
+        :param event: Notebook page close event
+        """
         index = event.GetSelection()
         title = self.GetPageText(index)