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

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

@@ -21,61 +21,103 @@
 # SOFTWARE.
 """Remote Procedure Call (RPC) server."""
 
-import fnmatch
 import os
+import threading
+import time
 import typing
 
 import rpyc
 from rpyc.utils.server import ThreadedServer
 import toolz
 
+from ansys.mechanical.core.embedding.app import App
 from ansys.mechanical.core.embedding.background import BackgroundApp
-from ansys.mechanical.core.mechanical import port_in_use
+import ansys.mechanical.core.embedding.utils
 
-from .utils import MethodType, get_remote_methods, remote_method
+from .utils import MethodType, get_free_port, get_remote_methods
 
 # TODO : implement logging
 
-PYMECHANICAL_DEFAULT_RPC_PORT = 20000
+
+class ForegroundAppBackend:
+    """Backend for the python server where mechanical uses the main thread."""
+
+    def __init__(self, app: App):
+        """Create a new instance of ForegroundAppBackend."""
+        self._app = app
+        self._poster = app.poster
+
+    def try_post(self, callable: typing.Callable) -> typing.Any:
+        """Try to post to mechanical's main thread."""
+        return self._poster.try_post(callable)
+
+    def get_app(self) -> App:
+        """Get the app object."""
+        return self._app
+
+
+class BackgroundAppBackend:
+    """Backend for the python server where mechanical uses the background thread."""
+
+    def __init__(self, backgroundapp: BackgroundApp):
+        """Create a new instance of BackgroundAppBackend."""
+        self._backgroundapp = backgroundapp
+
+    def try_post(self, callable: typing.Callable) -> typing.Any:
+        """Try to post to mechanical's main thread."""
+        return self._backgroundapp.try_post(callable)
+
+    def get_app(self) -> App:
+        """Get the app object."""
+        return self._backgroundapp.app
 
 
 class MechanicalService(rpyc.Service):
     """Starts Mechanical app services."""
 
-    def __init__(self, backgroundapp, functions=[], impl=None):
+    def __init__(self, backend, functions=[], impl=[]):
         """Initialize the service."""
         super().__init__()
-        self._backgroundapp = backgroundapp
+        self._backend = backend
         self._install_functions(functions)
-        self._install_class(impl)
-        self.EMBEDDED = True
+        self._install_classes(impl)
+
+    def _try_post(self, callable: typing.Callable) -> typing.Any:
+        return self._backend.try_post(callable)
+
+    def _get_app(self) -> App:
+        return self._backend.get_app()
+
+    def on_connect(self, conn):
+        """Handle client connection."""
+        print("Client connected")
+
+    def on_disconnect(self, conn):
+        """Handle client disconnection."""
+        print("Client disconnected")
 
     def _install_functions(self, methods):
         """Install the given list of methods."""
+        if not methods:
+            return
         [self._install_function(method) for method in methods]
 
+    def _install_classes(self, impl):
+        """Install the given list of classes."""
+        if not impl:
+            return
+        [self._install_class(_impl) for _impl in impl]
+
     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."""
 
@@ -86,7 +128,7 @@ class MechanicalService(rpyc.Service):
                 else:
                     setattr(prop._owner, propname, *arg)
 
-            return self._backgroundapp.try_post(curried)
+            return self._try_post(curried)
 
         return posted
 
@@ -99,7 +141,7 @@ class MechanicalService(rpyc.Service):
                 result = original_method(*args, **kwargs)
                 return result
 
-            return self._backgroundapp.try_post(curried)
+            return self._try_post(curried)
 
         return posted
 
@@ -110,9 +152,9 @@ class MechanicalService(rpyc.Service):
 
         def posted(*args, **kwargs):
             def curried():
-                return curried_method(self._app, *args, **kwargs)
+                return curried_method(self._get_app(), *args, **kwargs)
 
-            return self._backgroundapp.try_post(curried)
+            return self._try_post(curried)
 
         return posted
 
@@ -157,7 +199,6 @@ class MechanicalService(rpyc.Service):
 
     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__}"
 
@@ -211,8 +252,9 @@ class MechanicalService(rpyc.Service):
 
     def exposed_service_exit(self):
         """Exit the server."""
-        self._backgroundapp.stop()
-        self._backgroundapp = None
+        print("Shutting down server ...")
+        self._exit_f()
+        print("Server stopped")
 
 
 class MechanicalEmbeddedServer:
@@ -220,163 +262,130 @@ class MechanicalEmbeddedServer:
 
     def __init__(
         self,
-        service: typing.Type[rpyc.Service] = MechanicalService,
         port: int = None,
         version: int = None,
         methods: typing.List[typing.Callable] = [],
-        impl=None,
+        impl: typing.List = [],
     ):
         """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
+        use_background_app = False
+        if use_background_app:
+            self._app_instance = BackgroundApp(version=version)
+            self._backend = BackgroundAppBackend(self._app_instance)
         else:
