ansys-pyensight-core 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

ansys/pyensight/core/launch_ensight.py

@@ -36,33 +36,19 @@ except Exception:  # pragma: no cover
 logging.debug(f"docker_is_available: {docker_is_available}\n")
 
 
-if pim_is_available:
+if pim_is_available:  # pragma: no cover
 
-    def _launch_ensight_with_pim(
+    def _prepare_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.
+    ):
+        """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", in which case
-        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
-        -------
-
-            pyensight Session object instance
+            Version of the product. For example, "232". The default is "None"
 
         """
-
         pim = pypim.connect()
         instance = pim.create_instance(
             product_name="ensight",
@@ -77,10 +63,46 @@ if pim_is_available:
                 ("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,
@@ -171,3 +193,82 @@ def launch_ensight(
         **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

@@ -13,9 +13,7 @@ Examples:
 """
 import os.path
 import platform
-import random
 import re
-import socket
 from typing import TYPE_CHECKING, Dict, List, Optional
 import warnings
 
@@ -63,6 +61,8 @@ class Launcher:
         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
     """
 
     def __init__(
@@ -72,6 +72,7 @@ class Launcher:
         use_sos: Optional[int] = None,
         enable_rest_api: bool = False,
         additional_command_line_options: Optional[List] = None,
+        launch_webui: bool = False,
     ) -> None:
         self._timeout = timeout
         self._use_egl_param_val: bool = use_egl
@@ -92,6 +93,7 @@ class Launcher:
         # 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
 
     @property
     def session_directory(self) -> str:
@@ -205,64 +207,6 @@ class Launcher:
             ports.append(int(command_line[idx]))
         return list(set(ports))
 
-    @staticmethod
-    def _find_unused_ports(count: int, avoid: Optional[List[int]] = None) -> Optional[List[int]]:
-        """Find "count" unused ports on the host system
-
-        A port is considered unused if it does not respond to a "connect" attempt.  Walk
-        the ports from 'start' to 'end' looking for unused ports and avoiding any ports
-        in the 'avoid' list.  Stop once the desired number of ports have been
-        found.  If an insufficient number of ports were found, return None.
-
-        Parameters
-        ----------
-        count: int :
-            Number of unused ports to find
-        avoid: Optional[List[int]] :
-            An optional list of ports not to check
-
-        Returns
-        -------
-            The detected ports or None on failure
-
-        """
-        if avoid is None:
-            avoid = []
-        ports = list()
-
-        # pick a starting port number
-        start = random.randint(1024, 64000)
-        # We will scan for 65530 ports unless end is specified
-        port_mod = 65530
-        end = start + port_mod - 1
-        # walk the "virtual" port range
-        for base_port in range(start, end + 1):
-            # Map to physical port range
-            # There have been some issues with 65534+ so we stop at 65530
-            port = base_port % port_mod
-            # port 0 is special
-            if port == 0:  # pragma: no cover
-                continue  # pragma: no cover
-            # avoid admin ports
-            if port < 1024:  # pragma: no cover
-                continue  # pragma: no cover
-            # are we supposed to skip this one?
-            if port in avoid:  # pragma: no cover
-                continue  # pragma: no cover
-            # is anyone listening?
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            result = sock.connect_ex(("127.0.0.1", port))
-            if result != 0:
-                ports.append(port)
-            else:
-                sock.close()
-            if len(ports) >= count:
-                return ports
-        # in case we failed...
-        if len(ports) < count:  # pragma: no cover
-            return None  # pragma: no cover
-        return ports  # pragma: no cover
-
     def _use_egl(self) -> bool:
         """Return True if the system supports the EGL and if EGL was desired.