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

ansys/mechanical/core/_version.py

@@ -40,6 +40,7 @@ except ModuleNotFoundError:  # pragma: no cover
 __version__ = importlib_metadata.version("ansys-mechanical-core")
 
 SUPPORTED_MECHANICAL_VERSIONS = {
+    251: "2025R1",
     242: "2024R2",
     241: "2024R1",
     232: "2023R2",

ansys/mechanical/core/embedding/app.py

@@ -134,8 +134,7 @@ class App:
     Create App with Mechanical project file and version:
 
     >>> from ansys.mechanical.core import App
-    >>> app = App(db_file="path/to/file.mechdat", version=241, pri)
-
+    >>> app = App(db_file="path/to/file.mechdat", version=251)
 
     Disable copying the user profile when private appdata is enabled
 
@@ -182,8 +181,8 @@ class App:
             profile.update_environment(os.environ)
             atexit.register(_cleanup_private_appdata, profile)
 
-        self._app = _start_application(configuration, self._version, db_file)
         runtime.initialize(self._version)
+        self._app = _start_application(configuration, self._version, db_file)
         connect_warnings(self)
         self._poster = None
 

ansys/mechanical/core/embedding/background.py

@@ -76,12 +76,21 @@ class BackgroundApp:
         """
         return BackgroundApp.__app
 
-    def post(self, callable: typing.Callable):
-        """Post callable method to the background app thread."""
+    def _post(self, callable: typing.Callable, try_post: bool = False):
         if BackgroundApp.__stopped:
             raise RuntimeError("Cannot use BackgroundApp after stopping it.")
+        if try_post:
+            return BackgroundApp.__poster.try_post(callable)
         return BackgroundApp.__poster.post(callable)
 
+    def post(self, callable: typing.Callable):
+        """Post callable method to the background app thread."""
+        return self._post(callable)
+
+    def try_post(self, callable: typing.Callable):
+        """Try post callable method to the background app thread."""
+        return self._post(callable, try_post=True)
+
     def stop(self) -> None:
         """Stop the background app thread."""
         if BackgroundApp.__stopped:

ansys/mechanical/core/embedding/enum_importer.py

@@ -33,5 +33,5 @@ clr.AddReference("Ansys.ACT.Interfaces")
 
 from Ansys.ACT.Interfaces.Common import *  # noqa isort: skip
 from Ansys.Mechanical.DataModel.Enums import *  # noqa isort: skip
-
+from Ansys.ACT.Interfaces.Analysis import *  # noqa isort: skip
 import Ansys  # noqa  isort: skip

ansys/mechanical/core/embedding/imports.py

@@ -55,6 +55,7 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     # When ansys-pythonnet issue #14 is fixed, uncomment above
     from Ansys.ACT.Core.Math import Point2D, Point3D
     from Ansys.ACT.Math import Vector3D
+    from Ansys.ACT.Mechanical.Fields import VariableDefinitionType
     from Ansys.Core.Units import Quantity
     from Ansys.Mechanical.DataModel import MechanicalEnums
     from Ansys.Mechanical.Graphics import Point, SectionPlane
@@ -74,6 +75,7 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     vars["Point2D"] = Point2D
     vars["Point3D"] = Point3D
     vars["Vector3D"] = Vector3D
+    vars["VariableDefinitionType"] = VariableDefinitionType
 
     if enums:
         vars.update(get_all_enums())

ansys/mechanical/core/embedding/initializer.py

@@ -34,7 +34,12 @@ from ansys.mechanical.core.embedding.resolver import resolve
 INITIALIZED_VERSION = None
 """Constant for the initialized version."""
 
-SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS = {242: "2024R2", 241: "2024R1", 232: "2023R2"}
+SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS = {
+    251: "2025R1",
+    242: "2024R2",
+    241: "2024R1",
+    232: "2023R2",
+}
 """Supported Mechanical embedding versions on Windows."""
 
 

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

@@ -37,7 +37,7 @@ Configuring the logger can be done using the :class:`Configuration <ansys.mechan
   from ansys.mechanical.core.embedding.logger import Configuration, Logger
 
   Configuration.configure(level=logging.INFO, to_stdout=True, base_directory=None)
-  app = mech.App(version=242)
+  app = mech.App(version=251)
 
 Then, the :class:`Logger <ansys.mechanical.core.embedding.logger.Logger>` class can be used to write messages to the log:
 

ansys/mechanical/core/embedding/poster.py

@@ -25,6 +25,19 @@
 import typing
 
 
+class PosterError(Exception):
+    """Class which holds errors from the background thread posting system."""
+
+    def __init__(self, error: Exception):
+        """Create an instance to hold the given error."""
+        self._error = error
+
+    @property
+    def error(self) -> Exception:
+        """Get the underlying exception."""
+        return self._error
+
+
 class Poster:
     """Class which can post a python callable function to Mechanical's main thread."""
 
@@ -37,7 +50,26 @@ class Poster:
 
         self._poster = Ans.Common.WB1ManagedUtils.TaskPoster
 
-    def post(self, callable: typing.Callable):
+    def try_post(self, callable: typing.Callable) -> typing.Any:
+        """Post the callable to Mechanical's main thread.
+
+        This does the same thing as `post` but if `callable`
+        raises an exception, try_post will raise the same
+        exception to the caller of `try_post`.
+        """
+
+        def wrapped():
+            try:
+                return callable()
+            except Exception as e:
+                return PosterError(e)
+
+        result = self.post(wrapped)
+        if isinstance(result, PosterError):
+            raise result.error
+        return result
+
+    def post(self, callable: typing.Callable) -> typing.Any:
         """Post the callable to Mechanical's main thread.
 
         The main thread needs to be receiving posted messages

ansys/mechanical/core/embedding/resolver.py

@@ -23,8 +23,8 @@
 """This is the .NET assembly resolving for embedding Ansys Mechanical.
 
 Note that for some Mechanical Addons - additional resolving may be
-necessary. A resolve handler is shipped with Ansys Mechanical on windows
-starting in version 23.1 and on linux starting in version 23.2
+necessary. A resolve handler is shipped with Ansys Mechanical on Windows
+starting in version 23.1 and on Linux starting in version 23.2
 """
 
 
@@ -36,6 +36,13 @@ def resolve(version):
     clr.AddReference("Ansys.Mechanical.Embedding")
     import Ansys  # isort: skip
 
-    assembly_resolver = Ansys.Mechanical.Embedding.AssemblyResolver
-    resolve_handler = assembly_resolver.MechanicalResolveEventHandler
-    System.AppDomain.CurrentDomain.AssemblyResolve += resolve_handler
+    try:
+        assembly_resolver = Ansys.Mechanical.Embedding.AssemblyResolver
+        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:
+    1. Mechanical is installed.
+    2. A folder with the name "Ansys" does not exist in the same directory as the script being run.
+    """
+        raise AttributeError(error_msg)

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

@@ -0,0 +1,36 @@
+# 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.
+
+"""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 .server import (
+    DefaultServiceMethods,
+    MechanicalDefaultServer,
+    MechanicalEmbeddedServer,
+    MechanicalService,
+)
+from .utils import get_remote_methods, remote_method

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")