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

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

@@ -0,0 +1,237 @@
+# 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.
+"""Client for Mechanical services."""
+
+import os
+import pathlib
+import time
+
+import rpyc
+
+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):
+        """Initialize the client.
+
+        Parameters
+        ----------
+        host : str, optional
+            IP address to connect to the server.  The default is ``None``
+            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.
+        timeout : float, optional
+            Maximum allowable time for connecting to the Mechanical server.
+            The default is ``60.0``.
+
+        """
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self.connection = None
+        self.root = None
+        self._connect()
+
+    def __getattr__(self, attr):
+        """Get attribute from the root object."""
+        if hasattr(self.root, attr):
+            return getattr(self.root, attr)
+        propget_name = f"propget_{attr}"
+        if hasattr(self.root, propget_name):
+            exposed_fget = getattr(self.root, propget_name)
+            return exposed_fget()
+        return self.__dict__.items[attr]
+
+    # TODO - implement setattr
+    # def __setattr__(self, attr, value):
+    #     if hasattr(self.root, attr):
+    #         inner_prop = getattr(self.root.__class__, attr)
+    #         if isinstance(inner_prop, property):
+    #             inner_prop.fset(self.root, value)
+    #     else:
+    #         super().__setattr__(attr, value)
+
+    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 _wait_until_ready(self):
+        t_max = time.time() + self.timeout
+        while time.time() < t_max:
+            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."
+            )
+
+    def close(self):
+        """Close the connection."""
+        self.connection.close()
+        print(f"Connection to {self.host}:{self.port} closed")
+
+    def upload(
+        self,
+        file_name,
+        file_location_destination=None,
+        chunk_size=DEFAULT_CHUNK_SIZE,
+        progress_bar=False,
+    ):
+        """Upload a file to the server."""
+        print(f"arg: {file_name}, {file_location_destination}")
+        print()
+        if not os.path.exists(file_name):
+            print(f"File {file_name} does not exist.")
+            return
+        file_base_name = os.path.basename(file_name)
+        remote_path = os.path.join(file_location_destination, file_base_name)
+
+        with open(file_name, "rb") as f:
+            file_data = f.read()
+            self.service_upload(remote_path, file_data)
+
+        print(f"File {file_name} uploaded to {file_location_destination}")
+
+    def download(
+        self,
+        files,
+        target_dir=None,
+        chunk_size=DEFAULT_CHUNK_SIZE,
+        progress_bar=None,
+        recursive=False,
+    ):
+        """Download a file from the server."""
+        out_files = []
+        os.makedirs(target_dir, exist_ok=True)
+
+        response = self.service_download(files)
+
+        if isinstance(response, dict) and response["is_directory"]:
+            for relative_file_path in response["files"]:
+                full_remote_path = os.path.join(files, relative_file_path)
+                local_file_path = os.path.join(target_dir, relative_file_path)
+                local_file_dir = os.path.dirname(local_file_path)
+                os.makedirs(local_file_dir, exist_ok=True)
+
+                out_file_path = self._download_file(
+                    full_remote_path, local_file_path, chunk_size, overwrite=True
+                )
+        else:
+            out_file_path = self._download_file(
+                files, os.path.join(target_dir, os.path.basename(files)), chunk_size, overwrite=True
+            )
+        out_files.append(out_file_path)
+
+        return out_files
+
+    def _download_file(self, remote_file_path, local_file_path, chunk_size=1024, overwrite=False):
+        if os.path.exists(local_file_path) and not overwrite:
+            print(f"File {local_file_path} already exists locally. Skipping download.")
+            return
+        response = self.service_download(remote_file_path)
+        if isinstance(response, dict):
+            raise ValueError("Expected a file download, but got a directory response.")
+        file_data = response
+
+        # Write the file data to the local path
+        with open(local_file_path, "wb") as f:
+            f.write(file_data)
+
+        print(f"File {remote_file_path} downloaded to {local_file_path}")
+
+        return local_file_path
+
+    def download_project(self, extensions=None, target_dir=None, progress_bar=False):
+        """Download all project files in the working directory of the Mechanical instance."""
+        destination_directory = target_dir.rstrip("\\/")
+        if destination_directory:
+            path = pathlib.Path(destination_directory)
+            path.mkdir(parents=True, exist_ok=True)
+        else:
+            destination_directory = os.getcwd()
+        # relative directory?
+        if os.path.isdir(destination_directory):
+            if not os.path.isabs(destination_directory):
+                # construct full path
+                destination_directory = os.path.join(os.getcwd(), destination_directory)
+        _project_directory = self.project_directory
+        _project_directory = _project_directory.rstrip("\\/")
+
+        # this is where .mechddb resides
+        parent_directory = os.path.dirname(_project_directory)
+
+        list_of_files = []
+
+        if not extensions:
+            files = self.list_files()
+        else:
+            files = []
+            for each_extension in extensions:
+                # mechdb resides one level above project directory
+                if "mechdb" == each_extension.lower():
+                    file_temp = os.path.join(parent_directory, f"*.{each_extension}")
+                else:
+                    file_temp = os.path.join(_project_directory, "**", f"*.{each_extension}")
+
+                list_files = self._get_files(file_temp, recursive=False)
+
+                files.extend(list_files)
+
+        for file in files:
+            # create similar hierarchy locally
+            new_path = file.replace(parent_directory, destination_directory)
+            new_path_dir = os.path.dirname(new_path)
+            temp_files = self.download(
+                files=file, target_dir=new_path_dir, progress_bar=progress_bar
+            )
+            list_of_files.extend(temp_files)
+        return list_of_files
+
+    @property
+    def is_alive(self):
+        """Check if the Mechanical instance is alive."""
+        try:
+            self.connection.ping()
+            return True
+        except:
+            return False
+
+    def exit(self):
+        """Shuts down the Mechanical instance."""
+        print("Requesting server shutdown ...")
+        self.root.service_exit()
+        self.connection.close()
+        print("Disconnected from server")

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

