ansys-pyensight-core 0.11.0__py3-none-any.whl

ansys/pyensight/core/launch_ensight.py

@@ -0,0 +1,296 @@
+# Copyright (C) 2022 - 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""launch_ensight module
+
+The launch_ensight module provides pyensight with the ability to launch an
+EnSight session using PyPIM.  This leverages the DockerLauncher module.
+
+Examples
+--------
+>>> from ansys.pyensight.core import launch_ensight
+>>> session = launch_ensight()
+>>> # do pyensight stuff with the session
+>>> session.close()
+"""
+
+import logging
+from typing import Optional
+
+from ansys.pyensight.core.locallauncher import LocalLauncher
+from ansys.pyensight.core.session import Session
+
+pim_is_available = False  # pragma: no cover
+try:
+    import ansys.platform.instancemanagement as pypim
+
+    pim_is_available = True  # pragma: no cover
+except Exception:  # pragma: no cover
+    pass  # pragma: no cover
+logging.debug(f"pim_is_available: {pim_is_available}\n")
+
+docker_is_available = False
+try:
+    from ansys.pyensight.core.dockerlauncher import DockerLauncher
+
+    docker_is_available = True
+except Exception:  # pragma: no cover
+    pass  # pragma: no cover
+logging.debug(f"docker_is_available: {docker_is_available}\n")
+
+
+if pim_is_available:  # pragma: no cover
+
+    def _prepare_pim(  # pragma: no cover
+        product_version: Optional[str] = None,
+    ):
+        """Create a PIM instance and gRPC channel for the input version of EnSight.
+
+        Parameters
+        ----------
+        product_version : str, optional
+            Version of the product. For example, "232". The default is "None"
+
+        """
+        pim = pypim.connect()
+        instance = pim.create_instance(
+            product_name="ensight",
+            product_version=product_version,
+        )
+        instance.wait_for_ready()
+        # use defaults as specified by PIM
+        channel = instance.build_grpc_channel(
+            options=[
+                ("grpc.max_receive_message_length", -1),
+                ("grpc.max_send_message_length", -1),
+                ("grpc.testing.fixed_reconnect_backoff_ms", 1100),
+            ]
+        )
+        return instance, channel
+
+    def _launch_ensight_with_pim(  # pragma: no cover
+        product_version: Optional[str] = None,
+        **kwargs,
+    ) -> "Session":
+        """Internal function.
+        Start via PyPIM the EnSight Docker container with EnShell as the ENTRYPOINT.
+        Create and bind a Session instance to the created gRPC session.  Return that session.
+
+        Parameters
+        ----------
+        product_version : str, optional
+            Version of the product. For example, "232". The default is "None"
+        use_egl : bool, optional
+            If True, EGL hardware accelerated graphics will be used. The platform
+            must be able to support it.
+        use_sos : int, optional
+            If None, don't use SOS. Otherwise, it's the number of EnSight Servers to use (int).
+
+        Returns
+        -------
+        Session
+            pyensight Session object instance
+
+        """
+        instance, channel = _prepare_pim(product_version=product_version)
+        launcher = DockerLauncher(channel=channel, pim_instance=instance, **kwargs)
+        return launcher.connect()
+
+    def _launch_libuserd_with_pim(
+        product_version: Optional[str] = None, **kwargs
+    ):  # pragma: no cover
+        from ansys.pyensight.core.libuserd import LibUserd
+
+        instance, channel = _prepare_pim(product_version=product_version)
+        libuserd = LibUserd(channel=channel, pim_instance=instance, **kwargs)
+        libuserd.initialize()
+        return libuserd
+
+
+def launch_ensight(
+    product_version: Optional[str] = None,
+    use_pim: bool = True,
+    use_docker: bool = True,
+    data_directory: Optional[str] = None,
+    docker_image_name: Optional[str] = None,
+    use_dev: bool = False,
+    ansys_installation: Optional[str] = None,
+    application: str = "ensight",
+    batch: bool = True,
+    **kwargs,
+) -> "Session":
+    """Start an EnSight session via EnShell using the Docker EnSight Image.
+    Return that session.
+
+    Parameters
+    ----------
+    product_version : str, optional
+        Select an installed version of ANSYS. The string must be in a format like
+        "232" (for 2023 R2). The default is "None", in which case the newest installed
+        version is used.
+    use_pim : bool, optional
+        If True, then PyPIM is used to launch EnSight.
+    use_docker : bool, optional
+        If True, use DockerLaucher. If use_pim is True, this option is ignored.
+    data_directory: str, optional
+        Host directory to make into the Docker container at /data
+        Only used if use_docker is True.
+    docker_image_name: str, optional
+        Optional Docker Image name to use
+    use_dev: bool, optional
+        Option to use the latest ensight_dev Docker Image; overridden by docker_image_name if specified.
+    ansys_installation: str, optional
+        Location of the ANSYS installation, including the version.
+        directory Default: None (causes common locations to be scanned).
+        If use_pim is True, this option is ignored.  If use_docker is True, this option is ignored.
+    application: str, optional
+        The application to be launched. By default, "ensight", but
+        "envision" is also available.
+    batch: bool, optional
+        By default, the EnSight/EnVision instance will run in batch mode.
+        If batch is set to False, the full GUI will be presented.
+        Only used if use_pim and use_docker are False.
+    use_egl: bool, optional
+        If True, EGL hardware accelerated graphics will be used. The platform
+        must be able to support it.
+    use_sos: int, optional
+        If None, don't use SOS. Otherwise, it's the number of EnSight Servers to use (int).
+    timeout: float, optional
+        In some cases where the EnSight session can take a significant amount of
+        time to start up, this is the number of seconds to wait before failing
+        the connection.  The default is 120.0.
+
+    Returns
+    -------
+    type
+        pyensight Session object instance
+
+    Raises
+    ------
+    RuntimeError
+        variety of error conditions
+
+    """
+
+    logging.debug(f"pim_is_available: {pim_is_available}  use_pim: {use_pim}\n")  # pragma: no cover
+    if pim_is_available and use_pim:  # pragma: no cover
+        if pypim.is_configured():
+            return _launch_ensight_with_pim(product_version=product_version, **kwargs)
+
+    # not using PIM, but use Docker
+    logging.debug(f"docker_is_available: {docker_is_available}  use_docker: {use_docker}\n")
+    if docker_is_available and use_docker:
+        launcher = DockerLauncher(
+            data_directory=data_directory,
+            docker_image_name=docker_image_name,
+            use_dev=use_dev,
+            **kwargs,
+        )
+        return launcher.start()
+
+    # use local installation of EnSight
+    launcher = LocalLauncher(  # pragma: no cover
+        ansys_installation=ansys_installation,  # pragma: no cover
+        application=application,  # pragma: no cover
+        batch=batch,  # pragma: no cover
+        **kwargs,  # pragma: no cover
+    )  # pragma: no cover
+    return launcher.start()  # pragma: no cover
+
+
+def launch_libuserd(  # pragma: no cover
+    product_version: Optional[str] = None,
+    use_pim: bool = True,
+    use_docker: bool = True,
+    data_directory: Optional[str] = None,
+    docker_image_name: Optional[str] = None,
+    use_dev: bool = False,
+    ansys_installation: Optional[str] = None,
+    timeout: float = 120.0,
+    pull_image_if_not_available: bool = False,
+):
+    """Start an EnSight session via EnShell using the Docker EnSight Image.
+    Return that session.
+
+    Parameters
+    ----------
+    product_version : str, optional
+        Select an installed version of ANSYS. The string must be in a format like
+        "232" (for 2023 R2). The default is "None", in which case the newest installed
+        version is used.
+    use_pim : bool, optional
+        If True, then PyPIM is used to launch the EnSight image.
+    use_docker : bool, optional
+        If True, use DockerLaucher. If use_pim is True, this option is ignored.
+    data_directory: str, optional
+        Host directory to make into the Docker container at /data
+        Only used if use_docker is True.
+    docker_image_name: str, optional
+        Optional Docker Image name to use
+    use_dev: bool, optional
+        Option to use the latest ensight_dev Docker Image; overridden by docker_image_name if specified.
+    ansys_installation: str, optional
+        Location of the ANSYS installation, including the version.
+        directory Default: None (causes common locations to be scanned).
+        If use_pim is True, this option is ignored.  If use_docker is True, this option is ignored.
+    application: str, optional
+        The application to be launched. By default, "ensight", but
+        "envision" is also available.
+    timeout: float, optional
+        In some cases where the EnSight session can take a significant amount of
+        time to start up, this is the number of seconds to wait before failing
+        the connection.  The default is 120.0.
+    pull_image_if_not_available: bool
+        If True, the image will be pulled using Docker. If use_pim is True this option
+        is ignored.
+    Returns
+    -------
+    type
+        LibUserd object instance
+
+    Raises
+    ------
+    RuntimeError
+        variety of error conditions
+
+    """
+    from ansys.pyensight.core.libuserd import LibUserd
+
+    logging.debug(f"pim_is_available: {pim_is_available}  use_pim: {use_pim}\n")  # pragma: no cover
+    if pim_is_available and use_pim:  # pragma: no cover
+        if pypim.is_configured():
+            return _launch_libuserd_with_pim(product_version=product_version, timeout=timeout)
+    logging.debug(f"docker_is_available: {docker_is_available}  use_docker: {use_docker}\n")
+    if docker_is_available and use_docker:
+        libuserd = LibUserd(
+            data_directory=data_directory,
+            docker_image_name=docker_image_name,
+            use_dev=use_dev,
+            use_docker=use_docker,
+            timeout=timeout,
+            pull_image_if_not_available=pull_image_if_not_available,
+        )
+        libuserd.initialize()
+        return libuserd
+    libuserd = LibUserd(ansys_installation=ansys_installation, timeout=timeout)
+    libuserd.initialize()
+    return libuserd

ansys/pyensight/core/launcher.py

@@ -0,0 +1,388 @@
+# Copyright (C) 2022 - 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Launcher module.
+
+The Launcher module provides a base class responsible for managing an EnSight
+:class:`Session<ansys.pyensight.core.Session>` instance. Subclasses of the
+class implement specific launching paradigms.
+
+Examples:
+    ::
+
+        from ansys.pyensight.core import LocalLauncher
+        session = LocalLauncher().start()
+
+"""
+import os.path
+import platform
+import re
+from typing import TYPE_CHECKING, Dict, List, Optional
+import warnings
+
+import psutil
+import requests
+
+if TYPE_CHECKING:
+    from ansys.pyensight.core import Session
+
+# Don't remove this line.  The idna encoding
+# is used by getaddrinfo when dealing with unicode hostnames,
+# and in some cases, there appears to be a race condition
+# where threads will get a LookupError on getaddrinfo() saying
+# that the encoding doesn't exist. Using the idna encoding before
+# running any CLI code (and any threads it may create) ensures that
+# the encodings.idna is imported and registered in the codecs registry,
+# which will stop the LookupErrors from happening.
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+# The user doesn't know "eth" and "ib" what they mean. Use more meaningful
+# keywords.
+INTERCONNECT_MAP = {"ethernet": "eth", "infiniband": "ib"}
+
+MPI_TYPES = ["intel2018", "intel2021", "openmpi"]
+
+
+class Launcher:
+    """Provides the EnSight ``Launcher`` base class.
+
+    A ``Launcher`` instance is used to start and end an EnSight session.
+    Specific subclasses handle different types of launching semantics.
+    A launcher can create only a single EnSight instance. If you  need to
+    have more than one EnSight instance, a new launcher instance is required.
+
+    Parameters
+    ----------
+    timeout : float, optional
+        Number of seconds to try a gRPC connection before giving up.
+        The default is ``120``.
+    use_egl : bool, optional
+        Whether to use EGL hardware for accelerated graphics. The platform
+        must be able to support this hardware. The default is ``False``.
+    use_sos : int, optional
+        Number of EnSight servers to use for SOS (Server of Server) mode.
+        The default is ``None``, in which case SOS mode is not used.
+    enable_rest_api : bool, optional
+        Whether to enable the EnSight REST API. The default is ``False``.
+        This parameter is supported in EnSight 2024 R1 and later.
+    additional_command_line_options: list, optional
+        Additional command line options to be used to launch EnSight.
+        Please note, when using DockerLauncher, arguments that contain spaces
+        are not supported.
+    launch_web_ui : bool, optional
+        Whether to launch the webUI from EnSight
+    use_mpi: str, optional
+        If set, EnSight will be launched with the MPI type selected. The valid
+        values depend on the EnSight version to be used. The user can see
+        the specific list starting the EnSight Launcher manually and specifying the options
+        to launch EnSight in parallel and MPI. Here are reported the values for releases
+        2024R2 and 2025R1.
+
+        =================== =========================================
+        Release             Valid MPI Types
+        =================== =========================================
+        2024R2              intel2021, intel2018, openmpi
+        2025R1              intel2021, intel2018, openmpi
+        =================== =========================================
+
+        The remote nodes must be Linux nodes.
+        This option is valid only if a LocalLauncher is used.
+    interconnet: str, optional
+        If set, EnSight will be launched with the MPI Interconnect selected. Valid values
+        are "ethernet", "infiniband". It requires use_mpi to be set.
+        If use_mpi is set and interconnect is not, "ethernet" will be used.
+        This option is valid only if a LocalLauncher is used.
+    server_hosts: List[str], optional
+        A list of hostnames where the server processes should be spawned on when MPI is selected.
+        If use_mpi is set and server_hosts not, it will default to "localhost".
+        This option is valid only if a LocalLauncher is used.
+    """
+
+    def __init__(
+        self,
+        timeout: float = 120.0,
+        use_egl: bool = False,
+        use_sos: Optional[int] = None,
+        enable_rest_api: bool = False,
+        additional_command_line_options: Optional[List] = None,
+        launch_webui: bool = False,
+        use_mpi: Optional[str] = None,
+        interconnect: Optional[str] = None,
+        server_hosts: Optional[List[str]] = None,
+        rest_ws_separate_loops: bool = False,
+        do_not_start_ws: bool = False,
+        liben_rest: bool = False,
+        vtk_ws: bool = False,
+    ) -> None:
+        self._timeout = timeout
+        self._use_egl_param_val: bool = use_egl
+        self._use_sos = use_sos
+        self._use_mpi = use_mpi
+        self._interconnect = interconnect
+        self._vtk_ws_port = vtk_ws
+        if self._use_mpi and self._use_mpi not in MPI_TYPES:
+            raise RuntimeError(f"{self._use_mpi} is not a valid MPI option.")
+        if self._use_mpi and not self._interconnect:
+            self._interconnect = "ethernet"
+        if self._interconnect:
+            if self._interconnect not in list(INTERCONNECT_MAP.values()):
+                raise RuntimeError(f"{self._interconnect} is not a valid MPI interconnect option.")
+            self._interconnect = INTERCONNECT_MAP.get(self._interconnect)
+        self._server_hosts = server_hosts
+        if self._use_mpi and not self._server_hosts:
+            self._server_hosts = ["localhost"]
+        self._enable_rest_api = enable_rest_api
+
+        self._sessions: List[Session] = []
+        self._session_directory: str = "."
+
+        self._is_egl_capable: Optional[bool] = None
+        self._egl_env_val: Optional[bool] = None
+        egl_env = os.environ.get("PYENSIGHT_FORCE_ENSIGHT_EGL")
+        if egl_env is not None:
+            if egl_env == "1":  # pragma: no cover
+                self._egl_env_val = True  # pragma: no cover
+            else:
+                self._egl_env_val = False
+        # a dict of any optional launcher specific query parameters for URLs
+        self._query_parameters: Dict[str, str] = {}
+        self._additional_command_line_options = additional_command_line_options
+        self._launch_webui = launch_webui
+        self._do_not_start_ws = do_not_start_ws
+        self._liben_rest = liben_rest
+        self._rest_ws_separate_loops = rest_ws_separate_loops
+        self._has_grpc_changes = False
+
+    @property
+    def session_directory(self) -> str:
+        """Root directory for HTML files.
+
+        The contents of this directory can be accessed at ``hostname:port``.
+        """
+        return self._session_directory
+
+    @session_directory.setter
+    def session_directory(self, value: str):
+        self._session_directory = value
+
+    def close(self, session: "Session") -> None:
+        """Shut down the launched EnSight session.
+
+        This method closes all associated sessions and then stops the
+        launched EnSight instance.
+
+        Parameters
+        ----------
+        session : ``pyensight.Session``
+            Session to close.
+
+        Raises
+        ------
+        RuntimeError
+            If the session was not launched by this launcher.
+
+        """
+        if session not in self._sessions:
+            raise RuntimeError("Session not associated with this Launcher")
+        self._sessions.remove(session)
+        if self._sessions:
+            # stop the grpc session interface
+            session.grpc.shutdown(stop_ensight=False)
+            return
+
+        # if the session list is empty, stop the EnSight instance (via session grpc interface)
+        session.grpc.shutdown(stop_ensight=True, force=True)
+
+        # stop the websocketserver instance
+        url = f"http://{session.hostname}:{session.html_port}/v1/stop"
+        if session.secret_key:  # pragma: no cover
+            url += f"?security_token={session.secret_key}"
+        try:
+            _ = requests.get(url)
+        except requests.exceptions.ConnectionError:
+            pass
+
+        # Stop the launcher instance
+        self.stop()
+
+    def start(self) -> Optional["Session"]:
+        """Start a session using the current launcher
+
+        The start() method will only allocate a single instance of
+        a Session object.  If called a second time, return the
+        result of the first call.
+
+        Returns
+        -------
+        If start() has been called previously, return that session
+        and emit a warning.   If start() has not been called, return None.
+
+        """
+        if len(self._sessions):
+            msg = "The launcher start() method may only be called once. "
+            msg += "Create a new launcher instance to start a new EnSight instance."
+            warnings.warn(msg, RuntimeWarning)
+            return self._sessions[0]
+        return None
+
+    def stop(self) -> None:
+        """Base method for stopping a session initiated by start()
+
+        Notes
+        -----
+            The session object is responsible for making the EnSight 'Exit' and websocketserver
+            calls. This method can be used to clean up any additional resources being used
+            by the launching method.
+        """
+        return
+
+    def _find_ports_used_by_other_pyensight_and_ensight(self):
+        """Find ports to avoid when looking for empty ports.
+
+        The ports are found iterating the current processes and
+        looking for PyEnSight/EnSight sessions and their command
+        lines.
+        """
+        pyensight_found = []
+        ensight_found = []
+        for process in psutil.process_iter():
+            try:
+                process_cmdline = process.cmdline()
+            except (psutil.AccessDenied, psutil.ZombieProcess, OSError, psutil.NoSuchProcess):
+                continue
+            if not process_cmdline:
+                continue
+            if len(process_cmdline) > 1:
+                if "websocketserver.py" in os.path.basename(process_cmdline[1]):
+                    pyensight_found.append(process_cmdline)
+            if any(["ensight" in os.path.basename(x) for x in process_cmdline]):
+                if any([x == "-ports" for x in process_cmdline]):
+                    ensight_found.append(process_cmdline)
+        ports = []
+        for command_line in pyensight_found:
+            for command in command_line:
+                if re.match(r"^\d{4,5}$", command):
+                    ports.append(int(command))
+        for command_line in ensight_found:
+            idx = command_line.index("-ports") + 1
+            ports.append(int(command_line[idx]))
+        return list(set(ports))
+
+    def _use_egl(self) -> bool:
+        """Return True if the system supports the EGL and if EGL was desired.
+
+        Returns
+        -------
+        bool
+            A bool value that is True if we should use EGL.
+
+        """
+        if self._is_egl_capable is None:
+            # if we haven't checked with the subclasss if the system can do EGL
+            self._is_egl_capable = self._is_system_egl_capable()
+
+        if self._is_egl_capable is False:
+            # if the system can't do it, return False now
+            return False
+
+        if self._egl_env_val is not None:  # pragma: no cover
+            # if the environment variable was set, that overrides the constructor option
+            return self._egl_env_val
+
+        # otherwise, use the arg passed to the constructor
+        return self._use_egl_param_val  # pragma: no cover
+
+    def _is_system_egl_capable(self) -> bool:  # pragma: no cover
+        """Return True if the system supports the EGL launch.
+
+        Returns
+        -------
+        bool
+            A bool value that is True if the system supports the EGL launch.
+
+        """
+        raise RuntimeError("Unsupported method for this configuration")
+
+    def _is_windows(self) -> bool:
+        """Return True if it is Windows
+
+        Returns
+        -------
+        bool
+            a bool that is True if the platform is Windows
+
+        """
+        return platform.system() == "Windows"
+
+    def _get_query_parameters(self) -> Dict[str, str]:
+        """Return optional http query parameters as a dict.
+        It may be empty if there are None.
+        If query parameters exist, they should be added to any
+        http/https URL intended for the WSS web server.
+        This is used by things such as Ansys Lab.
+
+        Returns
+        -------
+        dict
+            query parameters that should be appended to any queries
+        """
+        return self._query_parameters
+
+    def _add_query_parameters(self, params: Dict[str, str]) -> None:
+        """Add query parameters supplied by params to the
+        overall dict of query parameters.
+
+        Parameters
+        ----------
+        params: dict :
+            query parameters to add to overall dict
+        """
+        for item, value in params.items():  # pragma: no cover
+            self._query_parameters[item] = value  # pragma: no cover
+
+    def _delete_query_parameters(self, params: List[str]) -> None:
+        """Delete query parameters supplied by params from the
+        overall dict of query parameters.
+
+        Parameters
+        ----------
+        params: list :
+            query parameters to delete from the overall dict
+        """
+        for item in params:  # pragma: no cover
+            try:  # pragma: no cover
+                del self._query_parameters[item]  # pragma: no cover
+            except Exception:  # pragma: no cover
+                pass  # pragma: no cover
+
+    def _get_versionfrom_buildinfo(self, buildinfo):
+        """Check if the gRPC security options apply to the EnSight install."""
+        version_match = re.search("Version: (.*)\n", buildinfo)
+        internal_version_match = re.search("Internal: (.*)\n", buildinfo)
+        if not internal_version_match:
+            raise RuntimeError("Couldn't parse EnSight internal version in BUILDINFO file.")
+        internal_version = internal_version_match.group(1)
+        if not version_match:
+            raise RuntimeError("Couldn't parse EnSight version in BUILDINFO file.")
+        ensight_full_version = version_match.group(1)
+        return internal_version, ensight_full_version