Improvements to open_gui (#1267)

* Implement the option to run inplace. Using original jobname.

* Making sure the start_parameter is updated and stored.

* Added MAPDLdidnotstart exception class.

* Using new error class.

* Updated docstring.

* removing error classes.

* small fix.

* Making sure there is no edge cases in args

* Fixing coverage and adding unit tests to error classes.

* Updating docstrings

* fixing error class inits

* fixing init load

Author: germa89

src/ansys/mapdl/core/errors.py

@@ -75,13 +75,20 @@ def __init__(self, msg=LOCKFILE_MSG):
         RuntimeError.__init__(self, msg)
 
 
-class LicenseServerConnectionError(RuntimeError):
-    """Error when the license server is not available."""
+class MapdlDidNotStart(RuntimeError):
+    """Error when the MAPDL process does not start"""
 
     def __init__(self, msg=""):
         RuntimeError.__init__(self, msg)
 
 
+class LicenseServerConnectionError(MapdlDidNotStart):
+    """Error when the license server is not available."""
+
+    def __init__(self, msg=""):
+        MapdlDidNotStart.__init__(self, msg)
+
+
 # handler for protect_grpc
 def handler(sig, frame):  # pragma: no cover
     """Pass signal to custom interrupt handler."""
@@ -144,3 +151,43 @@ def wrapper(*args, **kwargs):
         return out
 
     return wrapper
+
+
+class MapdlException(MapdlRuntimeError):
+
+    """General MAPDL exception."""
+
+    def __init__(self, msg=""):
+        MapdlRuntimeError.__init__(self, msg)
+
+
+class MapdlError(MapdlException):
+
+    """General MAPDL Error"""
+
+    def __init__(self, msg=""):
+        MapdlException.__init__(self, msg)
+
+
+class MapdlWarning(MapdlException):
+
+    """General MAPDL warning"""
+
+    def __init__(self, msg=""):
+        MapdlException.__init__(self, msg)
+
+
+class MapdlNote(MapdlException):
+
+    """General MAPDL note"""
+
+    def __init__(self, msg=""):
+        MapdlException.__init__(self, msg)
+
+
+class MapdlInfo(MapdlException):
+
+    """General MAPDL info message"""
+
+    def __init__(self, msg=""):
+        MapdlException.__init__(self, msg)

src/ansys/mapdl/core/launcher.py

@@ -22,7 +22,7 @@
 
 from ansys.mapdl import core as pymapdl
 from ansys.mapdl.core import LOG
-from ansys.mapdl.core.errors import LockFileException, VersionError
+from ansys.mapdl.core.errors import LockFileException, MapdlDidNotStart, VersionError
 from ansys.mapdl.core.licensing import ALLOWABLE_LICENSES, LicenseChecker
 from ansys.mapdl.core.mapdl import _MapdlCore
 from ansys.mapdl.core.mapdl_grpc import MAX_MESSAGE_LENGTH, MapdlGrpc
@@ -221,7 +221,7 @@ def launch_grpc(
     timeout=20,
     verbose=False,
     **kwargs,
-) -> tuple:
+) -> tuple:  # pragma: no cover
     """Start MAPDL locally in gRPC mode.
 
     Parameters
@@ -496,9 +496,8 @@ def launch_grpc(
             ]
         )
         command = " ".join(command_parm)
-
+    LOG.info(f"Running in {ip}:{port} the following command: '{command}'")
     if verbose:
-        print(f"Running {command}")
         subprocess.Popen(command, shell=os.name != "nt", cwd=run_location)
     else:
         subprocess.Popen(
@@ -520,9 +519,15 @@ def launch_grpc(
         files = os.listdir(run_location)
         has_ans = any([filename for filename in files if ".err" in filename])
         if has_ans:
+            LOG.info("MAPDL session successfully started (Error file found)")
             break
         time.sleep(sleep_time)
 
+    if not has_ans:
+        raise MapdlDidNotStart(
+            f"MAPDL failed to start (No err file generated in '{run_location}')"
+        )
+
     return port, run_location
 
 

src/ansys/mapdl/core/mapdl.py

@@ -7,6 +7,7 @@
 import pathlib
 import re
 from shutil import copyfile, rmtree
+from subprocess import DEVNULL, call
 import tempfile
 import time
 import warnings
@@ -805,13 +806,21 @@ def _generate_iges(self):
         self.igesout(filename, att=1, mute=True)
         return filename
 
-    def open_gui(self, include_result=True):  # pragma: no cover
+    def open_gui(self, include_result=None, inplace=None):  # pragma: no cover
         """Saves existing database and opens up the APDL GUI.
 
         Parameters
         ----------
         include_result : bool, optional
             Allow the result file to be post processed in the GUI.
