ansys-mechanical-core 0.11.13__py3-none-any.whl → 0.11.15__py3-none-any.whl

ansys/mechanical/core/embedding/messages.py

@@ -0,0 +1,195 @@
+# Copyright (C) 2022 - 2025 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.
+
+"""Message Manager for App."""
+
+# TODO: add functionality to filter only errors, warnings, info
+# TODO: add max number of messages to display
+# TODO: implement pep8 formatting
+
+try:  # noqa: F401
+    import pandas as pd
+
+    HAS_PANDAS = True
+    """Whether or not pandas exists."""
+except ImportError:
+    HAS_PANDAS = False
+
+
+class MessageManager:
+    """Message manager for adding, fetching, and printing messages."""
+
+    def __init__(self, app):
+        """Initialize the message manager."""
+        self._app = app
+
+        # Import necessary classes
+        from Ansys.Mechanical.Application import Message
+        from Ansys.Mechanical.DataModel.Enums import MessageSeverityType
+
+        self._message_severity = MessageSeverityType
+        self._message = Message
+        self._messages = self._app.ExtAPI.Application.Messages
+
+    def _create_messages_data(self):  # pragma: no cover
+        """Update the local cache of messages."""
+        data = {
+            "Severity": [],
+            "TimeStamp": [],
+            "DisplayString": [],
+            "Source": [],
+            "StringID": [],
+            "Location": [],
+            "RelatedObjects": [],
+        }
+        for msg in self._app.ExtAPI.Application.Messages:
+            data["Severity"].append(str(msg.Severity).upper())
+            data["TimeStamp"].append(msg.TimeStamp)
+            data["DisplayString"].append(msg.DisplayString)
+            data["Source"].append(msg.Source)
+            data["StringID"].append(msg.StringID)
+            data["Location"].append(msg.Location)
+            data["RelatedObjects"].append(msg.RelatedObjects)
+
+        return data
+
+    def __repr__(self):  # pragma: no cover
+        """Provide a DataFrame representation of all messages."""
+        if not HAS_PANDAS:
+            return "Pandas is not available. Please pip install pandas to display messages."
+        data = self._create_messages_data()
+        return repr(pd.DataFrame(data))
+
+    def __str__(self):
+        """Provide a custom string representation of the messages."""
+        if self._messages.Count == 0:
+            return "No messages to display."
+
+        formatted_messages = [f"[{msg.Severity}] : {msg.DisplayString}" for msg in self._messages]
+        return "\n".join(formatted_messages)
+
+    def __getitem__(self, index):
+        """Allow indexed access to messages."""
+        if len(self._messages) == 0:
+            raise IndexError("No messages are available.")
+        if index >= len(self._messages) or index < 0:
+            raise IndexError("Message index out of range.")
+        return self._messages[index]
+
+    def __len__(self):
+        """Return the number of messages."""
+        return self._messages.Count
+
+    def add(self, severity: str, text: str):
+        """Add a message and update the cache.
+
+        Parameters
+        ----------
+        severity : str
+            Severity of the message. Can be "info", "warning", or "error".
+        text : str
+            Message text.
+
+        Examples
+        --------
+        >>> app.messages.add("info", "User clicked the start button.")
+        """
+        severity_map = {
+            "info": self._message_severity.Info,
+            "warning": self._message_severity.Warning,
+            "error": self._message_severity.Error,
+        }
+
+        if severity.lower() not in severity_map:
+            raise ValueError(f"Invalid severity: {severity}")
+
+        _msg = self._message(text, severity_map[severity.lower()])
+        self._messages.Add(_msg)
+
+    def remove(self, index: int):
+        """Remove a message by index.
+
+        Parameters
+        ----------
+        index : int
+            Index of the message to remove.
+
+        Examples
+        --------
+        >>> app.messages.remove(0)
+        """
+        if index >= len(self._app.ExtAPI.Application.Messages) or index < 0:
+            raise IndexError("Message index out of range.")
+        _msg = self._messages[index]
+        self._messages.Remove(_msg)
+
+    def _show_string(self, filter: str = "Severity;DisplayString") -> str:
+        if self._messages.Count == 0:
+            return "No messages to display."
+
+        if filter == "*":
+            selected_columns = [
+                "TimeStamp",
+                "Severity",
+                "DisplayString",
+                "Source",
+                "StringID",
+                "Location",
+                "RelatedObjects",
+            ]
+        else:
+            selected_columns = [col.strip() for col in filter.split(";")]
+
+        lines = []
+        for msg in self._messages:
+            for key in selected_columns:
+                line = f"{key}: {getattr(msg, key, 'Specified attribute not found.')}"
+                lines.append(line)
+        return "\n".join(lines)
+
+    def show(self, filter="Severity;DisplayString") -> None:
+        """Print all messages with full details.
+
+        Parameters
+        ----------
+        filter : str, optional
+            Semicolon separated list of message attributes to display.
+            Default is "severity;message".
+            if filter is "*", all available attributes will be displayed.
+
+        Examples
+        --------
+        >>> app.messages.show()
+        ... severity: info
+        ... message: Sample message.
+
+        >>> app.messages.show(filter="time_stamp;severity;message")
+        ... time_stamp: 1/30/2025 12:10:35 PM
+        ... severity: info
+        ... message: Sample message.
+        """
+        show_string = self._show_string(filter)
+        print(show_string)
+
+    def clear(self):
+        """Clear all messages."""
+        self._messages.Clear()

