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

ansys/mechanical/core/embedding/app_libraries.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -50,12 +50,31 @@ can be imported with the `import` statement.
 
 import os
 import sys
+import warnings
 
-from ansys.tools.path.path import _get_unified_install_base_for_version
+from ansys.tools.path import get_mechanical_path
 
+from ansys.mechanical.core.embedding.app import App
 
-def add_mechanical_python_libraries(version: int):
+
+def add_mechanical_python_libraries(app_or_version):
     """Add the Mechanical libraries path to sys.path."""
-    install, _ = _get_unified_install_base_for_version(version)
-    location = os.path.join(install, "Addins", "ACT", "libraries", "Mechanical")
+    installdir = []
+    if isinstance(app_or_version, int):
+        warnings.warn(
+            "Passing version to add_mechanical_python_libraries() is deprecated."
+            "Please pass an instance of App() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        exe = get_mechanical_path(allow_input=False, version=app_or_version)
+        while os.path.basename(exe) != f"v{app_or_version}":
+            exe = os.path.dirname(exe)
+        installdir.append(exe)
+    elif isinstance(app_or_version, App):
+        installdir.append(os.environ[f"AWP_ROOT{app_or_version.version}"])
+    else:
+        raise ValueError("Invalid input: expected an integer (version) or an instance of App().")
+
+    location = os.path.join(installdir[0], "Addins", "ACT", "libraries", "Mechanical")
     sys.path.append(location)

ansys/mechanical/core/embedding/appdata.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -31,21 +31,33 @@ import warnings
 class UniqueUserProfile:
     """Create Unique User Profile (for AppData)."""
 
-    def __init__(self, profile_name):
+    def __init__(self, profile_name: str, copy_profile: bool = True, dry_run: bool = False):
         """Initialize UniqueUserProfile class."""
         self._default_profile = os.path.expanduser("~")
         self._location = os.path.join(self._default_profile, "PyMechanical-AppData", profile_name)
+        self._dry_run = dry_run
+        self.copy_profile = copy_profile
         self.initialize()
 
     def initialize(self) -> None:
-        """Initialize the new profile location."""
+        """
+        Initialize the new profile location.
+
+        Args:
+            copy_profile (bool): If False, the copy_profile method will be skipped.
+        """
+        if self._dry_run:
+            return
         if self.exists():
             self.cleanup()
         self.mkdirs()
-        self.copy_profiles()
+        if self.copy_profile:
+            self.copy_profiles()
 
     def cleanup(self) -> None:
         """Cleanup unique user profile."""
+        if self._dry_run:
+            return
         text = "The `private_appdata` option was used, but the following files were not removed: "
         message = []
 

ansys/mechanical/core/embedding/background.py

@@ -0,0 +1,106 @@
+# 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.
+
+"""Class for running Mechanical on a background thread."""
+
+import atexit
+import threading
+import time
+import typing
+
+import ansys.mechanical.core as mech
+from ansys.mechanical.core.embedding import initializer
+from ansys.mechanical.core.embedding.poster import Poster
+import ansys.mechanical.core.embedding.utils as utils
+
+
+def _exit(background_app: "BackgroundApp"):
+    """Stop the thread serving the Background App."""
+    background_app.stop()
+
+
+class BackgroundApp:
+    """Background App."""
+
+    __app: mech.App = None
+    __app_thread: threading.Thread = None
+    __stopped: bool = False
+    __stop_signaled: bool = False
+    __poster: Poster = None
+
+    def __init__(self, **kwargs):
+        """Construct an instance of BackgroundApp."""
+        if BackgroundApp.__app_thread is None:
+            initializer.initialize(kwargs.get("version"))
+            BackgroundApp.__app_thread = threading.Thread(
+                target=self._start_app, kwargs=kwargs, daemon=True
+            )
+            BackgroundApp.__app_thread.start()
+
+            while BackgroundApp.__poster is None:
+                time.sleep(0.05)
+                continue
+        else:
+            if BackgroundApp.__stopped:
+                raise RuntimeError("Cannot initialize a BackgroundApp once it has been stopped!")
+
+            def new():
+                BackgroundApp.__app.new()
+
+            self.post(new)
+
+    @property
+    def app(self) -> mech.App:
+        """Get the App instance of the background thread.
+
+        It is not meant to be used aside from passing to methods using `post`.
+        """
+        return BackgroundApp.__app
+
+    def post(self, callable: typing.Callable):
+        """Post callable method to the background app thread."""
+        if BackgroundApp.__stopped:
+            raise RuntimeError("Cannot use BackgroundApp after stopping it.")
+        return BackgroundApp.__poster.post(callable)
+
+    def stop(self) -> None:
+        """Stop the background app thread."""
+        if BackgroundApp.__stopped:
+            return
+        BackgroundApp.__stop_signaled = True
+        while True:
+            time.sleep(0.05)
+            if BackgroundApp.__stopped:
+                break
+
+    def _start_app(self, **kwargs) -> None:
+        BackgroundApp.__app = mech.App(**kwargs)
+        BackgroundApp.__poster = BackgroundApp.__app.poster
+        atexit.register(_exit, self)
+        while True:
+            if BackgroundApp.__stop_signaled:
+                break
+            try:
+                utils.sleep(40)
+            except:
+                raise Exception("BackgroundApp cannot sleep.")  # pragma: no cover
+        BackgroundApp.__stopped = True

ansys/mechanical/core/embedding/cleanup_gui.py

@@ -0,0 +1,61 @@
+# 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.
+"""Clean up temporary mechdb files after GUI is closed."""
+
+from pathlib import Path
+import shutil
+import sys
+import time
+
+import psutil
+
+
+def cleanup_gui(pid, temp_mechdb) -> None:
+    """Remove the temporary mechdb file after it is closed.
+
+    Parameters
+    ----------
+    pid: int
+        The process ID of the open temporary mechdb file.
+    temp_mechdb: Path
+        The path of the temporary mechdb file.
+    """
+    # While the pid exists, sleep
+    while psutil.pid_exists(pid):
+        time.sleep(1)
+
+    # Delete the temporary mechdb file once the GUI is closed
+    temp_mechdb.unlink()
+
+    # Delete the temporary mechdb Mech_Files folder
+    temp_folder_path = temp_mechdb.parent / f"{temp_mechdb.name.split('.')[0]}_Mech_Files"
+    shutil.rmtree(temp_folder_path)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    """Get the process ID and temporary file path to monitor and delete files after use."""
+    # Convert the process id (pid) argument into an integer
+    pid = int(sys.argv[1])
+    # Convert the temporary mechdb path into a Path
+    temp_mechdb_path = Path(sys.argv[2])
+    # Remove the temporary mechdb file when the GUI is closed
+    cleanup_gui(pid, temp_mechdb_path)

ansys/mechanical/core/embedding/enum_importer.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -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

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -24,20 +24,28 @@
 import typing
 
 
+def global_entry_points(app: "ansys.mechanical.core.App") -> typing.Dict:
+    """Return the global entry points of the application."""
+    vars = {}
+    vars["ExtAPI"] = app.ExtAPI
+    vars["DataModel"] = app.DataModel
+    vars["Model"] = app.DataModel.Project.Model
+    vars["Tree"] = app.DataModel.Tree
+    vars["Graphics"] = app.ExtAPI.Graphics
+    return vars
+
+
 def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> typing.Dict:
     """Return the Mechanical scripting global variables as a dict.
 
     It can be used to add all of these as global variables in python
     with this command:
-        `globals().update(global_variables(embedded_app))`
+
+    ``globals().update(global_variables(embedded_app))``
 
     To also import all the enums, set the parameter enums to true.
     """
-    vars = {}
-    vars["ExtAPI"] = app.ExtAPI
-    vars["DataModel"] = app.DataModel
-    vars["Model"] = app.DataModel.Project.Model
-    vars["Tree"] = app.DataModel.Tree
+    vars = global_entry_points(app)
     import clr  # isort: skip
 
     clr.AddReference("System.Collections")
@@ -45,8 +53,12 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     clr.AddReference("Ansys.Mechanical.DataModel")
     # from Ansys.ACT.Mechanical import Transaction
     # 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
 
     import System  # isort: skip
     import Ansys  # isort: skip
@@ -56,6 +68,14 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     vars["Ansys"] = Ansys
     vars["Transaction"] = Transaction
     vars["MechanicalEnums"] = MechanicalEnums
+    # Graphics
+    vars["Point"] = Point
+    vars["SectionPlane"] = SectionPlane
+    # Math
+    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

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -28,13 +28,19 @@ import platform
 import sys
 import warnings
 
-import ansys.tools.path as atp
-
 from ansys.mechanical.core.embedding.loader import load_clr
 from ansys.mechanical.core.embedding.resolver import resolve
 
 INITIALIZED_VERSION = None
-SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS_WINDOWS = {241: "2024R1", 232: "2023R2", 231: "2023R1"}
+"""Constant for the initialized version."""
+
+SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS = {
+    251: "2025R1",
+    242: "2024R2",
+    241: "2024R1",
+    232: "2023R2",
+}
+"""Supported Mechanical embedding versions on Windows."""
 
 
 def __add_sys_path(version: int) -> str:
@@ -44,15 +50,6 @@ def __add_sys_path(version: int) -> str:
     sys.path.append(str(bin_path.resolve()))
 
 
-def __disable_sec() -> None:
-    """SEC is part of RSM and is unstable with embedding.
-
-    I'm not going to debug why that is since we are planning to support
-    DCS/REP in the future instead of RSM.
-    """
-    os.environ["ANSYS_MECHANICAL_EMBEDDING_NO_SEC"] = "1"
-
-
 def __workaround_material_server(version: int) -> None:
     """Workaround material server bug in 2024 R1.
 
@@ -61,53 +58,72 @@ def __workaround_material_server(version: int) -> None:
     starts by default on a background thread, which may lead to
     a race condition on shutdown.
     """
-    # TODO - remove 242 when that is fixed
-    if version in [241, 242]:
+    if version in [241]:
         os.environ["ENGRDATA_SERVER_SERIAL"] = "1"
 
 
-def _get_default_linux_version() -> int:
-    """Try to get the active linux version from the environment.
+def __check_for_supported_version(version) -> None:
+    """Check if Mechanical version is supported with current version of PyMechanical.
 
-    On linux, embedding is only possible by setting environment variables before starting python.
-    The version will then be fixed  to a specific version, based on those env vars.
-    The documented way to set those variables is to run python using the ``mechanical-env`` script,
-    which can be used after installing the ``ansys-mechanical-env`` package with this command:
-    ``pip install ansys-mechanical-env``. The script takes user input of a version. If the user
-    does not provide a version, the ``find_mechanical()`` function from the ``ansys-tools-path``
-    package is used to find a version of Mechanical.
+    If specific environment variable is enabled, then users can overwrite the supported versions.
+    However, using unsupported versions may cause issues.
     """
-    supported_versions = [232, 241]
-    awp_roots = {ver: os.environ.get(f"AWP_ROOT{ver}", "") for ver in supported_versions}
-    installed_versions = {
-        ver: path for ver, path in awp_roots.items() if path and os.path.isdir(path)
-    }
-    assert len(installed_versions) == 1, "multiple AWP_ROOT environment variables found!"
-    return next(iter(installed_versions))
+    allow_old_version = os.getenv("ANSYS_MECHANICAL_EMBEDDING_SUPPORT_OLD_VERSIONS") == "1"
+
+    # Check if the version is supported
+    if not allow_old_version and version < min(SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS):
+        raise ValueError(f"Mechanical version {version} is not supported.")
+
+    return version
+
 
+def _get_latest_default_version() -> int:
+    """Try to get the latest Mechanical version from the environment.
 
-def _get_default_version() -> int:
-    if os.name == "posix":
-        return _get_default_linux_version()
+    Checks if multiple versions of Mechanical found in system.
+    For Linux it will be only one since ``mechanical-env`` takes care of that.
+    If multiple versions are detected, select the latest one, as no specific version is provided.
+    """
+    awp_roots = [value for key, value in os.environ.items() if key.startswith("AWP_ROOT")]
 
-    if os.name != "nt":  # pragma: no cover
-        raise Exception("Unexpected platform!")
+    if not awp_roots:
+        raise Exception("No Mechanical installations found.")
 
-    _, version = atp.find_mechanical(
-        supported_versions=SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS_WINDOWS
-    )
+    versions_found = []
+    for path in awp_roots:
+        folder = os.path.basename(os.path.normpath(path))
+        version = folder.split("v")[-1]
+        versions_found.append(int(version))
+    latest_version = max(versions_found)
 
-    # version is of the form 23.2
-    int_version = int(str(version).replace(".", ""))
-    return int_version
+    if len(awp_roots) > 1:
+        warnings.warn(
+            f"Multiple versions of Mechanical found! Using latest version {latest_version} ..."
+        )
 
+    return latest_version
 
-def __check_python_interpreter_architecture():
+
+def __check_python_interpreter_architecture() -> None:
     """Embedding support only 64 bit architecture."""
     if platform.architecture()[0] != "64bit":
         raise Exception("Mechanical Embedding requires a 64-bit Python environment.")
 
 
+def __set_environment(version: int) -> None:
+    """Set environment variables to configure embedding."""
+    if os.name == "nt":  # pragma: no cover
+        if version < 251:
+            os.environ["MECHANICAL_STARTUP_UNOPTIMIZED"] = "1"
+
+    # Set an environment variable to use the custom CLR host
+    # for embedding.
+    # In the future (>251), it would always be used.
+    if version == 251:
+        if "PYMECHANICAL_NO_CLR_HOST_LITE" not in os.environ:
+            os.environ["ANSYS_MECHANICAL_EMBEDDING_CLR_HOST"] = "1"
+
+
 def __check_for_mechanical_env():
     """Embedding in linux platform must use mechanical-env."""
     if platform.system() == "Linux" and os.environ.get("PYMECHANICAL_EMBEDDING") != "TRUE":
@@ -120,22 +136,57 @@ def __check_for_mechanical_env():
         )
 
 
+def __is_lib_loaded(libname: str):  # pragma: no cover
+    """Return whether a library is loaded."""
+    import ctypes
+
+    RTLD_NOLOAD = 4
+    try:
+        ctypes.CDLL(libname, RTLD_NOLOAD)
+    except OSError:
+        return False
+    return True
+
+
+def __check_loaded_libs(version: int = None):  # pragma: no cover
+    """Ensure that incompatible libraries aren't loaded prior to PyMechanical load."""
+    if platform.system() != "Linux":
+        return
+
+    if version < 251:
+        return
+
+    # For 2025 R1, PyMechanical will crash on shutdown if libX11.so is already loaded
+    # before starting Mechanical
+    if __is_lib_loaded("libX11.so"):
+        warnings.warn(
+            "libX11.so is loaded prior to initializing the Embedded Instance of Mechanical.\
+                      Python will crash on shutdown..."
+        )
+
+
 def initialize(version: int = None):
     """Initialize Mechanical embedding."""
-    __check_python_interpreter_architecture()  # blocks 32 bit python
-    __check_for_mechanical_env()  # checks for mechanical-env in linux embedding
-
     global INITIALIZED_VERSION
-    if INITIALIZED_VERSION != None:
-        assert INITIALIZED_VERSION == version
-        return
+    if version is None:
+        version = _get_latest_default_version()
 
-    if version == None:
-        version = _get_default_version()
+    version = __check_for_supported_version(version=version)
 
-    INITIALIZED_VERSION = version
+    if INITIALIZED_VERSION is not None:
+        if INITIALIZED_VERSION != version:
+            raise ValueError(
+                f"Initialized version {INITIALIZED_VERSION} "
+                f"does not match the expected version {version}."
+            )
+        return INITIALIZED_VERSION
 
-    __disable_sec()
+    __check_python_interpreter_architecture()  # blocks 32 bit python
+    __check_for_mechanical_env()  # checks for mechanical-env in linux embedding
+
+    __set_environment(version)
+
+    __check_loaded_libs(version)
 
     __workaround_material_server(version)
 
@@ -164,4 +215,5 @@ def initialize(version: int = None):
     # attach the resolver
     resolve(version)
 
+    INITIALIZED_VERSION = version
     return version

ansys/mechanical/core/embedding/loader.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -22,25 +22,35 @@
 
 """clr_loader for pymechanical embedding. This loads the CLR on both windows and linux."""
 import os
+import warnings
 
 
 def __get_mono(assembly_dir, config_dir):
     import clr_loader
 
     libmono = os.path.join(assembly_dir, "libmonosgen-2.0.so")
-    mono = clr_loader.get_mono(
-        set_signal_chaining=True,
-        libmono=libmono,  # TODO: find_mono is broken on clr-loader v0.2.6
-        assembly_dir=assembly_dir,
-        config_dir=config_dir,
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        mono = clr_loader.get_mono(
+            set_signal_chaining=True,
+            libmono=libmono,  # TODO: find_mono is broken on clr-loader v0.2.6
+            assembly_dir=assembly_dir,
+            config_dir=config_dir,
+        )
     return mono
 
 
-def load_clr_mono(install_loc):
+def _set_mono_trace():  # pragma: no cover
+    if "ANS_MONO_TRACE" in os.environ:
+        os.environ["MONO_LOG_LEVEL"] = "message"
+        os.environ["MONO_LOG_MASK"] = "all"
+
+
+def _load_mono(install_loc):
     """Load the clr using mono that is shipped with the unified install."""
     from pythonnet import load
 
+    _set_mono_trace()
     mono_dir = os.path.join(install_loc, "Tools", "mono", "Linux64")
     assembly_dir = os.path.join(mono_dir, "lib")
     config_dir = os.path.join(mono_dir, "etc")
@@ -52,4 +62,4 @@ def load_clr(install_loc: str) -> None:
     """Load the clr, the outcome of this function is that `clr` is usable."""
     if os.name == "nt":  # pragma: no cover
         return
-    load_clr_mono(install_loc)
+    _load_mono(install_loc)