+            It is ignored if 'inplace' is ``True``.
+            By default, it is ``True``.
+
+        inplace : bool, optional
+            Open the GUI on the current working directory, instead of create
+            a new temporary directory and copy the results files over there.
+            If ``True``, it ignores 'include_result' kwarg.
+            By default, it is ``False``.
 
         Examples
         --------
@@ -849,17 +858,38 @@ def open_gui(self, include_result=True):  # pragma: no cover
                 "``open_gui`` can only be called from a local " "MAPDL instance"
             )
 
-        # specify a path for the temporary database
-        temp_dir = tempfile.gettempdir()
-        save_path = os.path.join(temp_dir, f"ansys_{random_string(10)}")
-        if os.path.isdir(save_path):
-            rmtree(save_path)
-        os.mkdir(save_path)
+        if inplace and include_result:
+            raise ValueError(
+                "'inplace' and 'include_result' kwargs are not compatible."
+            )
+
+        if inplace and include_result is None:
+            include_result = False
+
+        elif not include_result:
+            include_result = True
+
+        if not inplace:
+            inplace = False
+
+        name = self.jobname
+
+        # specify a path for the temporary database if any.
+        if inplace:
+            run_dir = self._start_parm["run_location"]
 
-        name = "tmp"
-        tmp_database = os.path.join(save_path, "%s.db" % name)
-        if os.path.isfile(tmp_database):
-            os.remove(tmp_database)
+        else:
+            temp_dir = tempfile.gettempdir()
+            run_dir = os.path.join(temp_dir, f"ansys_{random_string(10)}")
+
+            # Sanity checks
+            if os.path.isdir(run_dir):
+                rmtree(run_dir)
+            os.mkdir(run_dir)
+
+        database_file = os.path.join(run_dir, "%s.db" % name)
+        if os.path.isfile(database_file) and not inplace:
+            os.remove(database_file)
 
         # cache result file, version, and routine before closing
         resultfile = self._result_file
@@ -868,40 +898,56 @@ def open_gui(self, include_result=True):  # pragma: no cover
 
         # finish, save and exit the server
         self.finish(mute=True)
-        self.save(tmp_database, mute=True)
+        self.save(database_file, mute=True)
         self.exit()
 
         # copy result file to temp directory
-        if include_result and self._result_file is not None:
-            if os.path.isfile(resultfile):
-                tmp_resultfile = os.path.join(save_path, "%s.rst" % name)
-                copyfile(resultfile, tmp_resultfile)
+        if not inplace:
+            if include_result and self._result_file is not None:
+                if os.path.isfile(resultfile):
+                    tmp_resultfile = os.path.join(run_dir, "%s.rst" % name)
+                    copyfile(resultfile, tmp_resultfile)
 
         # write temporary input file
-        start_file = os.path.join(save_path, "start%s.ans" % version)
+        start_file = os.path.join(run_dir, "start%s.ans" % version)
         with open(start_file, "w") as f:
             f.write("RESUME\n")
 
         # some versions of ANSYS just look for "start.ans" when starting
-        other_start_file = os.path.join(save_path, "start.ans")
+        other_start_file = os.path.join(run_dir, "start.ans")
         with open(other_start_file, "w") as f:
             f.write("RESUME\n")
 
         # issue system command to run ansys in GUI mode
         cwd = os.getcwd()
-        os.chdir(save_path)
+        os.chdir(run_dir)
         exec_file = self._start_parm.get("exec_file", get_ansys_path(allow_input=False))
         nproc = self._start_parm.get("nproc", 2)
         add_sw = self._start_parm.get("additional_switches", "")