ansys/mechanical/core/embedding/resolver.py

@@ -41,7 +41,7 @@ def resolve(version):
         resolve_handler = assembly_resolver.MechanicalResolveEventHandler
         System.AppDomain.CurrentDomain.AssemblyResolve += resolve_handler
     except AttributeError:
-        error_msg = f"""Unable to resolve Mechanical assemblies. Please ensure the following:
+        error_msg = """Unable to resolve Mechanical assemblies. Please ensure the following:
     1. Mechanical is installed.
     2. A folder with the name "Ansys" does not exist in the same directory as the script being run.
     """

ansys/mechanical/core/embedding/rpc/__init__.py

@@ -22,15 +22,11 @@
 
 """RPC and Mechanical service implementation."""
 from .client import Client
-
-# todo - provide an implementation of Server (RemoteMechancial) that installs the below
-# from .default_server import RemoteMechanical
-#        and remove them from this import statement
-# todo - combine Server and MechanicalService
+from .default_server import DefaultServiceMethods, MechanicalDefaultServer
 from .server import (
-    DefaultServiceMethods,
-    MechanicalDefaultServer,
     MechanicalEmbeddedServer,
     MechanicalService,
 )
 from .utils import get_remote_methods, remote_method
+
+# todo - combine Server and MechanicalService

ansys/mechanical/core/embedding/rpc/client.py

@@ -27,13 +27,16 @@ import time
 
 import rpyc
 
+from ansys.mechanical.core.embedding.rpc.utils import PYMECHANICAL_DEFAULT_RPC_PORT
 from ansys.mechanical.core.mechanical import DEFAULT_CHUNK_SIZE
 
 
 class Client:
     """Client for connecting to Mechanical services."""
 
-    def __init__(self, host: str, port: int, timeout: float = 120.0):
+    def __init__(
+        self, host: str, port: int, timeout: float = 120.0, cleanup_on_exit=True, process=None
+    ):
         """Initialize the client.
 
         Parameters
@@ -43,18 +46,28 @@ class Client:
             in which case ``localhost`` is used.
         port : int, optional
             Port to connect to the Mecahnical server. The default is ``None``,
-            in which case ``10000`` is used.
+            in which case ``20000`` is used.
         timeout : float, optional
             Maximum allowable time for connecting to the Mechanical server.
             The default is ``60.0``.
