Repository: ansys/pyansys-geometry (python)

Issue:
Allow launcher method to detect local installations as well
Our current ``launch_modeler`` method just detects two modes, Docker and PIM. We should also look for local installations of the Ansys Geometry Service and Ansys SpaceClaim or Discovery

Pull request description:
feat: generic launch_modeler function
Closes #939 

Patch:
diff --git a/doc/source/examples/01_getting_started/05_plotter_picker.mystnb b/doc/source/examples/01_getting_started/05_plotter_picker.mystnb
index 3693b703..27f6fd6d 100644
--- a/doc/source/examples/01_getting_started/05_plotter_picker.mystnb
+++ b/doc/source/examples/01_getting_started/05_plotter_picker.mystnb
@@ -33,7 +33,7 @@ import pyvista as pv
 
 from ansys.geometry.core import Modeler
 from ansys.geometry.core.connection.defaults import GEOMETRY_SERVICE_DOCKER_IMAGE
-from ansys.geometry.core.connection.local_instance import LocalDockerInstance
+from ansys.geometry.core.connection.docker_instance import LocalDockerInstance
 from ansys.geometry.core.math import Point2D
 from ansys.geometry.core.misc import UNITS
 from ansys.geometry.core.plotting import PlotterHelper
@@ -61,13 +61,13 @@ for image in available_images:
             is_image_available_cont = geom_cont
             break
 