-            self._impl = impl(self._background_app.app)
+            self._app_instance = App(version=version)
+            self._backend = ForegroundAppBackend(self._app_instance)
+        self._port = get_free_port(port)
+        self._install_methods(methods)
+        self._install_classes(impl)
+        self._server = ThreadedServer(self._create_service(), port=self._port)
 
-        my_service = self._service(self._background_app, self._methods, self._impl)
-        self._server = ThreadedServer(my_service, port=self._port)
+    def _create_service(self):
+        service = MechanicalService(self._backend, self._methods, self._impl)
 
-    @staticmethod
-    def get_free_port(port=None):
-        """Get free port.
+        def exit_f():
+            self.stop()
 
-        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
+        service._exit_f = exit_f
+        return service
 
-        while port_in_use(port):
-            port += 1
+    def _is_stopped(self):
+        return self._app_instance is None
 
-        return port
+    def _wait_exit(self) -> None:
+        if self._exit_thread is None:
+            return
+        self._exit_thread.join()
 
-    def start(self) -> None:
+    def _start_background_app(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._exit_thread: threading.Thread = None
         self._server.start()
-        """try:
-            try:
-                conn.serve_all()
-            except KeyboardInterrupt:
-                print("User interrupt!")
-        finally:
-            conn.close()"""
+        print("Server exited!")
+        self._wait_exit()
         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.")
+    def _stop_background_app(self):
+        """Return immediately but will stop the server.
 
+        Mechanical is running on the background but
+        the rpyc server is running on the main thread
+        this signals for the server to stop, and the main
+        thread will wait until the server has stopped.
+        """
 
-class DefaultServiceMethods:
-    """Default service methods for MechanicalEmbeddedServer."""
+        def stop_f():  # wait for all connections to close
+            while len(self._server.clients) > 0:
+                time.sleep(0.005)
+            self._app_instance.stop()
+            self._app_instance = None
+            self._backend = None
+            self._server.close()
+            self._exited = True
+
+        self._exit_thread = threading.Thread(target=stop_f)
+        self._exit_thread.start()
+
+    def _start_foreground_app(self):
+        self._server_stopped = False
+
+        def start_f():
+            print("Server started!")
+            self._server.start()
+            print("Server exited!")
+
+        self._server_thread = threading.Thread(target=start_f)
+        self._server_thread.start()
+        while True:
+            if self._server_stopped:
+                break
+            try:
+                ansys.mechanical.core.embedding.utils.sleep(40)
+            except Exception as e:
+                print(f"An error occurred: {e}")
+        self._server_thread.join()
 
-    def __init__(self, app):
-        """Initialize the DefaultServiceMethods."""
-        self._app = app
+    def _stop_foreground_app(self):
+        self._server_stopped = True
+        self._server.close()
+        # self._server_thread.join()
 
-    def __repr__(self):
-        """Return the representation of the instance."""
-        return '"ServiceMethods instance"'
+    def _get_app_repr(self) -> str:
+        def f():
+            return repr(self._backend.get_app())
 
-    @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
+        return self._backend.try_post(f)
 
-    @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
+    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._get_app_repr()}"
+        )
+        if isinstance(self._app_instance, BackgroundApp):
+            self._start_background_app()
         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
-
+            self._start_foreground_app()
 
-class MechanicalDefaultServer(MechanicalEmbeddedServer):
-    """Default server with default service methods."""
-
-    def __init__(self, **kwargs):
-        """Initialize the MechanicalDefaultServer."""
-        super().__init__(service=MechanicalService, impl=DefaultServiceMethods, **kwargs)
+    def stop(self) -> None:
+        """Stop the server."""
+        if self._is_stopped():
+            raise Exception("already stopped!")
+        if isinstance(self._app_instance, BackgroundApp):
+            self._stop_background_app()
+        else:
+            self._stop_foreground_app()
+
+    def _install_classes(self, impl: typing.Union[typing.Any, typing.List]) -> None:
+        app = self._backend.get_app()
+        if impl and not isinstance(impl, list):
+            impl = [impl]
+        self._impl = [i(app) for i in impl] if impl else []
+
+    def _install_methods(
+        self, methods: typing.Union[typing.Callable, typing.List[typing.Callable]]
+    ) -> None:
+        if methods and not isinstance(methods, list):
+            methods = [methods]
+        self._methods = methods if methods is not None else []

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

@@ -22,6 +22,10 @@
 """Utilities necessary for remote calls."""
 import typing
 
+from ansys.mechanical.core.mechanical import port_in_use
+
+PYMECHANICAL_DEFAULT_RPC_PORT = 20000
+
 
 class remote_method:
     """Decorator for passing remote methods."""
@@ -102,12 +106,10 @@ def get_remote_methods(
         A tuple containing the method name and the method itself
         for each remote method found in the object
     """