-        os.system(
-            f'cd "{save_path}" && "{exec_file}" -g -j {name} -np {nproc} {add_sw}'
+
+        if inplace:
+            warn(
+                "MAPDL GUI is opened using 'inplace' kwarg."
+                f"Hence the changes you do will overwrite the files in {run_dir}."
+            )
+
+        call(
+            f'cd "{run_dir}" && "{exec_file}" -g -j {name} -np {nproc} {add_sw}',
+            shell=True,
+            stdout=DEVNULL,
         )
+
+        # Going back
         os.chdir(cwd)
-        # Consider removing this temporary directory
+
+        # Clearing
+        os.remove(start_file)
+        os.remove(other_start_file)
 
         # reattach to a new session and reload database
         self._launch(self._start_parm)
-        self.resume(tmp_database, mute=True)
+        self.resume(database_file, mute=True)
+        self.save()
 
     def _cache_routine(self):
         """Cache the current routine."""

src/ansys/mapdl/core/mapdl_grpc.py

@@ -280,7 +280,7 @@ def __init__(
         print_com=False,
         channel=None,
         remote_instance=None,
-        **kwargs,
+        **start_parm,
     ):
         """Initialize connection to the mapdl server"""
         self.__distributed = None
@@ -302,7 +302,7 @@ def __init__(
             log_apdl=log_apdl,
             log_file=log_file,
             print_com=print_com,
-            **kwargs,
+            **start_parm,
         )
 
         # gRPC request specific locks as these gRPC request are not thread safe
@@ -314,18 +314,23 @@ def __init__(
         self._stub = None
         self._cleanup = cleanup_on_exit
         self._remove_tmp = remove_temp_files
-        self._jobname = kwargs.pop("jobname", "file")
-        self._path = kwargs.pop("run_location", None)
+        self._jobname = start_parm.get("jobname", "file")
+        self._path = start_parm.get("run_location", None)
         self._busy = False  # used to check if running a command on the server
         self._local = ip in ["127.0.0.1", "127.0.1.1", "localhost"]
-        if "local" in kwargs:  # pragma: no cover  # allow this to be overridden
-            self._local = kwargs["local"]
+        if "local" in start_parm:  # pragma: no cover  # allow this to be overridden
+            self._local = start_parm["local"]
         self._health_response_queue = None
         self._exiting = False
         self._exited = None
         self._mute = False
         self._db = None
 
+        # saving for later use (for example open_gui)
+        start_parm["ip"] = ip
+        start_parm["port"] = port
+        self._start_parm = start_parm
+
         if port is None:
             from ansys.mapdl.core.launcher import MAPDL_DEFAULT_PORT
 
@@ -345,11 +350,11 @@ def __init__(
 
         # double check we have access to the local path if not
         # explicitly specified
-        if "local" not in kwargs:
+        if "local" not in start_parm:
             self._verify_local()
 
         # only cache process IDs if launched locally
-        if self._local and "exec_file" in kwargs:
+        if self._local and "exec_file" in start_parm:
             self._cache_pids()
 
     def _create_channel(self, ip, port):

tests/test_errors.py

@@ -1,6 +1,14 @@
 import pytest
 
-from ansys.mapdl.core.errors import MapdlRuntimeError
+from ansys.mapdl.core.errors import (
+    MapdlDidNotStart,
+    MapdlError,
+    MapdlException,
+    MapdlInfo,
+    MapdlNote,
+    MapdlRuntimeError,
+    MapdlWarning,
+)
 
 error_shape_error_limits = """
 
@@ -79,3 +87,13 @@ def test_raise_output_errors(mapdl, response, expected_error):
             mapdl._raise_output_errors(response)
     else:
         mapdl._raise_output_errors(response)
+
+
+@pytest.mark.parametrize(
+    "error_class",
+    [MapdlDidNotStart, MapdlException, MapdlError, MapdlWarning, MapdlNote, MapdlInfo],
+)
+def test_exception_classes(error_class):
+    message = "Exception message"
+    with pytest.raises(error_class):
+        raise error_class(message)