+        process: subprocess.Popen, optional
+            The process object that was connected to
 
         """
+        if host is None:
+            host = "localhost"
         self.host = host
+        if port is None:
+            port = PYMECHANICAL_DEFAULT_RPC_PORT
         self.port = port
+        self._process = process
         self.timeout = timeout
         self.connection = None
         self.root = None
         self._connect()
+        self._cleanup_on_exit = cleanup_on_exit
+        self._error_type = Exception
+        self._has_exited = False
 
     def __getattr__(self, attr):
         """Get attribute from the root object."""
@@ -77,29 +90,38 @@ class Client:
 
     def _connect(self):
         self._wait_until_ready()
-        self.connection = rpyc.connect(self.host, self.port)
         self.root = self.connection.root
         print(f"Connected to {self.host}:{self.port}")
-        print(f"Installed methods")
+
+    def _exponential_backoff(self, max_time=60.0, base_time=0.1, factor=2):
+        """Generate exponential backoff timing."""
+        t_max = time.time() + max_time
+        t = base_time
+        while time.time() < t_max:
+            yield t
+            t = min(t * factor, max_time)
 
     def _wait_until_ready(self):
+        """Wait until the server is ready."""
         t_max = time.time() + self.timeout
-        while time.time() < t_max:
+        for delay in self._exponential_backoff(max_time=self.timeout):
+            if time.time() >= t_max:
+                break  # Exit if the timeout is reached
             try:
-                conn = rpyc.connect(self.host, self.port)
-                conn.ping()  # Simple ping to check if the connection is healthy
-                conn.close()
-                print("Server is ready to connect")
-                break
-            except:
-                time.sleep(2)
-        else:
-            raise TimeoutError(
-                f"Server at {self.host}:{self.port} not ready within {self.timeout} seconds."
-            )
+                self.connection = rpyc.connect(self.host, self.port)
+                self.connection.ping()
+                print("Server is ready.")
+                return
+            except Exception:
+                time.sleep(delay)
+
+        raise TimeoutError(
+            f"Server at {self.host}:{self.port} not ready within {self.timeout} seconds."
+        )
 
     def close(self):
         """Close the connection."""
+        print("Closing the connection")
         self.connection.close()
         print(f"Connection to {self.host}:{self.port} closed")
 
@@ -220,6 +242,11 @@ class Client:
             list_of_files.extend(temp_files)
         return list_of_files
 
+    @property
+    def backend(self) -> str:
+        """Get the backend type."""
+        return "python"
+
     @property
     def is_alive(self):
         """Check if the Mechanical instance is alive."""
@@ -231,7 +258,16 @@ class Client:
 
     def exit(self):
         """Shuts down the Mechanical instance."""
-        print("Requesting server shutdown ...")
-        self.root.service_exit()
-        self.connection.close()
+        if self._has_exited:
+            return
+        self.close()
+        self._has_exited = True
         print("Disconnected from server")
+
+    def __del__(self):  # pragma: no cover
+        """Clean up on exit."""
+        if self._cleanup_on_exit:
+            try:
+                self.exit()
+            except Exception as e:
+                print(f"Failed to exit cleanly: {e}")

ansys/mechanical/core/embedding/rpc/default_server.py

@@ -0,0 +1,131 @@
+# Copyright (C) 2022 - 2025 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.
+"""Remote Procedure Call (RPC) server."""
+
+import fnmatch
+import os
+
+from ansys.mechanical.core.embedding.app import App
+
+from .server import MechanicalEmbeddedServer
+from .utils import remote_method
+
+
+class DefaultServiceMethods:
+    """Default service methods for MechanicalEmbeddedServer."""
+
+    def __init__(self, app: App):
+        """Initialize the DefaultServiceMethods."""
+        self._app = app
+
+    def __repr__(self):
+        """Return the representation of the instance."""
+        return '"ServiceMethods instance"'
+
+    @remote_method
+    def run_python_script(
+        self, script: str, enable_logging=False, log_level="WARNING", progress_interval=2000
+    ):
+        """Run scripts using Internal python engine."""
+        result = self._app.execute_script(script)
+        return result
+
+    @remote_method
+    def run_python_script_from_file(
+        self,
+        file_path: str,
+        enable_logging=False,
+        log_level="WARNING",
+        progress_interval=2000,
+    ):
+        """Run scripts using Internal python engine."""
+        return self._app.execute_script_from_file(file_path)
+
+    @remote_method
+    def clear(self):
+        """Clear the current project."""
+        self._app.new()
+
+    @property
+    @remote_method
+    def project_directory(self):
+        """Get the project directory."""
+        return self._app.ExtAPI.DataModel.Project.ProjectDirectory
+
+    @remote_method
+    def list_files(self):
+        """List all files in the project directory."""
+        list = []
+        mechdbPath = self._app.ExtAPI.DataModel.Project.FilePath
+        if mechdbPath != "":
+            list.append(mechdbPath)
+        rootDir = self._app.ExtAPI.DataModel.Project.ProjectDirectory
+
+        for dirPath, dirNames, fileNames in os.walk(rootDir):
+            for fileName in fileNames:
+                list.append(os.path.join(dirPath, fileName))
+        files_out = "\n".join(list).splitlines()
+        if not files_out:  # pragma: no cover
+            print("No files listed")
+        return files_out
+
+    @remote_method
+    def _get_files(self, files, recursive=False):
+        self_files = self.list_files()  # to avoid calling it too much
+
+        if isinstance(files, str):
+            if files in self_files:
+                list_files = [files]
+            elif "*" in files:
+                list_files = fnmatch.filter(self_files, files)
+                if not list_files:
+                    raise ValueError(
+                        f"The `'files'` parameter ({files}) didn't match any file using "
+                        f"glob expressions in the remote server."
+                    )
+            else:
+                raise ValueError(
+                    f"The `'files'` parameter ('{files}') does not match any file or pattern."
+                )
+
+        elif isinstance(files, (list, tuple)):
+            if not all([isinstance(each, str) for each in files]):
+                raise ValueError(
+                    "The parameter `'files'` can be a list or tuple, but it "
+                    "should only contain strings."
+                )
+            list_files = files
+        else:
+            raise ValueError(
+                f"The `file` parameter type ({type(files)}) is not supported."
+                "Only strings, tuple of strings, or list of strings are allowed."
+            )
+
+        return list_files
+
+
+class MechanicalDefaultServer(MechanicalEmbeddedServer):
+    """Default server with default service methods."""
+
+    def __init__(self, **kwargs):
+        """Initialize the MechanicalDefaultServer."""
+        super().__init__(impl=DefaultServiceMethods, **kwargs)