ansys-mechanical-core 0.11.14__py3-none-any.whl → 0.11.16__py3-none-any.whl

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

@@ -21,7 +21,6 @@
 # SOFTWARE.
 """Remote Procedure Call (RPC) server."""
 
-import fnmatch
 import os
 import threading
 import time
@@ -31,26 +30,63 @@ 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."""
@@ -62,8 +98,16 @@ class MechanicalService(rpyc.Service):
 
     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."""
         if impl is None:
@@ -84,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
 
@@ -97,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
 
@@ -108,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
 
@@ -209,9 +253,7 @@ class MechanicalService(rpyc.Service):
     def exposed_service_exit(self):
         """Exit the server."""
         print("Shutting down server ...")
-        self._backgroundapp.stop()
-        self._backgroundapp = None
-        self._server.stop_async()
+        self._exit_f()
         print("Server stopped")
 
 
@@ -220,184 +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
-        self._exit_thread: threading.Thread = None
-
-        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)
-        my_service._server = self
+    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 _wait_exit(self) -> None:
-        if self._exit_thread is None:
-            return
-        self._exit_thread.join()
+    def _stop_background_app(self):
+        """Return immediately but will stop the server.
 
-    def stop_async(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.
+        """
 
         def stop_f():  # wait for all connections to close
             while len(self._server.clients) > 0:
                 time.sleep(0.005)
-            self._background_app.stop()
+            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 stop(self) -> None:
-        """Stop the server."""
-        print("Stopping the server...")
-        self._background_app.stop()
-        self._server.close()
-        self._exited = True
-        print("Server stopped.")
+    def _start_foreground_app(self):
+        self._server_stopped = False
 
+        def start_f():
+            print("Server started!")
+            self._server.start()
+            print("Server exited!")
 
-class DefaultServiceMethods:
-    """Default service methods for MechanicalEmbeddedServer."""
+        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
-
-
-class MechanicalDefaultServer(MechanicalEmbeddedServer):
-    """Default server with default service methods."""
+            self._start_foreground_app()
 
-    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."""
@@ -116,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/ide_config.py

@@ -93,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:

ansys/mechanical/core/mechanical.py

@@ -34,6 +34,7 @@ import subprocess  # nosec: B404
 import sys
 import threading
 import time
+import typing
 from typing import Optional
 import warnings
 import weakref
@@ -460,10 +461,11 @@ class Mechanical(object):
         else:
             self.log_info("Mechanical connection is treated as remote.")
 
+        self._error_type = grpc.RpcError
+
         # connect and validate to the channel
         self._multi_connect(timeout=timeout)
         self.log_info("Mechanical is ready to accept grpc calls.")
-        self._rpc_type = "grpc"
 
     def __del__(self):  # pragma: no cover
         """Clean up on exit."""
@@ -482,6 +484,11 @@ class Mechanical(object):
         """Log associated with the current Mechanical instance."""
         return self._log
 
+    @property
+    def backend(self) -> str:
+        """Return the backend type."""
+        return "mechanical"
+
     @property
     def version(self) -> str:
         """Get the Mechanical version based on the instance.
@@ -1204,9 +1211,9 @@ class Mechanical(object):
         if progress_bar:
             if not _HAS_TQDM:  # pragma: no cover
                 raise ModuleNotFoundError(
-                    f"To use the keyword argument 'progress_bar', you must have "
-                    f"installed the 'tqdm' package. To avoid this message, you can "
-                    f"set 'progress_bar=False'."
+                    "To use the keyword argument 'progress_bar', you must have "
+                    "installed the 'tqdm' package. To avoid this message, you can "
+                    "set 'progress_bar=False'."
                 )
 
             n_bytes = os.path.getsize(file_name)
@@ -1951,11 +1958,12 @@ def launch_rpyc(
     additional_switches=None,
     additional_envs=None,
     verbose=False,
-) -> int:
+) -> typing.Tuple[int, subprocess.Popen]:
     """Start Mechanical locally in RPyC mode."""
     _version = atp.version_from_path("mechanical", exec_file)
-    if _version < 232:
-        raise VersionError("The Mechanical gRPC interface requires Mechanical 2023 R2 or later.")
+
+    if not batch:
+        raise Exception("The rpyc backend does not support graphical mode!")
 
     # get the next available port
     local_ports = pymechanical.LOCAL_PORTS