-local_instance = LocalDockerInstance(
+docker_instance = LocalDockerInstance(
     connect_to_existing_service=True,
     restart_if_existing_service=True,
     image=is_image_available_cont,
 )
 
-modeler = Modeler(local_instance=local_instance)
+modeler = Modeler(docker_instance=docker_instance)
 ```
 
 +++
diff --git a/doc/source/examples/03_modeling/boolean_operations.mystnb b/doc/source/examples/03_modeling/boolean_operations.mystnb
index 8a9253bb..022808b6 100644
--- a/doc/source/examples/03_modeling/boolean_operations.mystnb
+++ b/doc/source/examples/03_modeling/boolean_operations.mystnb
@@ -21,7 +21,7 @@ Perform the required imports.
 ```{code-cell} ipython3
 from typing import List
 
-from ansys.geometry.core import launch_local_modeler
+from ansys.geometry.core import launch_docker_modeler
 from ansys.geometry.core.designer import Body
 from ansys.geometry.core.math import Point2D
 from ansys.geometry.core.misc import UNITS
@@ -37,7 +37,7 @@ modeler, see the "Launch a modeling service" section in the
 [PyAnsys Geometry 101: Modeling](../01_getting_started/04_modeling.mystnb) example.
 
 ```{code-cell} ipython3
-modeler = launch_local_modeler()
+modeler = launch_docker_modeler()
 ```
 
 ## Define bodies
diff --git a/doc/source/getting_started/docker/common_docker.jinja b/doc/source/getting_started/docker/common_docker.jinja
index f38a5ed8..863c6cf3 100644
--- a/doc/source/getting_started/docker/common_docker.jinja
+++ b/doc/source/getting_started/docker/common_docker.jinja
@@ -111,7 +111,7 @@ To see the commands for each method, click the following tabs.
           modeler = launch_modeler()
 
        The ``launch_modeler()`` method launches the Geometry service under the default
-       conditions. For more configurability, use the ``launch_local_modeler()`` method.
+       conditions. For more configurability, use the ``launch_docker_modeler()`` method.
 
     .. tab-item:: Manual launch
        :sync: manual
diff --git a/src/ansys/geometry/core/__init__.py b/src/ansys/geometry/core/__init__.py
index ab01351a..b8bebc0c 100644
--- a/src/ansys/geometry/core/__init__.py
+++ b/src/ansys/geometry/core/__init__.py
@@ -35,7 +35,7 @@ __version__ = importlib_metadata.version(__name__.replace(".", "-"))
 import os
 
 from ansys.geometry.core.connection.launcher import (
-    launch_local_modeler,
+    launch_docker_modeler,
     launch_modeler,
     launch_modeler_with_discovery,
     launch_modeler_with_discovery_and_pimlight,
diff --git a/src/ansys/geometry/core/connection/__init__.py b/src/ansys/geometry/core/connection/__init__.py
index 0f4f5828..801bd938 100644
--- a/src/ansys/geometry/core/connection/__init__.py
+++ b/src/ansys/geometry/core/connection/__init__.py
@@ -38,8 +38,13 @@ from ansys.geometry.core.connection.defaults import (
     DEFAULT_PORT,
     GEOMETRY_SERVICE_DOCKER_IMAGE,
 )
+from ansys.geometry.core.connection.docker_instance import (
+    GeometryContainers,
+    LocalDockerInstance,
+    get_geometry_container_type,
+)
 from ansys.geometry.core.connection.launcher import (
-    launch_local_modeler,
+    launch_docker_modeler,
     launch_modeler,
     launch_modeler_with_discovery,
     launch_modeler_with_discovery_and_pimlight,
@@ -49,9 +54,4 @@ from ansys.geometry.core.connection.launcher import (
     launch_modeler_with_spaceclaim_and_pimlight,
     launch_remote_modeler,
 )
-from ansys.geometry.core.connection.local_instance import (
-    GeometryContainers,
-    LocalDockerInstance,
-    get_geometry_container_type,
-)
 from ansys.geometry.core.connection.product_instance import ProductInstance
diff --git a/src/ansys/geometry/core/connection/client.py b/src/ansys/geometry/core/connection/client.py
index 47cb275a..047aa9e2 100644
--- a/src/ansys/geometry/core/connection/client.py
+++ b/src/ansys/geometry/core/connection/client.py
@@ -36,7 +36,7 @@ from grpc_health.v1 import health_pb2, health_pb2_grpc
 
 from ansys.geometry.core.connection.backend import BackendType
 from ansys.geometry.core.connection.defaults import DEFAULT_HOST, DEFAULT_PORT, MAX_MESSAGE_LENGTH
-from ansys.geometry.core.connection.local_instance import LocalDockerInstance
+from ansys.geometry.core.connection.docker_instance import LocalDockerInstance
 from ansys.geometry.core.connection.product_instance import ProductInstance
 from ansys.geometry.core.logger import LOG as logger
 from ansys.geometry.core.logger import PyGeometryCustomAdapter
@@ -100,9 +100,9 @@ class GrpcClient:
         This instance is deleted when calling the
         :func:`GrpcClient.close <ansys.geometry.core.client.GrpcClient.close >`
         method.
-    local_instance : LocalDockerInstance, default: None
-        Corresponding local instance when the Geometry service is launched using
-        the ``launch_local_modeler()`` method. This local instance is deleted
+    docker_instance : LocalDockerInstance, default: None
+        Corresponding local Docker instance when the Geometry service is launched using
+        the ``launch_docker_modeler()`` method. This local Docker instance is deleted
         when the :func:`GrpcClient.close <ansys.geometry.core.client.GrpcClient.close >`
         method is called.
     product_instance : ProductInstance, default: None
@@ -130,7 +130,7 @@ class GrpcClient:
         port: Union[str, int] = DEFAULT_PORT,
         channel: Optional[grpc.Channel] = None,
         remote_instance: Optional["Instance"] = None,
-        local_instance: Optional[LocalDockerInstance] = None,
+        docker_instance: Optional[LocalDockerInstance] = None,
         product_instance: Optional[ProductInstance] = None,
         timeout: Optional[Real] = 120,
         logging_level: Optional[int] = logging.INFO,
@@ -140,7 +140,7 @@ class GrpcClient:
         """Initialize the ``GrpcClient`` object."""
         self._closed = False
         self._remote_instance = remote_instance
-        self._local_instance = local_instance
+        self._docker_instance = docker_instance
         self._product_instance = product_instance
         if channel:
             # Used for PyPIM when directly providing a channel
@@ -263,14 +263,14 @@ class GrpcClient:
         -----
         If an instance of the Geometry service was started using
         `PyPIM <https://github.com/ansys/pypim>`_, this instance is
-        deleted. Furthermore, if a local instance
+        deleted. Furthermore, if a local Docker instance
         of the Geometry service was started, it is stopped.
         """
         if self._remote_instance:
             self._remote_instance.delete()  # pragma: no cover
-        elif self._local_instance:
-            if not self._local_instance.existed_previously:
-                self._local_instance.container.stop()
+        elif self._docker_instance:
+            if not self._docker_instance.existed_previously:
+                self._docker_instance.container.stop()
             else:
                 self.log.warning(
                     "Geometry service was not shut down because it was already running..."
diff --git a/src/ansys/geometry/core/connection/local_instance.py b/src/ansys/geometry/core/connection/docker_instance.py
similarity index 100%
rename from src/ansys/geometry/core/connection/local_instance.py
rename to src/ansys/geometry/core/connection/docker_instance.py
diff --git a/src/ansys/geometry/core/connection/launcher.py b/src/ansys/geometry/core/connection/launcher.py
index b944982a..e1fab7ab 100644
--- a/src/ansys/geometry/core/connection/launcher.py
+++ b/src/ansys/geometry/core/connection/launcher.py
@@ -27,7 +27,7 @@ from beartype.typing import TYPE_CHECKING, Dict, Optional
 from ansys.geometry.core.connection.backend import ApiVersions, BackendType
 from ansys.geometry.core.connection.client import MAX_MESSAGE_LENGTH
 from ansys.geometry.core.connection.defaults import DEFAULT_PIM_CONFIG, DEFAULT_PORT
-from ansys.geometry.core.connection.local_instance import (
+from ansys.geometry.core.connection.docker_instance import (
     _HAS_DOCKER,
     GeometryContainers,
     LocalDockerInstance,
@@ -48,15 +48,27 @@ if TYPE_CHECKING:  # pragma: no cover
     from ansys.geometry.core.modeler import Modeler
 
 
-def launch_modeler(**kwargs: Optional[Dict]) -> "Modeler":
+def launch_modeler(mode: str = None, **kwargs: Optional[Dict]) -> "Modeler":
     """
     Start the ``Modeler`` interface for PyAnsys Geometry.
 
     Parameters
     ----------
+    mode : str, default: None
+        Mode in which to launch the ``Modeler`` service. The default is ``None``,
+        in which case the method tries to determine the mode automatically. The
+        possible values are:
+
+        * ``"pypim"``: Launches the ``Modeler`` service remotely using the PIM API.
+        * ``"docker"``: Launches the ``Modeler`` service locally using Docker.
+        * ``"geometry_service"``: Launches the ``Modeler`` service locally using the
+          Ansys Geometry Service.
+        * ``"spaceclaim"``: Launches the ``Modeler`` service locally using Ansys SpaceClaim.
+        * ``"discovery"``: Launches the ``Modeler`` service locally using Ansys Discovery.
+
     **kwargs : dict, default: None
         Keyword arguments for the launching methods. For allowable keyword arguments, see the
-        :func:`launch_remote_modeler` and :func:`launch_local_modeler` methods. Some of these
+        :func:`launch_remote_modeler` and :func:`launch_docker_modeler` methods. Some of these
         keywords might be unused.
 
     Returns
@@ -71,21 +83,133 @@ def launch_modeler(**kwargs: Optional[Dict]) -> "Modeler":
     >>> from ansys.geometry.core import launch_modeler
     >>> modeler = launch_modeler()
     """
-    # A local Docker container of the Geometry service or `PyPIM <https://github.com/ansys/pypim>`_
-    # is required for this to work. Neither is integrated, but they could possibly be added later.
+    if mode:
+        return _launch_with_launchmode(mode, **kwargs)
+    else:
+        return _launch_with_automatic_detection(**kwargs)
+
+
+def _launch_with_launchmode(mode: str, **kwargs: Optional[Dict]) -> "Modeler":
+    """
+    Start the ``Modeler`` interface for PyAnsys Geometry.
+
+    Parameters
+    ----------
+    mode : str
+        Mode in which to launch the ``Modeler`` service. The possible values are:
+
+        * ``"pypim"``: Launches the ``Modeler`` service remotely using the PIM API.
+        * ``"docker"``: Launches the ``Modeler`` service locally using Docker.
+        * ``"geometry_service"``: Launches the ``Modeler`` service locally using the
+          Ansys Geometry Service.
+        * ``"spaceclaim"``: Launches the ``Modeler`` service locally using Ansys SpaceClaim.
+        * ``"discovery"``: Launches the ``Modeler`` service locally using Ansys Discovery.
+
+    **kwargs : dict, default: None
+        Keyword arguments for the launching methods. For allowable keyword arguments, see the
+        :func:`launch_remote_modeler` and :func:`launch_docker_modeler` methods. Some of these
+        keywords might be unused.
+
+    Returns
+    -------
+    ansys.geometry.core.modeler.Modeler
+        Pythonic interface for geometry modeling.
+    """
+    # Ensure that the launch mode is a string
+    if not isinstance(mode, str):
+        raise TypeError("The launch mode must be a string.")
 
-    # Another alternative is to use this method to run Docker locally.
+    # Ensure that the launch mode is lowercase
+    mode = mode.lower()
 
-    # Start PyAnsys Geometry with PyPIM if the environment is configured for it
+    if mode == "pypim":
+        return launch_remote_modeler(**kwargs)
+    elif mode == "docker":
+        return launch_docker_modeler(**kwargs)
+    elif mode == "geometry_service":
+        return launch_modeler_with_geometry_service(**kwargs)
+    elif mode == "spaceclaim":
+        return launch_modeler_with_spaceclaim(**kwargs)
+    elif mode == "discovery":
+        return launch_modeler_with_discovery(**kwargs)
+    else:  # pragma: no cover
+        raise ValueError(
+            f"Invalid launch mode '{mode}'. The valid modes are: "
+            "'pypim', 'docker', 'geometry_service', 'spaceclaim', 'discovery'."
+        )
+
+
+def _launch_with_automatic_detection(**kwargs: Optional[Dict]) -> "Modeler":
+    """
+    Start the ``Modeler`` interface for PyAnsys Geometry based on automatic detection.
+
+    Parameters
+    ----------
+    **kwargs : dict, default: None
+        Keyword arguments for the launching methods. For allowable keyword arguments, see the
+        :func:`launch_remote_modeler` and :func:`launch_docker_modeler` methods. Some of these
+        keywords might be unused.
+
+    Returns
+    -------
+    ansys.geometry.core.modeler.Modeler
+        Pythonic interface for geometry modeling.
+    """
+    # This method is a wrapper for the other launching methods. It is used to
+    # determine which method to call based on the environment.
+    #
+    # The order of the checks is as follows:
+    #
+    # 1. Check if PyPIM is configured and if the environment is configured for it.
+    # 2. Check if Docker is installed and if the environment is configured for it.
+    # 3. If you are on a Windows machine:
+    #     - check if the Ansys Geometry service is installed.
+    #     - check if Ansys SpaceClaim is installed.
+    #     - check if Ansys Discovery is installed.
+
+    # 1.Start PyAnsys Geometry with PyPIM if the environment is configured for it
     # and a directive on how to launch it was not passed.
     if _HAS_PIM and pypim.is_configured():
         logger.info("Starting Geometry service remotely. The startup configuration is ignored.")
         return launch_remote_modeler(**kwargs)
 
     # Otherwise, we are in the "local Docker Container" scenario
-    if _HAS_DOCKER and LocalDockerInstance.is_docker_installed():
-        logger.info("Starting Geometry service locally from Docker container.")
-        return launch_local_modeler(**kwargs)
+    try:
+        if _HAS_DOCKER and LocalDockerInstance.is_docker_installed():
+            logger.info("Starting Geometry service locally from Docker container.")
+            return launch_docker_modeler(**kwargs)
+    except Exception:
+        logger.warning(
+            "The local Docker container could not be started."
+            " Trying to start the Geometry service locally."
+        )
+
+    # If we are on a Windows machine, we can try to start the Geometry service locally,
+    # through various methods: Geometry service, SpaceClaim, Discovery.
+    if os.name == "nt":
+        try:
+            logger.info("Starting Geometry service locally.")
+            return launch_modeler_with_geometry_service(**kwargs)
+        except Exception as err:
+            logger.warning(
+                "The Geometry service could not be started locally."
+                " Trying to start Ansys SpaceClaim locally."
+            )
+
+        try:
+            logger.info("Starting Ansys SpaceClaim with Geometry Service locally.")
+            return launch_modeler_with_geometry_service(**kwargs)
+        except Exception as err:
+            logger.warning(
+                "Ansys SpaceClaim could not be started locally."
+                " Trying to start Ansys Discovery locally."
+            )
+
+        try:
+            logger.info("Starting Ansys Discovery with Geometry Service locally.")
+            return launch_modeler_with_geometry_service(**kwargs)
+        except Exception as err:
+            logger.warning("Ansys SpaceClaim could not be started locally.")
 
     # If we reached this point...
     raise NotImplementedError("Geometry service cannot be initialized.")
@@ -109,7 +233,7 @@ def launch_remote_modeler(version: Optional[str] = None, **kwargs: Optional[Dict
         chooses the version.
     **kwargs : dict, default: None
         Keyword arguments for the launching methods. For allowable keyword arguments, see the
-        :func:`launch_remote_modeler` and :func:`launch_local_modeler` methods. Some of these
+        :func:`launch_remote_modeler` and :func:`launch_docker_modeler` methods. Some of these
         keywords might be unused.
 
     Returns
@@ -125,7 +249,7 @@ def launch_remote_modeler(version: Optional[str] = None, **kwargs: Optional[Dict
     )
 
 
-def launch_local_modeler(
+def launch_docker_modeler(
     port: int = DEFAULT_PORT,
     connect_to_existing_service: bool = True,
     restart_if_existing_service: bool = False,
@@ -163,7 +287,7 @@ def launch_local_modeler(
         that OS.
     **kwargs : dict, default: None
         Keyword arguments for the launching methods. For allowable keyword arguments, see the
-        :func:`launch_remote_modeler` and :func:`launch_local_modeler` methods. Some of these
+        :func:`launch_remote_modeler` and :func:`launch_docker_modeler` methods. Some of these
         keywords might be unused.
 
     Returns
@@ -177,7 +301,7 @@ def launch_local_modeler(
         raise ModuleNotFoundError("The package 'docker' is required to use this function.")
 
     # Call the LocalDockerInstance ctor.
-    local_instance = LocalDockerInstance(
+    docker_instance = LocalDockerInstance(
         port=port,
         connect_to_existing_service=connect_to_existing_service,
         restart_if_existing_service=restart_if_existing_service,
@@ -185,8 +309,8 @@ def launch_local_modeler(
         image=image,
     )
 
-    # Once the local instance is ready... return the Modeler
-    return Modeler(host="localhost", port=port, local_instance=local_instance)
+    # Once the local Docker instance is ready... return the Modeler
+    return Modeler(host="localhost", port=port, docker_instance=docker_instance)
 
 
 def launch_modeler_with_discovery_and_pimlight(version: Optional[str] = None) -> "Modeler":
diff --git a/src/ansys/geometry/core/modeler.py b/src/ansys/geometry/core/modeler.py
index 242a3544..613d839a 100644
--- a/src/ansys/geometry/core/modeler.py
+++ b/src/ansys/geometry/core/modeler.py
@@ -46,7 +46,7 @@ from ansys.geometry.core.typing import Real
 if TYPE_CHECKING:  # pragma: no cover
     from ansys.platform.instancemanagement import Instance
 
-    from ansys.geometry.core.connection.local_instance import LocalDockerInstance
+    from ansys.geometry.core.connection.docker_instance import LocalDockerInstance
     from ansys.geometry.core.connection.product_instance import ProductInstance
     from ansys.geometry.core.designer.design import Design
 
@@ -68,9 +68,9 @@ class Modeler:
         is launched using `PyPIM <https://github.com/ansys/pypim>`_. This instance
         is deleted when the :func:`GrpcClient.close <ansys.geometry.core.client.GrpcClient.close>`
         method is called.
-    local_instance : LocalDockerInstance, default: None
-        Corresponding local instance when the Geometry service is launched using the
-        :func:`launch_local_modeler<ansys.geometry.core.connection.launcher.launch_local_modeler>`
+    docker_instance : LocalDockerInstance, default: None
+        Corresponding local Docker instance when the Geometry service is launched using the
+        :func:`launch_docker_modeler<ansys.geometry.core.connection.launcher.launch_docker_modeler>`
         method. This instance is deleted when the
         :func:`GrpcClient.close <ansys.geometry.core.client.GrpcClient.close>`
         method is called.
@@ -95,7 +95,7 @@ class Modeler:
         port: Union[str, int] = DEFAULT_PORT,
         channel: Optional[Channel] = None,
         remote_instance: Optional["Instance"] = None,
-        local_instance: Optional["LocalDockerInstance"] = None,
+        docker_instance: Optional["LocalDockerInstance"] = None,
         product_instance: Optional["ProductInstance"] = None,
         timeout: Optional[Real] = 120,
         logging_level: Optional[int] = logging.INFO,
@@ -108,7 +108,7 @@ class Modeler:
             port=port,
             channel=channel,
             remote_instance=remote_instance,
-            local_instance=local_instance,
+            docker_instance=docker_instance,
             product_instance=product_instance,
             timeout=timeout,
             logging_level=logging_level,


Test patch:
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index daec91a1..d1206dd1 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -38,7 +38,7 @@ import pyvista as pv
 from ansys.geometry.core import Modeler
 from ansys.geometry.core.connection.backend import BackendType
 from ansys.geometry.core.connection.defaults import GEOMETRY_SERVICE_DOCKER_IMAGE
-from ansys.geometry.core.connection.local_instance import GeometryContainers, LocalDockerInstance
+from ansys.geometry.core.connection.docker_instance import GeometryContainers, LocalDockerInstance
 
 pv.OFF_SCREEN = True
 
@@ -52,13 +52,13 @@ def docker_instance(use_existing_service):
     # 2) At least one of the Geometry service images for your OS is downloaded
     #    on the machine
     #
-    local_instance = None
+    docker_instance = None
 
     # Check 0)
     # If it is requested the connection to an existing service
-    # just return the local instance as None
+    # just return the local Docker instance as None
     if use_existing_service:
-        return local_instance
+        return docker_instance
 
     # Check 1)
     if LocalDockerInstance.is_docker_installed():
@@ -92,13 +92,13 @@ def docker_instance(use_existing_service):
 
         # Declare a LocalDockerInstance object if all checks went through
         if is_image_available:
-            local_instance = LocalDockerInstance(
+            docker_instance = LocalDockerInstance(
                 connect_to_existing_service=True,
                 restart_if_existing_service=True,
                 image=is_image_available_cont,
             )
 
-    return local_instance
+    return docker_instance
 
 
 @pytest.fixture(scope="session")
@@ -112,7 +112,7 @@ def modeler(docker_instance):
         pass
 
     modeler = Modeler(
-        local_instance=docker_instance, logging_level=logging.DEBUG, logging_file=log_file_path
+        docker_instance=docker_instance, logging_level=logging.DEBUG, logging_file=log_file_path
     )
 
     yield modeler
diff --git a/tests/integration/test_launcher_local.py b/tests/integration/test_launcher_local.py
index d95f8fab..4da25a47 100644
--- a/tests/integration/test_launcher_local.py
+++ b/tests/integration/test_launcher_local.py
@@ -30,7 +30,7 @@ from ansys.geometry.core import Modeler
 from ansys.geometry.core.connection import (
     LocalDockerInstance,
     get_geometry_container_type,
-    launch_local_modeler,
+    launch_docker_modeler,
 )
 
 SKIP_DOCKER_TESTS_CONDITION = (
@@ -52,7 +52,7 @@ def _check_no_shutdown_warning(port: int, log: str) -> bool:
 
 def _check_service_already_running(port: int, log: str) -> bool:
     msg = (
-        r"WARNING  PyAnsys_Geometry_global:local_instance\.py:[0-9]+ Service is already running at port "  # noqa : E501
+        r"WARNING  PyAnsys_Geometry_global:docker_instance\.py:[0-9]+ Service is already running at port "  # noqa : E501
         + str(port)
         + r"\.\.\."
     )
@@ -62,7 +62,7 @@ def _check_service_already_running(port: int, log: str) -> bool:
 
 def _check_restarting_service(port: int, log: str) -> bool:
     msg = (
-        r"WARNING  PyAnsys_Geometry_global:local_instance\.py:[0-9]+ Restarting service already running at port "  # noqa : E501
+        r"WARNING  PyAnsys_Geometry_global:docker_instance\.py:[0-9]+ Restarting service already running at port "  # noqa : E501
         + str(port)
         + r"\.\.\."
     )
@@ -90,10 +90,10 @@ def test_local_launcher_connect(
 
     # Trying to deploy a service there will lead to an error...
     with pytest.raises(RuntimeError, match=f"Geometry service cannot be deployed on port {port}"):
-        launch_local_modeler(port=port, connect_to_existing_service=False)
+        launch_docker_modeler(port=port, connect_to_existing_service=False)
 
     # Connect to the existing target... this will throw a warning
-    local_modeler = launch_local_modeler(
+    local_modeler = launch_docker_modeler(
         port=port, connect_to_existing_service=True, restart_if_existing_service=False
     )
     assert _check_service_already_running(port, caplog.text) is True
@@ -123,7 +123,7 @@ def test_local_launcher_connect_with_restart(
     new_port = port + 1
 
     # Launch a new modeler...
-    new_modeler = launch_local_modeler(
+    new_modeler = launch_docker_modeler(
         port=new_port,
         connect_to_existing_service=True,
         restart_if_existing_service=False,
@@ -135,7 +135,7 @@ def test_local_launcher_connect_with_restart(
     caplog.clear()
 
     # Connect to the previous modeler and restart it
-    new_modeler_restarted = launch_local_modeler(
+    new_modeler_restarted = launch_docker_modeler(
         port=new_port,
         connect_to_existing_service=True,
         restart_if_existing_service=True,
@@ -180,7 +180,7 @@ def test_try_deploying_container_with_same_name(
 
     # Launch a new modeler...
     container_name = "MY_CONTAINER"
-    new_modeler = launch_local_modeler(
+    new_modeler = launch_docker_modeler(
         port=new_port,
         connect_to_existing_service=True,
         restart_if_existing_service=False,
@@ -197,7 +197,7 @@ def test_try_deploying_container_with_same_name(
     with pytest.raises(
         RuntimeError, match="Geometry service Docker image error when initialized. Error:"
     ):
-        launch_local_modeler(
+        launch_docker_modeler(
             port=new_port_2,
             connect_to_existing_service=True,
             restart_if_existing_service=False,
diff --git a/tests/integration/test_launcher_remote.py b/tests/integration/test_launcher_remote.py
index 35709d5e..95ee8eeb 100644
--- a/tests/integration/test_launcher_remote.py
+++ b/tests/integration/test_launcher_remote.py
@@ -20,16 +20,18 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 """Test the PyPIM integration."""
+import os
 from unittest.mock import create_autospec
 
 import ansys.platform.instancemanagement as pypim
+import ansys.tools.path.path as atpp
 from grpc import insecure_channel
 import pytest
 
 from ansys.geometry.core import Modeler
 from ansys.geometry.core.connection.client import MAX_MESSAGE_LENGTH
+from ansys.geometry.core.connection.docker_instance import LocalDockerInstance
 from ansys.geometry.core.connection.launcher import launch_modeler
-from ansys.geometry.core.connection.local_instance import LocalDockerInstance
 
 
 def test_launch_remote_instance(monkeypatch, modeler: Modeler):
@@ -97,8 +99,13 @@ def test_launch_remote_instance_error(monkeypatch):
     """Check that when PyPIM is not configured, launch_modeler raises an error."""
     mock_is_installed = create_autospec(LocalDockerInstance.is_docker_installed, return_value=False)
     monkeypatch.setattr(LocalDockerInstance, "is_docker_installed", mock_is_installed)
+    mock_available_ansys = create_autospec(atpp.get_available_ansys_installations, return_value={})
+    monkeypatch.setattr(atpp, "get_available_ansys_installations", mock_available_ansys)
 
     with pytest.raises(NotImplementedError, match="Geometry service cannot be initialized."):
         launch_modeler()
 
     assert mock_is_installed.called
+
+    if os.name == "nt":
+        assert mock_available_ansys.called