Python Help Window Feature Addition - Indicator / UI element for Offline vs. Online (ornl-next merge) (#39183)

* OFFLINE_MODE

* Change red to green for Local Docs text.

* Updates based on comments left.

* Updates to icons and comment fix

* Fix logger defnition.

* Release documentation

* Updates to release documentation

* Hopefully this fixes the issue with docs build?

* Fix mantidworkbench.rst

* Move conda build tools to base environment (#39177)

* Move build tools to conda base environment in package-conda

At least one of these dependencies causes conda to be installed,
which should only be done inside the base environment.

* Move conda build tool to base env in package-standalone

conda build tools bring in conda as a dependency, so should
only be installed inside the base environment. Also, I think
conda-index is the correct dependency here.

---------

Co-authored-by: thomashampson <thomas.hampson@stfc.ac.uk>

Author: darshdinger

buildconfig/Jenkins/Conda/package-conda

@@ -82,9 +82,9 @@ done
 
 
 # Mamba
-setup_mamba $WORKSPACE/mambaforge "package-conda" true
-# CMake FindPython doesn't work correctly with conda 25.3.0
-mamba install --yes boa conda-verify versioningit conda=25.1.1
+setup_mamba $WORKSPACE/mambaforge "" true
+mamba activate base
+mamba install --yes boa conda-verify versioningit
 
 # Clean up any legacy conda-recipes git clones
 cd $WORKSPACE

buildconfig/Jenkins/Conda/package-standalone

@@ -59,9 +59,9 @@ do
 done
 
 # Mamba
-setup_mamba $WORKSPACE/mambaforge "package-standalone"
-# Pin conda to known working version. In 24.9 the post-link.bat script doesn't work.
-mamba install --yes mamba=1.5 conda-build conda=24.7
+setup_mamba $WORKSPACE/mambaforge "" true
+mamba activate base
+mamba install --yes conda-index
 
 # Build packages
 # Setup a local conda channel to find our locally built packages package. It is

docs/source/release/v6.13.0/Framework/Python/New_features/37248.rst

@@ -0,0 +1,6 @@
+- Makes the large offline documentation optional rather than a mandatory install, reducing installer/download size significantly.
+- Improvements:
+    - For users who frequently access online docs or have bandwidth constraints, this saves considerable disk space (potentially hundreds of MB).
+    - Those who prefer local/offline usage can still opt to install the documentation package and continue working without internet access.
+- Key benefits:
+    - Greater flexibility in how Mantid is set up — you choose whether to save space or have fully locally built docs.

docs/source/release/v6.13.0/Framework/Python/New_features/38736.rst

@@ -0,0 +1,7 @@
+- Introduced a prototype "side-by-side" help system that includes both the legacy QtHelp-based viewer and a new Python-based Help Window using an embedded web browser (QWebEngine) to display documentation within Mantid Workbench.
+- Improvements:
+    - Enhances the visual appearance and usability of in-app documentation.
+    - Supports richer HTML content and modern formatting, including MathJax for rendering mathematical equations.
+    - Delivers a smoother and more consistent experience when navigating help and reference material.
+- Key benefits:
+    - Improved clarity for technical content (e.g. math and tables), more attractive and readable pages, and future potential for interactive elements in documentation.

docs/source/release/v6.13.0/Framework/Python/New_features/39144.rst

@@ -0,0 +1,6 @@
+- Adds a clear indicator in the Help Window’s toolbar showing whether Mantid is displaying **Local Docs** or **Online Docs** documentation.
+- Improvements:
+    - Makes it obvious if you are using locally installed documentation or viewing updated online docs (default).
+    - Helps diagnose connection or installation issues if pages are not loading as expected.
+- Key benefits:
+    - Immediate clarity on where help content is being retrieved from, removing guesswork.

qt/python/mantidqt/mantidqt/widgets/helpwindow/helpwindowbridge.py

@@ -6,35 +6,34 @@
 # SPDX - License - Identifier: GPL - 3.0 +
 import os
 import sys
+import argparse
 
 from qtpy.QtWidgets import QApplication
 from mantidqt.widgets.helpwindow.helpwindowpresenter import HelpWindowPresenter
 
 _presenter = None
 
 
-def show_help_page(relative_url, local_docs=None, online_base_url="https://docs.mantidproject.org/"):
+def show_help_page(relativeUrl, localDocs=None, onlineBaseUrl="https://docs.mantidproject.org/"):
     """
     Show the help window at the given relative URL path.
     """
     global _presenter
     if _presenter is None:
         # Create a Presenter once. Re-use it on subsequent calls.
-        _presenter = HelpWindowPresenter(local_docs=local_docs, online_base_url=online_base_url)
+        _presenter = HelpWindowPresenter(localDocs=localDocs, onlineBaseUrl=onlineBaseUrl)
 
     # Ask the Presenter to load the requested page
-    _presenter.showHelpPage(relative_url)
+    _presenter.show_help_page(relativeUrl)
 
 
 def main(cmdargs=sys.argv):
     """
     Run this script standalone to test the Python-based Help Window.
     """
-    import argparse
-
     parser = argparse.ArgumentParser(description="Standalone test of the Python-based Mantid Help Window.")
     parser.add_argument(
-        "relative_url", nargs="?", default="", help="Relative doc path (e.g. 'algorithms/Load-v1.html'), defaults to 'index.html' if empty."
+        "relativeUrl", nargs="?", default="", help="Relative doc path (e.g. 'algorithms/Load-v1.html'), defaults to 'index.html' if empty."
     )
     parser.add_argument("--local-docs", default=None, help="Path to local Mantid HTML docs. Overrides environment if set.")
     parser.add_argument(
@@ -51,7 +50,7 @@ def main(cmdargs=sys.argv):
     app = QApplication(sys.argv)
 
     # Show the requested help page
-    show_help_page(relative_url=args.relative_url, local_docs=args.local_docs, online_base_url=args.online_base_url)
+    show_help_page(relativeUrl=args.relativeUrl, localDocs=args.local_docs, onlineBaseUrl=args.online_base_url)
 
     sys.exit(app.exec_())
 

qt/python/mantidqt/mantidqt/widgets/helpwindow/helpwindowmodel.py

@@ -5,9 +5,39 @@
 #   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
 # SPDX - License - Identifier: GPL - 3.0 +
 import os
+
+import logging
 from qtpy.QtCore import QUrl
 from qtpy.QtWebEngineCore import QWebEngineUrlRequestInterceptor, QWebEngineUrlRequestInfo
 
+# Module-level logger for functions outside of classes
+_logger = logging.getLogger(__name__)
+
+
+def _get_version_string_for_url():
+    """
+    Returns the Mantid version string formatted for use in documentation URLs.
+    For example, "v6.12.0" from version "6.12.0.1"
+
+    Returns:
+        str: Formatted version string in the form "vX.Y.Z" or None if version cannot be determined
+    """
+    versionStr = None
+    try:
+        import mantid
+
+        # Use the mantid version object (proper way)
+        versionObj = mantid.version()
+        # Retrieve the patch
+        patch = versionObj.patch.split(".")[0]
+        versionStr = f"v{versionObj.major}.{versionObj.minor}.{patch}"
+    except ImportError:
+        _logger.warning("Could not determine Mantid version for documentation URL.")
+    except Exception as e:
+        _logger.warning(f"Error determining Mantid version for documentation URL: {e}")
+
+    return versionStr
+
 
 class NoOpRequestInterceptor(QWebEngineUrlRequestInterceptor):
     """
@@ -31,50 +61,110 @@ def interceptRequest(self, info: QWebEngineUrlRequestInfo):
 
 
 class HelpWindowModel:
-    def __init__(self, local_docs_base=None, online_base="https://docs.mantidproject.org/"):
-        if local_docs_base and not os.path.isdir(local_docs_base):
-            raise ValueError(f"Local docs directory '{local_docs_base}' does not exist or is invalid.")
-        self.local_docs_base = local_docs_base
-        self.online_base = online_base.rstrip("/")
+    _logger = logging.getLogger(__name__)
+
+    MODE_LOCAL = "Local Docs"
+    MODE_ONLINE = "Online Docs"
+
+    def __init__(self, localDocsBase=None, onlineBase="https://docs.mantidproject.org/"):
+        self._rawLocalDocsBase = localDocsBase
+        self._rawOnlineBase = onlineBase.rstrip("/")
+
+        self._isLocal = False
+        self._modeString = self.MODE_ONLINE
+        self._baseUrl = self._rawOnlineBase
+        self._versionString = None
 
-    def is_local_docs_enabled(self):
+        self._determine_mode_and_base_url()
+
+    def _determine_mode_and_base_url(self):
         """
-        :return: True if local_docs_base is set and is a valid directory
+        Sets the internal state (_isLocal, _modeString, _baseWrl, _versionString)
+        based on the validity of localDocsBase and attempts to find a versioned URL.
         """
-        return bool(self.local_docs_base and os.path.isdir(self.local_docs_base))
+        if self._rawLocalDocsBase and os.path.isdir(self._rawLocalDocsBase):
+            self._isLocal = True
+            self._modeString = self.MODE_LOCAL
+            absLocalPath = os.path.abspath(self._rawLocalDocsBase)
+            self._baseUrl = QUrl.fromLocalFile(absLocalPath).toString()
+            self._versionString = None
+            self._logger.debug(f"Using {self._modeString} from {self._baseUrl}")
+        else:
+            if self._rawLocalDocsBase:
+                self._logger.warning(f"Local docs path '{self._rawLocalDocsBase}' is invalid or not found. Falling back to online docs.")
+
+            self._isLocal = False
+            self._modeString = self.MODE_ONLINE
 
-    def build_help_url(self, relative_url):
+            isLikelyRelease = self._rawLocalDocsBase is None
+            if isLikelyRelease:
+                self._versionString = _get_version_string_for_url()
+
+            if self._versionString:
+                baseOnline = self._rawOnlineBase
+                if baseOnline.endswith("/stable"):
+                    baseOnline = baseOnline[: -len("/stable")]
+
+                if self._versionString not in baseOnline:
+                    self._baseUrl = f"{baseOnline.rstrip('/')}/{self._versionString}"
+                    self._logger.debug(f"Using {self._modeString} (Version: {self._versionString}) from {self._baseUrl}")
+                else:
+                    self._baseUrl = self._rawOnlineBase
+                    self._logger.debug(f"Using {self._modeString} (Using provided base URL, possibly stable/latest): {self._baseUrl}")
+            else:
+                self._baseUrl = self._rawOnlineBase
+                self._logger.debug(f"Using {self._modeString} (Version: Unknown/Stable) from {self._baseUrl}")
+
+    def is_local_docs_mode(self):
         """
-        Returns a QUrl pointing to either local or online docs for the given relative URL.
+        :return: True if using local docs, False otherwise. Based on initial check.
         """
-        if not relative_url or not relative_url.endswith(".html"):
-            relative_url = "index.html"
+        return self._isLocal
 
-        if self.is_local_docs_enabled():
-            full_path = os.path.join(self.local_docs_base, relative_url)
-            return QUrl.fromLocalFile(full_path)
-        else:
-            return QUrl(self.online_base + "/" + relative_url)
+    def get_mode_string(self):
+        """
+        :return: User-friendly string indicating the mode ("Local Docs" or "Online Docs").
+        """
+        return self._modeString
+
+    def get_base_url(self):
+        """`
+        :return: The determined base URL (either file:///path or https://docs...[/version])
+        """
+        return self._baseUrl.rstrip("/") + "/"
+
+    def build_help_url(self, relativeUrl):
+        """
+        Returns a QUrl pointing to the determined doc source for the given relative URL.
+        """
+        if not relativeUrl or not relativeUrl.lower().endswith((".html", ".htm")):
+            relativeUrl = "index.html"
+
+        relativeUrl = relativeUrl.lstrip("/")
+        fullUrlStr = f"{self.get_base_url()}{relativeUrl}"
+
+        url = QUrl(fullUrlStr)
+        if not url.isValid():
+            self._logger.warning(f"Constructed invalid URL: {fullUrlStr} from base '{self.get_base_url()}' and relative '{relativeUrl}'")
+        return url
 
     def get_home_url(self):
         """
         Return the 'home' page URL:
           - local 'index.html' if local docs are enabled
           - online docs homepage otherwise
         """
-        if self.is_local_docs_enabled():
-            full_path = os.path.join(self.local_docs_base, "index.html")
-            return QUrl.fromLocalFile(full_path)
-        else:
-            return QUrl(self.online_base + "/index.html")
+        return self.build_help_url("index.html")
 
     def create_request_interceptor(self):
         """
         Return an appropriate request interceptor:
           - LocalRequestInterceptor if local docs are used (for mathjax CORS)
           - NoOpRequestInterceptor otherwise
         """
-        if self.is_local_docs_enabled():
+        if self._isLocal:
+            self._logger.debug("Using LocalRequestInterceptor.")
             return LocalRequestInterceptor()
         else:
+            self._logger.debug("Using NoOpRequestInterceptor.")
             return NoOpRequestInterceptor()