@@ -1969,21 +1977,21 @@ def launch_rpyc(
         port += 1
     local_ports.append(port)
 
+    # TODO - use multiprocessing
     server_script = """
 import sys
 from ansys.mechanical.core.embedding.rpc import MechanicalDefaultServer
 server = MechanicalDefaultServer(port=int(sys.argv[1]), version=int(sys.argv[2]))
 server.start()
 """
-    env_copy = os.environ.copy()
     try:
         embedded_server = subprocess.Popen(
-            [sys.executable, "-c", server_script, str(port), str(_version)], env=env_copy
+            [sys.executable, "-c", server_script, str(port), str(_version)]
         )  # nosec: B603
     except:
         raise RuntimeError("Unable to start the embedded server.")
 
-    return port
+    return port, embedded_server
 
 
 def launch_remote_mechanical(
@@ -2306,11 +2314,15 @@ def launch_mechanical(
             # pass
             raise exception
     elif backend == "python":
-        port = launch_rpyc(port=port, **start_parm)
+        port, process = launch_rpyc(port=port, **start_parm)
         from ansys.mechanical.core.embedding.rpc.client import Client
 
         mechanical = Client(
-            "localhost", port, timeout=start_timeout, cleanup_on_exit=cleanup_on_exit
+            "localhost",
+            port,
+            timeout=start_timeout,
+            cleanup_on_exit=cleanup_on_exit,
+            process=process,
         )
 
     return mechanical

{ansys_mechanical_core-0.11.14.dist-info → ansys_mechanical_core-0.11.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansys-mechanical-core
-Version: 0.11.14
+Version: 0.11.16
 Summary: A python wrapper for Ansys Mechanical
 Keywords: pymechanical,mechanical,ansys,pyansys
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
@@ -18,7 +18,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 License-File: LICENSE
 Requires-Dist: ansys-api-mechanical==0.1.2
-Requires-Dist: ansys-mechanical-env==0.1.9
+Requires-Dist: ansys-mechanical-env==0.1.12
 Requires-Dist: ansys-mechanical-stubs==0.1.6
 Requires-Dist: ansys-pythonnet>=3.1.0rc6
 Requires-Dist: ansys-tools-path>=0.3.1
@@ -30,19 +30,19 @@ Requires-Dist: protobuf>=3.12.2,<6
 Requires-Dist: psutil>=6
 Requires-Dist: tqdm>=4.45.0
 Requires-Dist: requests>=2,<3
-Requires-Dist: sphinx==8.2.1 ; extra == "doc"
-Requires-Dist: ansys-sphinx-theme[autoapi, changelog]==1.3.2 ; extra == "doc"
+Requires-Dist: sphinx==8.2.3 ; extra == "doc"
+Requires-Dist: ansys-sphinx-theme[autoapi, changelog]==1.4.2 ; extra == "doc"
 Requires-Dist: grpcio==1.70.0 ; extra == "doc"
 Requires-Dist: imageio-ffmpeg==0.6.0 ; extra == "doc"
 Requires-Dist: imageio==2.37.0 ; extra == "doc"
 Requires-Dist: jupyter_sphinx==0.5.3 ; extra == "doc"
 Requires-Dist: jupyterlab>=3.2.8 ; extra == "doc"
-Requires-Dist: matplotlib==3.10.0 ; extra == "doc"
-Requires-Dist: numpy==2.2.3 ; extra == "doc"
+Requires-Dist: matplotlib==3.10.1 ; extra == "doc"
+Requires-Dist: numpy==2.2.5 ; extra == "doc"
 Requires-Dist: numpydoc==1.8.0 ; extra == "doc"
 Requires-Dist: pandas==2.2.3 ; extra == "doc"
 Requires-Dist: panel==1.6.1 ; extra == "doc"
-Requires-Dist: plotly==6.0.0 ; extra == "doc"
+Requires-Dist: plotly==6.0.1 ; extra == "doc"
 Requires-Dist: pypandoc==1.15 ; extra == "doc"
 Requires-Dist: pytest-sphinx==0.6.3 ; extra == "doc"
 Requires-Dist: pythreejs==2.4.2 ; extra == "doc"
@@ -55,21 +55,24 @@ Requires-Dist: sphinx-gallery==0.19.0 ; extra == "doc"
 Requires-Dist: sphinx-notfound-page==1.1.0 ; extra == "doc"
 Requires-Dist: sphinxcontrib-websupport==2.0.0 ; extra == "doc"
 Requires-Dist: sphinxemoji==0.3.1 ; extra == "doc"
+Requires-Dist: ansys-tools-visualization-interface>=0.2.6 ; extra == "graphics"
+Requires-Dist: usd-core==25.5 ; extra == "graphics"
 Requires-Dist: ansys-platform-instancemanagement>=1.0.1 ; extra == "pim"
-Requires-Dist: rpyc==6.0.1 ; extra == "rpc"
+Requires-Dist: rpyc==6.0.2 ; extra == "rpc"
 Requires-Dist: toolz==1.0.0 ; extra == "rpc"
-Requires-Dist: pytest==8.3.4 ; extra == "tests"
-Requires-Dist: pytest-cov==6.0.0 ; extra == "tests"
-Requires-Dist: pytest-print==1.0.2 ; extra == "tests"
+Requires-Dist: pytest==8.3.5 ; extra == "tests"
+Requires-Dist: pytest-cov==6.1.1 ; extra == "tests"
+Requires-Dist: pytest-print==1.1.0 ; extra == "tests"
 Requires-Dist: psutil==7.0.0 ; extra == "tests"
 Requires-Dist: ansys-tools-visualization-interface>=0.2.6 ; extra == "viz"
-Requires-Dist: usd-core==24.11 ; extra == "viz"
+Requires-Dist: usd-core==25.5 ; extra == "viz"
 Project-URL: Changelog, https://mechanical.docs.pyansys.com/version/stable/changelog.html
 Project-URL: Documentation, https://mechanical.docs.pyansys.com
 Project-URL: Homepage, https://github.com/ansys/pymechanical
 Project-URL: Issues, https://github.com/ansys/pymechanical/issues
 Project-URL: Repository, https://github.com/ansys/pymechanical
 Provides-Extra: doc
+Provides-Extra: graphics
 Provides-Extra: pim
 Provides-Extra: rpc
 Provides-Extra: tests