-    print(f"Getting remote methods on {obj}")
     objclass = obj.__class__
     for attrname in dir(obj):
         if attrname.startswith("__"):
             continue
-        print(attrname)
         if hasattr(objclass, attrname):
             class_attribute = getattr(objclass, attrname)
             if isinstance(class_attribute, property):
@@ -118,3 +120,17 @@ def get_remote_methods(
         if result != None:
             attrname, method = result
             yield attrname, method, MethodType.METHOD
+
+
+def get_free_port(port: int = 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

ansys/mechanical/core/embedding/runtime.py

@@ -50,13 +50,17 @@ def _bind_assembly_for_explicit_interface(assembly_name: str):
     # if pythonnet is not installed, we can't bind the assembly
     try:
         distribution("pythonnet")
+        Logger.warning("Cannot bind for explicit interface because pythonnet is installed")
         return
     except ModuleNotFoundError:
         pass
 
+    Logger.debug(f"Binding assembly for explicit interface {assembly_name}")
     import clr
 
+    Logger.debug(f"Binding assembly for explicit interface, Loading {assembly_name}")
     assembly = clr.AddReference(assembly_name)
+    Logger.debug(f"Binding assembly for explicit interface, Loaded {assembly_name}")
     from Python.Runtime import BindingManager, BindingOptions
 
     binding_options = BindingOptions()
@@ -78,6 +82,8 @@ def initialize(version: int) -> None:
     if version >= 242 or os.name == "nt":
         # function codec is distributed with pymechanical on linux only
         # at version 242 or later
+        Logger.debug("Registering function codec")
         __register_function_codec()
+        Logger.debug("Registered function codec")
 
     _bind_assembly_for_explicit_interface("Ansys.ACT.WB1")

ansys/mechanical/core/embedding/transaction.py

@@ -0,0 +1,51 @@
+# 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.
+"""A class to speed up bulk user interactions using Ansys ACT Mechanical Transaction."""
+
+
+class Transaction:  # When ansys-pythonnet issue #14 is fixed, this class will be removed
+    """
+    A class to speed up bulk user interactions using Ansys ACT Mechanical Transaction.
+
+    Example
+    -------
+    >>> with Transaction() as transaction:
+    ...     pass   # Perform bulk user interactions here
+    ...
+    """
+
+    def __init__(self):
+        """Initialize the Transaction class."""
+        import clr
+
+        clr.AddReference("Ansys.ACT.WB1")
+        import Ansys
+
+        self._transaction = Ansys.ACT.Mechanical.Transaction()
+
+    def __enter__(self):
+        """Enter the context of the transaction."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context of the transaction and disposes of resources."""
+        self._transaction.Dispose()

ansys/mechanical/core/ide_config.py

@@ -28,6 +28,7 @@ from pathlib import Path
 import re
 import site
 import sys
+import warnings
 
 import ansys.tools.path as atp
 import click
@@ -92,6 +93,7 @@ def _vscode_impl(
         If unspecified, it finds the default Mechanical version from ansys-tools-path.
     """
     # Update the user or workspace settings
+    settings_json = "the settings.json file"
     if target == "user":
         # Get the path to the user's settings.json file depending on the platform
         if "win" in sys.platform:
@@ -151,13 +153,23 @@ def _cli_impl(
     stubs_location = get_stubs_location()
     # Get all revision numbers available in ansys-mechanical-stubs
     revns = get_stubs_versions(stubs_location)
-    # Check the IDE and raise an exception if it's not VS Code
-    if revision < min(revns) or revision > max(revns):
+
+    # Check if the user revision number is less or greater than the min and max revisions
+    # in the ansys-mechanical-stubs package location
+    if revision < min(revns):
         raise Exception(f"PyMechanical Stubs are not available for {revision}")
-    elif ide != "vscode":
+    elif revision > max(revns):
+        warnings.warn(
+            f"PyMechanical Stubs are not available for {revision}. Using {max(revns)} instead.",
+            stacklevel=2,
+        )
+        revision = max(revns)
+
+    # Check the IDE and raise an exception if it's not VS Code
+    if ide != "vscode":
         raise Exception(f"{ide} is not supported at the moment.")
-    else:
-        return _vscode_impl(target, revision)
+
+    return _vscode_impl(target, revision)
 
 
 @click.command()
@@ -202,8 +214,11 @@ def cli(ide: str, target: str, revision: int) -> None:
         $ ansys-mechanical-ideconfig --ide vscode --target user --revision 251
 
     """
-    exe = atp.get_mechanical_path(allow_input=False, version=revision)
-    version = atp.version_from_path("mechanical", exe)
+    if not revision:
+        exe = atp.get_mechanical_path(allow_input=False, version=revision)
+        version = atp.version_from_path("mechanical", exe)
+    else:
+        version = revision
 
     return _cli_impl(
         ide,