@@ -0,0 +1,382 @@
+# 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
+import typing
+
+import rpyc
+from rpyc.utils.server import ThreadedServer
+import toolz
+
+from ansys.mechanical.core.embedding.background import BackgroundApp
+from ansys.mechanical.core.mechanical import port_in_use
+
+from .utils import MethodType, get_remote_methods, remote_method
+
+# TODO : implement logging
+
+PYMECHANICAL_DEFAULT_RPC_PORT = 20000
+
+
+class MechanicalService(rpyc.Service):
+    """Starts Mechanical app services."""
+
+    def __init__(self, backgroundapp, functions=[], impl=None):
+        """Initialize the service."""
+        super().__init__()
+        self._backgroundapp = backgroundapp
+        self._install_functions(functions)
+        self._install_class(impl)
+        self.EMBEDDED = True
+
+    def _install_functions(self, methods):
+        """Install the given list of methods."""
+        [self._install_function(method) for method in methods]
+
+    def _install_class(self, impl):
+        """Install methods from the given implemented class."""
+        print("Install class")
+        if impl is None:
+            return
+        print("Installing methods from class")
+        for methodname, method, methodtype in get_remote_methods(impl):
+            print(f"installing {methodname} of {impl}")
+            if methodtype == MethodType.METHOD:
+                self._install_method(method)
+            elif methodtype == MethodType.PROP:
+                self._install_property(method, methodname)
+
+    def on_connect(self, conn):
+        """Handle client connection."""
+        print("Client connected")
+        print(self._backgroundapp.app)
+
+    def on_disconnect(self, conn):
+        """Handle client disconnection."""
+        print("Client disconnected")
+
+    def _curry_property(self, prop, propname, get: bool):
+        """Curry the given property."""
+
+        def posted(*arg):
+            def curried():
+                if get:
+                    return getattr(prop._owner, propname)
+                else:
+                    setattr(prop._owner, propname, *arg)
+
+            return self._backgroundapp.try_post(curried)
+
+        return posted
+
+    def _curry_method(self, method, realmethodname):
+        """Curry the given method."""
+
+        def posted(*args, **kwargs):
+            def curried():
+                original_method = getattr(method._owner, realmethodname)
+                result = original_method(*args, **kwargs)
+                return result
+
+            return self._backgroundapp.try_post(curried)
+
+        return posted
+
+    def _curry_function(self, methodname):
+        """Curry the given function."""
+        wrapped = getattr(self, methodname)
+        curried_method = toolz.curry(wrapped)
+
+        def posted(*args, **kwargs):
+            def curried():
+                return curried_method(self._app, *args, **kwargs)
+
+            return self._backgroundapp.try_post(curried)
+
+        return posted
+
+    def _install_property(self, prop: property, propname: str):
+        """Install property with inner and exposed pairs."""
+        if prop.fget:
+            exposed_get_name = f"exposed_propget_{propname}"
+
+            def exposed_propget():
+                """Convert to exposed getter."""
+                f = self._curry_property(prop.fget, propname, True)
+                result = f()
+                return result
+
+            setattr(self, exposed_get_name, exposed_propget)
+        if prop.fset:
+            exposed_set_name = f"exposed_propset_{propname}"
+
+            def exposed_propset(arg):
+                """Convert to exposed getter."""
+                f = self._curry_property(prop.fset, propname, True)
+                result = f(arg)
+                return result
+
+            setattr(self, exposed_set_name, exposed_propset)
+
+    def _install_method(self, method):
+        methodname = method.__name__
+        self._install_method_with_name(method, methodname, methodname)
+
+    def _install_method_with_name(self, method, methodname, innername):
+        """Install methods of impl with inner and exposed pairs."""
+        exposed_name = f"exposed_{methodname}"
+
+        def exposed_method(*args, **kwargs):
+            """Convert to exposed method."""
+            f = self._curry_method(method, innername)
+            result = f(*args, **kwargs)
+            return result
+
+        setattr(self, exposed_name, exposed_method)
+
+    def _install_function(self, function):
+        """Install a functions with inner and exposed pairs."""
+        print(f"Installing {function}")
+        exposed_name = f"exposed_{function.__name__}"
+        inner_name = f"inner_{function.__name__}"
+
+        def inner_method(app, *args, **kwargs):
+            """Convert to inner method."""
+            return function(app, *args, **kwargs)
+
+        def exposed_method(*args, **kwargs):
+            """Convert to exposed method."""
+            f = self._curry_function(inner_name)
+            return f(*args, **kwargs)
+
+        setattr(self, inner_name, inner_method)
+        setattr(self, exposed_name, exposed_method)
+
+    def exposed_service_upload(self, remote_path, file_data):
+        """Handle file upload request from client."""
+        if not remote_path:
+            raise ValueError("The remote file path is empty.")
+
+        remote_dir = os.path.dirname(remote_path)
+
+        if remote_dir:
+            os.makedirs(remote_dir, exist_ok=True)
+
+        with open(remote_path, "wb") as f:
+            f.write(file_data)
+
+        print(f"File {remote_path} uploaded successfully.")
+
+    def exposed_service_download(self, remote_path):
+        """Handle file download request from client."""
+        # Check if the remote file exists
+        if not os.path.exists(remote_path):
+            raise FileNotFoundError(f"The file {remote_path} does not exist on the server.")
+
+        if os.path.isdir(remote_path):
+            files = []
+            for dirpath, _, filenames in os.walk(remote_path):
+                for filename in filenames:
+                    full_path = os.path.join(dirpath, filename)
+                    relative_path = os.path.relpath(full_path, remote_path)
+                    files.append(relative_path)
+            return {"is_directory": True, "files": files}
+
+        with open(remote_path, "rb") as f:
+            file_data = f.read()
+
+        print(f"File {remote_path} downloaded successfully.")
+        return file_data
+
+    def exposed_service_exit(self):
+        """Exit the server."""
+        self._backgroundapp.stop()
+        self._backgroundapp = None
+
+
+class MechanicalEmbeddedServer:
+    """Start rpc server."""
+
+    def __init__(
+        self,
+        service: typing.Type[rpyc.Service] = MechanicalService,
+        port: int = None,
+        version: int = None,
+        methods: typing.List[typing.Callable] = [],
+        impl=None,
+    ):
+        """Initialize the server."""
+        self._exited = False
+        self._background_app = BackgroundApp(version=version)
+        self._service = service
+        self._methods = methods
+        print("Initializing Mechanical ...")
+
+        self._port = self.get_free_port(port)
+        if impl is None:
+            self._impl = None
+        else:
+            self._impl = impl(self._background_app.app)
+
+        my_service = self._service(self._background_app, self._methods, self._impl)
+        self._server = ThreadedServer(my_service, port=self._port)
+
+    @staticmethod
+    def get_free_port(port=None):
+        """Get free port.
+
+        If port is not given, it will find a free port starting from PYMECHANICAL_DEFAULT_RPC_PORT.
+        """
+        if port is None:
+            port = PYMECHANICAL_DEFAULT_RPC_PORT
+
+        while port_in_use(port):
+            port += 1
+
+        return port
+
+    def start(self) -> None:
+        """Start server on specified port."""
+        print(
+            f"Starting mechanical application in server.\n"
+            f"Listening on port {self._port}\n{self._background_app.app}"
+        )
+        self._server.start()
+        """try:
+            try:
+                conn.serve_all()
+            except KeyboardInterrupt:
+                print("User interrupt!")
+        finally:
+            conn.close()"""
+        self._exited = True
+
+    def stop(self) -> None:
+        """Stop the server."""
+        print("Stopping the server...")
+        self._background_app.stop()
+        self._server.close()
+        self._exited = True
+        print("Server stopped.")
+
+
+class DefaultServiceMethods:
+    """Default service methods for MechanicalEmbeddedServer."""
+
+    def __init__(self, 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.execute_script("""ExtAPI.DataModel.Project.ProjectDirectory""")
+
+    @remote_method
+    def list_files(self):
+        """List all files in the project directory."""
+        list = []
+        mechdbPath = self._app.execute_script("""ExtAPI.DataModel.Project.FilePath""")
+        if mechdbPath != "":
+            list.append(mechdbPath)
+        rootDir = self._app.execute_script("""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__(service=MechanicalService, impl=DefaultServiceMethods, **kwargs)