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

ansys/mechanical/core/__init__.py

@@ -46,7 +46,10 @@ LOG = Logger(level=logging.ERROR, to_file=False, to_stdout=True)
 
 
 from ansys.mechanical.core._version import __version__
+
+# import few classes / functions
 from ansys.mechanical.core.mechanical import (
+    Mechanical,
     change_default_mechanical_path,
     close_all_local_instances,
     connect_to_mechanical,
@@ -54,9 +57,6 @@ from ansys.mechanical.core.mechanical import (
     launch_mechanical,
 )
 
-# import few classes / functions
-from ansys.mechanical.core.mechanical import Mechanical as Mechanical
-
 try:
     from ansys.mechanical.core.embedding import App, global_variables
 

ansys/mechanical/core/embedding/app.py

@@ -47,10 +47,10 @@ if typing.TYPE_CHECKING:
 try:
     import ansys.tools.visualization_interface  # noqa: F401
 
-    HAS_ANSYS_VIZ = True
+    HAS_ANSYS_GRAPHICS = True
     """Whether or not PyVista exists."""
 except ImportError:
-    HAS_ANSYS_VIZ = False
+    HAS_ANSYS_GRAPHICS = False
 
 
 def _get_default_addin_configuration() -> AddinConfiguration:
@@ -186,10 +186,22 @@ class App:
 
         self.log_info("Starting Mechanical Application")
 
+        # Get the globals dictionary from kwargs
+        globals = kwargs.get("globals")
+
+        # If the building gallery flag is set, we need to share the instance
+        # This can apply to running the `make -C doc html` command
         if BUILDING_GALLERY:
             if len(INSTANCES) != 0:
+                # Get the first instance of the app
                 instance: App = INSTANCES[0]
+                # Point to the same underlying application object
                 instance._share(self)
+                # Update the globals if provided in kwargs
+                if globals:
+                    # The next line is covered by test_globals_kwarg_building_gallery
+                    instance.update_globals(globals)  # pragma: nocover
+                # Open the mechdb file if provided
                 if db_file is not None:
                     self.open(db_file)
                 return
@@ -212,7 +224,6 @@ class App:
             new_profile_name = f"PyMechanical-{os.getpid()}"
             profile = UniqueUserProfile(new_profile_name, copy_profile=copy_profile)
             profile.update_environment(os.environ)
-            atexit.register(_cleanup_private_appdata, profile)
 
         runtime.initialize(self._version)
         self._app = _start_application(configuration, self._version, db_file)
@@ -222,11 +233,14 @@ class App:
         self._disposed = False
         atexit.register(_dispose_embedded_app, INSTANCES)
         INSTANCES.append(self)
+
+        # Clean up the private appdata directory on exit if private_appdata is True
+        if private_appdata:
+            atexit.register(_cleanup_private_appdata, profile)
+
         self._updated_scopes: typing.List[typing.Dict[str, typing.Any]] = []
         self._subscribe()
         self._messages = None
-
-        globals = kwargs.get("globals")
         if globals:
             self.update_globals(globals)
 
@@ -391,27 +405,27 @@ This may corrupt the project file.",
 
     def plotter(self) -> None:
         """Return ``ansys.tools.visualization_interface.Plotter`` object."""
-        if not HAS_ANSYS_VIZ:
-            warnings.warn(
-                "Installation of viz option required! Use pip install ansys-mechanical-core[viz]"
+        if not HAS_ANSYS_GRAPHICS:
+            LOG.warning(
+                "Use ``pip install ansys-mechanical-core[graphics]`` to enable this option."
             )
             return
 
         if self.version < 242:
-            warnings.warn("Plotting is only supported with version 2024R2 and later!")
+            LOG.warning("Plotting is only supported with version 2024R2 and later!")
             return
 
         # TODO Check if anything loaded inside app or else show warning and return
 
-        from ansys.mechanical.core.embedding.viz.embedding_plotter import to_plotter
+        from ansys.mechanical.core.embedding.graphics.embedding_plotter import to_plotter
 
         return to_plotter(self)
 
     def plot(self) -> None:
         """Visualize the model in 3d.
 
-        Requires installation using the viz option. E.g.
-        pip install ansys-mechanical-core[viz]
+        Requires installation using the graphics option. E.g.
+        pip install ansys-mechanical-core[graphics]
 
         Examples
         --------

ansys/mechanical/core/embedding/appdata.py

@@ -22,7 +22,7 @@
 
 """Temporary Appdata for Ansys Mechanical."""
 
-import os
+from pathlib import Path
 import shutil
 import sys
 import warnings
@@ -33,8 +33,8 @@ class UniqueUserProfile:
 
     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._default_profile = Path("~").expanduser()
+        self._location = self._default_profile / "PyMechanical-AppData" / profile_name
         self._dry_run = dry_run
         self.copy_profile = copy_profile
         self.initialize()
@@ -58,15 +58,14 @@ class UniqueUserProfile:
         """Cleanup unique user profile."""
         if self._dry_run:
             return
-        text = "The `private_appdata` option was used, but the following files were not removed: "
-        message = []
 
-        def onerror(function, path, excinfo):
-            if len(message) == 0:
-                message.append(f"{text}{path}")
-                warnings.warn(message[0])
+        # Remove the appdata directory if it exists
+        shutil.rmtree(self.location, ignore_errors=True)
 
-        shutil.rmtree(self.location, onerror=onerror)
+        if self.location.is_dir():
+            warnings.warn(
+                f"The `private appdata` option was used, but {self.location} was not removed"
+            )
 
     @property
     def location(self) -> str:
@@ -77,28 +76,32 @@ class UniqueUserProfile:
         """Set environment variables for new user profile."""
         home = self.location
         if "win" in sys.platform:
-            env["USERPROFILE"] = home
-            env["APPDATA"] = os.path.join(home, "AppData/Roaming")
-            env["LOCALAPPDATA"] = os.path.join(home, "AppData/Local")
-            env["TMP"] = os.path.join(home, "AppData/Local/Temp")
-            env["TEMP"] = os.path.join(home, "AppData/Local/Temp")
+            appdata_dir = home / "AppData"
+            appdata_local_temp = str(appdata_dir / "Local" / "Temp")
+
+            env["USERPROFILE"] = str(home)
+            env["APPDATA"] = str(appdata_dir / "Roaming")
+            env["LOCALAPPDATA"] = str(appdata_dir / "Local")
+            env["TMP"] = appdata_local_temp
+            env["TEMP"] = appdata_local_temp
         elif "lin" in sys.platform:
-            env["HOME"] = home
+            env["HOME"] = str(home)
 
     def exists(self) -> bool:
         """Check if unique profile name already exists."""
-        return os.path.exists(self.location)
+        return self.location.exists()
 
     def mkdirs(self) -> None:
         """Create a unique user profile & set up the directory tree."""
-        os.makedirs(self.location, exist_ok=True)
+        self.location.mkdir(parents=True, exist_ok=True)
         if "win" in sys.platform:
             locs = ["AppData/Roaming", "AppData/Local", "Documents"]
         elif "lin" in sys.platform:
             locs = [".config", "temp/reports"]
 
         for loc in locs:
-            os.makedirs(os.path.join(self.location, loc))
+            dir_name = self.location / loc
+            dir_name.mkdir(parents=True, exist_ok=True)
 
     def copy_profiles(self) -> None:
         """Copy current user directories into a new user profile."""
@@ -107,6 +110,7 @@ class UniqueUserProfile:
         elif "lin" in sys.platform:
             locs = [".mw/Application Data/Ansys", ".config/Ansys"]
         for loc in locs:
-            shutil.copytree(
-                os.path.join(self._default_profile, loc), os.path.join(self.location, loc)
-            )
+            default_profile_loc = self._default_profile / loc
+            temp_appdata_loc = self.location / loc
+            if default_profile_loc.exists():
+                shutil.copytree(default_profile_loc, temp_appdata_loc)

ansys/mechanical/core/embedding/enum_importer.py

@@ -25,6 +25,12 @@
 A useful subset of what is imported by
 Ansys Inc/v{NNN}/ACT/apis/Mechanical.py
 """
+
+from ansys.mechanical.core.embedding.app import is_initialized
+
+if not is_initialized():
+    raise Exception("Enums cannot be imported until the embedded app is initialized.")
+
 import clr
 
 clr.AddReference("Ansys.Mechanical.DataModel")

ansys/mechanical/core/embedding/{viz → graphics}/embedding_plotter.py

@@ -82,7 +82,7 @@ def to_plotter(app: "ansys.mechanical.core.embedding.App"):
         if np_coordinates is None or np_indices is None:
             continue
         pv_transform = _transform_to_pyvista(scenegraph_node.Transform)
-        polydata = pv.PolyData(np_coordinates, np_indices).transform(pv_transform)
+        polydata = pv.PolyData(np_coordinates, np_indices).transform(pv_transform, inplace=True)
         color = pv.Color(bgr_to_rgb_tuple(body.Color))
         plotter.plot(polydata, color=color, smooth_shading=True)
     return plotter

ansys/mechanical/core/embedding/initializer.py

@@ -112,6 +112,74 @@ def __check_python_interpreter_architecture() -> None:
         raise Exception("Mechanical Embedding requires a 64-bit Python environment.")
 
 
+def __windows_store_workaround(version: int) -> None:
+    """Workaround for Windows store.
+
+    See https://github.com/ansys/pymechanical/issues/1136
+
+    Windows store Python uses the Win32 API SetDefaultDllDirectories
+    so that the PATH environment variable isn't scanned for any DLL
+    dependency.
+
+    PyMechanical loads the embedding library which automatically sets
+    these Paths, but this uses the PATH environment variable which doesn't
+    work for Windows store Python.
+
+    We provide a workaround for versions 2024R2 and 2025R1 that sets
+    these paths using `os.add_dll_directory`.
+
+    Note:   This workaround does not include DLL paths used in FSI
+            mapping workflows.
+
+    Parameters
+    ----------
+    version : int
+        The version of Mechanical to set the DLL paths for.
+    """
+    # Nothing to do on Linux
+    if os.name != "nt":
+        return
+
+    # Nothing to do if it isn't a Windows store application
+    if r"Microsoft\WindowsApps" not in sys.executable:
+        return
+
+    # Get the AWP_ROOT environment variable for the specified version
+    awp_root = Path(os.environ[f"AWP_ROOT{version}"])
+    # Set paths to the aisol and framework DLLs
+    paths = [
+        awp_root / "aisol" / "bin" / "winx64",
+        awp_root / "Framework" / "bin" / "Win64",
+    ]
+    # Set the path to the tp directory within the AWP_ROOTXYZ directory
+    awp_root_tp = awp_root / "tp"
+    # Add paths to the IntelCompiler, IntelMKL, HDF5, and Qt DLLs for 2024R2 and 2025R1
+    if version == 242:
+        paths.extend(
+            [
+                awp_root_tp / "IntelCompiler" / "2023.1.0" / "winx64",
+                awp_root_tp / "IntelMKL" / "2023.1.0" / "winx64",
+                awp_root_tp / "hdf5" / "1.12.2" / "winx64",
+                awp_root_tp / "qt" / "5.15.16" / "winx64" / "bin",
+            ]
+        )
+    elif version == 251:
+        paths.extend(
+            [
+                awp_root_tp / "IntelCompiler" / "2023.1.0" / "winx64",
+                awp_root_tp / "IntelMKL" / "2023.1.0" / "winx64",
+                awp_root_tp / "hdf5" / "1.12.2" / "winx64",
+                awp_root_tp / "qt" / "5.15.17" / "winx64" / "bin",
+            ]
+        )
+    else:
+        return
+
+    # Add each path to the DLL search path
+    for path in paths:
+        os.add_dll_directory(str(path))
+
+
 def __set_environment(version: int) -> None:
     """Set environment variables to configure embedding."""
     if os.name == "nt":  # pragma: no cover
@@ -188,6 +256,8 @@ def initialize(version: int = None):
 
     __set_environment(version)
 
+    __windows_store_workaround(version)
+
     __check_loaded_libs(version)
 
     __workaround_material_server(version)

ansys/mechanical/core/embedding/messages.py

@@ -142,7 +142,31 @@ class MessageManager:
         _msg = self._messages[index]
         self._messages.Remove(_msg)
 
-    def show(self, filter="Severity;DisplayString"):
+    def _show_string(self, filter: str = "Severity;DisplayString") -> str:
+        if self._messages.Count == 0:
+            return "No messages to display."
+
+        if filter == "*":
+            selected_columns = [
+                "TimeStamp",
+                "Severity",
+                "DisplayString",
+                "Source",
+                "StringID",
+                "Location",
+                "RelatedObjects",
+            ]
+        else:
+            selected_columns = [col.strip() for col in filter.split(";")]
+
+        lines = []
+        for msg in self._messages:
+            for key in selected_columns:
+                line = f"{key}: {getattr(msg, key, 'Specified attribute not found.')}"
+                lines.append(line)
+        return "\n".join(lines)
+
+    def show(self, filter="Severity;DisplayString") -> None:
         """Print all messages with full details.
 
         Parameters
@@ -163,27 +187,8 @@ class MessageManager:
         ... severity: info
         ... message: Sample message.
         """
-        if self._messages.Count == 0:
-            print("No messages to display.")
-            return
-
-        if filter == "*":
-            selected_columns = [
-                "TimeStamp",
-                "Severity",
-                "DisplayString",
-                "Source",
-                "StringID",
-                "Location",
-                "RelatedObjects",
-            ]
-        else:
-            selected_columns = [col.strip() for col in filter.split(";")]
-
-        for msg in self._messages:
-            for key in selected_columns:
-                print(f"{key}: {getattr(msg, key, 'Specified attribute not found.')}")
-            print()
+        show_string = self._show_string(filter)
+        print(show_string)
 
     def clear(self):
         """Clear all messages."""

ansys/mechanical/core/embedding/resolver.py

@@ -41,7 +41,7 @@ def resolve(version):
         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:
+        error_msg = """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.
     """

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

@@ -22,15 +22,11 @@
 
 """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 .default_server import DefaultServiceMethods, MechanicalDefaultServer
 from .server import (
-    DefaultServiceMethods,
-    MechanicalDefaultServer,
     MechanicalEmbeddedServer,
     MechanicalService,
 )
 from .utils import get_remote_methods, remote_method
+
+# todo - combine Server and MechanicalService

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

@@ -27,14 +27,16 @@ import time
 
 import rpyc
 
-from ansys.mechanical.core.embedding.rpc.server import PYMECHANICAL_DEFAULT_RPC_PORT
+from ansys.mechanical.core.embedding.rpc.utils import PYMECHANICAL_DEFAULT_RPC_PORT
 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, cleanup_on_exit=True):
+    def __init__(
+        self, host: str, port: int, timeout: float = 120.0, cleanup_on_exit=True, process=None
+    ):
         """Initialize the client.
 
         Parameters
@@ -48,6 +50,8 @@ class Client:
         timeout : float, optional
             Maximum allowable time for connecting to the Mechanical server.
             The default is ``60.0``.
+        process: subprocess.Popen, optional
+            The process object that was connected to
 
         """
         if host is None:
@@ -56,11 +60,14 @@ class Client:
         if port is None:
             port = PYMECHANICAL_DEFAULT_RPC_PORT
         self.port = port
+        self._process = process
         self.timeout = timeout
         self.connection = None
         self.root = None
         self._connect()
         self._cleanup_on_exit = cleanup_on_exit
+        self._error_type = Exception
+        self._has_exited = False
 
     def __getattr__(self, attr):
         """Get attribute from the root object."""
@@ -114,6 +121,7 @@ class Client:
 
     def close(self):
         """Close the connection."""
+        print("Closing the connection")
         self.connection.close()
         print(f"Connection to {self.host}:{self.port} closed")
 
@@ -234,6 +242,11 @@ class Client:
             list_of_files.extend(temp_files)
         return list_of_files
 
+    @property
+    def backend(self) -> str:
+        """Get the backend type."""
+        return "python"
+
     @property
     def is_alive(self):
         """Check if the Mechanical instance is alive."""
@@ -245,9 +258,10 @@ class Client:
 
     def exit(self):
         """Shuts down the Mechanical instance."""
-        print("Requesting server shutdown ...")
-        self.service_exit()
-        self.connection.close()
+        if self._has_exited:
+            return
+        self.close()
+        self._has_exited = True
         print("Disconnected from server")
 
     def __del__(self):  # pragma: no cover

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

@@ -0,0 +1,131 @@
+# 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
+
+from ansys.mechanical.core.embedding.app import App
+
+from .server import MechanicalEmbeddedServer
+from .utils import remote_method
+
+
+class DefaultServiceMethods:
+    """Default service methods for MechanicalEmbeddedServer."""
+
+    def __init__(self, app: 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.ExtAPI.DataModel.Project.ProjectDirectory
+
+    @remote_method
+    def list_files(self):
+        """List all files in the project directory."""
+        list = []
+        mechdbPath = self._app.ExtAPI.DataModel.Project.FilePath
+        if mechdbPath != "":
+            list.append(mechdbPath)
+        rootDir = self._app.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__(impl=DefaultServiceMethods, **kwargs)