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

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

@@ -1,216 +1,219 @@
-# Copyright (C) 2022 - 2024 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.
-
-"""Embedding logger.
-
-Module to interact with the built-in logging system of Mechanical.
-
-Usage
------
-
-Configuring logger
-~~~~~~~~~~~~~~~~~~
-
-Configuring the logger can be done using the :class:`Configuration <ansys.mechanical.core.embedding.logger.Configuration>` class:
-
-.. code:: python
-  import ansys.mechanical.core as mech
-  from ansys.mechanical.core.embedding.logger import Configuration, Logger
-
-  Configuration.configure(level=logging.INFO, to_stdout=True, base_directory=None)
-  app = mech.App(version=241)
-
-Then, the :class:`Logger <ansys.mechanical.core.embedding.logger.Logger>` class can be used to write messages to the log:
-
-.. code:: python
-
-   Logger.error("message")
-
-
-"""
-
-import logging
-import os
-import typing
-
-from ansys.mechanical.core.embedding import initializer
-from ansys.mechanical.core.embedding.logger import environ, linux_api, sinks, windows_api
-
-LOGGING_SINKS: typing.Set[int] = set()
-LOGGING_CONTEXT: str = "PYMECHANICAL"
-
-
-def _get_backend() -> (
-    typing.Union[windows_api.APIBackend, linux_api.APIBackend, environ.EnvironBackend]
-):
-    """Get the appropriate logger backend.
-
-    Before embedding is initialized, logging is configured via environment variables.
-    After embedding is initialized, logging is configured by making API calls into the
-    Mechanical logging system.
-
-    However, the API is mostly the same in both cases, though some methods only work
-    in one of the two backends.
-
-    Setting the base directory only works before initializing.
-    Actually logging a message or flushing the log only works after initializing.
-    """
-    # TODO - use abc instead of a union type?
-    embedding_initialized = initializer.INITIALIZED_VERSION != None
-    if not embedding_initialized:
-        return environ.EnvironBackend()
-    if os.name == "nt":
-        return windows_api.APIBackend()
-    return linux_api.APIBackend()
-
-
-class Configuration:
-    """Configures logger for Mechanical embedding."""
-
-    @classmethod
-    def configure(cls, level=logging.WARNING, directory=None, base_directory=None, to_stdout=True):
-        """Configure the logger for PyMechanical embedding.
-
-        Parameters
-        ----------
-        level : int, optional
-            Level of logging that is defined in the ``logging`` package. The default is 'DEBUG'.
-            Options are ``"DEBUG"``, ``"INFO"``, ``"WARNING"``, and ``"ERROR"``.
-        directory : str, optional
-            Directory to write log file to. The default is ``None``, but by default the log
-            will appear somewhere in the system temp folder.
-        base_directory: str, optional
-            Base directory to write log files to. Each instance of Mechanical will write its
-            log to a time-stamped subfolder within this directory. This is only possible to set
-            before Mechanical is initialized.
-        to_stdout : bool, optional
-            Whether to write log messages to the standard output, which is the
-            command line. The default is ``True``.
-        """
-        # Set up the global log configuration.
-        cls.set_log_directory(directory)
-        cls.set_log_base_directory(base_directory)
-
-        # Set up the sink-specific log configuration and store to global state.
-        cls._store_stdout_sink_enabled(to_stdout)
-        file_sink_enabled = directory != None or base_directory != None
-        cls._store_file_sink_enabled(file_sink_enabled)
-
-        # Commit the sink-specific log configuration global state to the backend.
-        cls._commit_enabled_configuration()
-        cls.set_log_level(level)
-
-    @classmethod
-    def set_log_to_stdout(cls, value: bool) -> None:
-        """Configure logging to write to the standard output."""
-        cls._store_stdout_sink_enabled(value)
-        cls._commit_enabled_configuration()
-
-    @classmethod
-    def set_log_to_file(cls, value: bool) -> None:
-        """Configure logging to write to a file."""
-        cls._store_file_sink_enabled(value)
-        cls._commit_enabled_configuration()
-
-    @classmethod
-    def set_log_level(cls, level: int) -> None:
-        """Set the log level for all configured sinks."""
-        if len(LOGGING_SINKS) == 0:
-            raise Exception("No logging backend configured!")
-        cls._commit_level_configuration(level)
-
-    @classmethod
-    def set_log_directory(cls, value: str) -> None:
-        """Configure logging to write to a directory."""
-        if value == None:
-            return
-        _get_backend().set_directory(value)
-
-    @classmethod
-    def set_log_base_directory(cls, directory: str) -> None:
-        """Configure logging to write in a time-stamped subfolder in this directory."""
-        if directory == None:
-            return
-        _get_backend().set_base_directory(directory)
-
-    @classmethod
-    def _commit_level_configuration(cls, level: int) -> None:
-        for sink in LOGGING_SINKS:
-            _get_backend().set_log_level(level, sink)
-
-    @classmethod
-    def _commit_enabled_configuration(cls) -> None:
-        for sink in LOGGING_SINKS:
-            _get_backend().enable(sink)
-
-    @classmethod
-    def _store_stdout_sink_enabled(cls, value: bool) -> None:
-        if value:
-            LOGGING_SINKS.add(sinks.StandardSinks.CONSOLE)
-        else:
-            LOGGING_SINKS.discard(sinks.StandardSinks.CONSOLE)
-
-    @classmethod
-    def _store_file_sink_enabled(cls, value: bool) -> None:
-        if value:
-            LOGGING_SINKS.add(sinks.StandardSinks.STANDARD_LOG_FILE)
-        else:
-            LOGGING_SINKS.discard(sinks.StandardSinks.STANDARD_LOG_FILE)
-
-
-class Logger:
-    """Provides the ``Logger`` class for embedding."""
-
-    @classmethod
-    def flush(cls):
-        """Flush the log."""
-        _get_backend().flush()
-
-    @classmethod
-    def can_log_message(cls, level: int) -> bool:
-        """Get whether a message at this level is logged."""
-        return _get_backend().can_log_message(level)
-
-    @classmethod
-    def debug(cls, msg: str):
-        """Write a debug message to the log."""
-        _get_backend().log_message(logging.DEBUG, LOGGING_CONTEXT, msg)
-
-    @classmethod
-    def error(cls, msg: str):
-        """Write a error message to the log."""
-        _get_backend().log_message(logging.ERROR, LOGGING_CONTEXT, msg)
-
-    @classmethod
-    def info(cls, msg: str):
-        """Write an info message to the log."""
-        _get_backend().log_message(logging.INFO, LOGGING_CONTEXT, msg)
-
-    @classmethod
-    def warning(cls, msg: str):
-        """Write a warning message to the log."""
-        _get_backend().log_message(logging.WARNING, LOGGING_CONTEXT, msg)
-
-    @classmethod
-    def fatal(cls, msg: str):
-        """Write a fatal message to the log."""
-        _get_backend().log_message(logging.FATAL, LOGGING_CONTEXT, msg)
+# 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.
+
+"""Embedding logger.
+
+Module to interact with the built-in logging system of Mechanical.
+
+Usage
+-----
+
+Configuring logger
+~~~~~~~~~~~~~~~~~~
+
+Configuring the logger can be done using the :class:`Configuration <ansys.mechanical.core.embedding.logger.Configuration>` class:
+
+.. code:: python
+  import ansys.mechanical.core as mech
+  from ansys.mechanical.core.embedding.logger import Configuration, Logger
+
+  Configuration.configure(level=logging.INFO, to_stdout=True, base_directory=None)
+  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:
+
+.. code:: python
+
+   Logger.error("message")
+
+
+"""
+
+import logging
+import os
+import typing
+
+from ansys.mechanical.core.embedding import initializer
+from ansys.mechanical.core.embedding.logger import environ, linux_api, sinks, windows_api
+
+LOGGING_SINKS: typing.Set[int] = set()
+"""Constant for logging sinks."""
+
+LOGGING_CONTEXT: str = "PYMECHANICAL"
+"""Constant for logging context."""
+
+
+def _get_backend() -> (
+    typing.Union[windows_api.APIBackend, linux_api.APIBackend, environ.EnvironBackend]
+):
+    """Get the appropriate logger backend.
+
+    Before embedding is initialized, logging is configured via environment variables.
+    After embedding is initialized, logging is configured by making API calls into the
+    Mechanical logging system.
+
+    However, the API is mostly the same in both cases, though some methods only work
+    in one of the two backends.
+
+    Setting the base directory only works before initializing.
+    Actually logging a message or flushing the log only works after initializing.
+    """
+    # TODO - use abc instead of a union type?
+    embedding_initialized = initializer.INITIALIZED_VERSION is not None
+    if not embedding_initialized:
+        return environ.EnvironBackend()
+    if os.name == "nt":
+        return windows_api.APIBackend()
+    return linux_api.APIBackend()
+
+
+class Configuration:
+    """Configures logger for Mechanical embedding."""
+
+    @classmethod
+    def configure(cls, level=logging.WARNING, directory=None, base_directory=None, to_stdout=True):
+        """Configure the logger for PyMechanical embedding.
+
+        Parameters
+        ----------
+        level : int, optional
+            Level of logging that is defined in the ``logging`` package. The default is 'DEBUG'.
+            Options are ``"DEBUG"``, ``"INFO"``, ``"WARNING"``, and ``"ERROR"``.
+        directory : str, optional
+            Directory to write log file to. The default is ``None``, but by default the log
+            will appear somewhere in the system temp folder.
+        base_directory: str, optional
+            Base directory to write log files to. Each instance of Mechanical will write its
+            log to a time-stamped subfolder within this directory. This is only possible to set
+            before Mechanical is initialized.
+        to_stdout : bool, optional
+            Whether to write log messages to the standard output, which is the
+            command line. The default is ``True``.
+        """
+        # Set up the global log configuration.
+        cls.set_log_directory(directory)
+        cls.set_log_base_directory(base_directory)
+
+        # Set up the sink-specific log configuration and store to global state.
+        cls._store_stdout_sink_enabled(to_stdout)
+        file_sink_enabled = directory is not None or base_directory is not None
+        cls._store_file_sink_enabled(file_sink_enabled)
+
+        # Commit the sink-specific log configuration global state to the backend.
+        cls._commit_enabled_configuration()
+        cls.set_log_level(level)
+
+    @classmethod
+    def set_log_to_stdout(cls, value: bool) -> None:
+        """Configure logging to write to the standard output."""
+        cls._store_stdout_sink_enabled(value)
+        cls._commit_enabled_configuration()
+
+    @classmethod
+    def set_log_to_file(cls, value: bool) -> None:
+        """Configure logging to write to a file."""
+        cls._store_file_sink_enabled(value)
+        cls._commit_enabled_configuration()
+
+    @classmethod
+    def set_log_level(cls, level: int) -> None:
+        """Set the log level for all configured sinks."""
+        if len(LOGGING_SINKS) == 0:
+            raise Exception("No logging backend configured!")
+        cls._commit_level_configuration(level)
+
+    @classmethod
+    def set_log_directory(cls, value: str) -> None:
+        """Configure logging to write to a directory."""
+        if value is None:
+            return
+        _get_backend().set_directory(value)
+
+    @classmethod
+    def set_log_base_directory(cls, directory: str) -> None:
+        """Configure logging to write in a time-stamped subfolder in this directory."""
+        if directory is None:
+            return
+        _get_backend().set_base_directory(directory)
+
+    @classmethod
+    def _commit_level_configuration(cls, level: int) -> None:
+        for sink in LOGGING_SINKS:
+            _get_backend().set_log_level(level, sink)
+
+    @classmethod
+    def _commit_enabled_configuration(cls) -> None:
+        for sink in LOGGING_SINKS:
+            _get_backend().enable(sink)
+
+    @classmethod
+    def _store_stdout_sink_enabled(cls, value: bool) -> None:
+        if value:
+            LOGGING_SINKS.add(sinks.StandardSinks.CONSOLE)
+        else:
+            LOGGING_SINKS.discard(sinks.StandardSinks.CONSOLE)
+
+    @classmethod
+    def _store_file_sink_enabled(cls, value: bool) -> None:
+        if value:
+            LOGGING_SINKS.add(sinks.StandardSinks.STANDARD_LOG_FILE)
+        else:
+            LOGGING_SINKS.discard(sinks.StandardSinks.STANDARD_LOG_FILE)
+
+
+class Logger:
+    """Provides the ``Logger`` class for embedding."""
+
+    @classmethod
+    def flush(cls):
+        """Flush the log."""
+        _get_backend().flush()
+
+    @classmethod
+    def can_log_message(cls, level: int) -> bool:
+        """Get whether a message at this level is logged."""
+        return _get_backend().can_log_message(level)
+
+    @classmethod
+    def debug(cls, msg: str):
+        """Write a debug message to the log."""
+        _get_backend().log_message(logging.DEBUG, LOGGING_CONTEXT, msg)
+
+    @classmethod
+    def error(cls, msg: str):
+        """Write a error message to the log."""
+        _get_backend().log_message(logging.ERROR, LOGGING_CONTEXT, msg)
+
+    @classmethod
+    def info(cls, msg: str):
+        """Write an info message to the log."""
+        _get_backend().log_message(logging.INFO, LOGGING_CONTEXT, msg)
+
+    @classmethod
+    def warning(cls, msg: str):
+        """Write a warning message to the log."""
+        _get_backend().log_message(logging.WARNING, LOGGING_CONTEXT, msg)
+
+    @classmethod
+    def fatal(cls, msg: str):
+        """Write a fatal message to the log."""
+        _get_backend().log_message(logging.FATAL, LOGGING_CONTEXT, msg)

ansys/mechanical/core/embedding/logger/environ.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
 #
 #

ansys/mechanical/core/embedding/logger/linux_api.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
 #
 #

ansys/mechanical/core/embedding/logger/sinks.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
 #
 #

ansys/mechanical/core/embedding/logger/windows_api.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
 #
 #
@@ -41,7 +41,7 @@ def _get_logger():
         import Ansys
 
         return Ansys.Common.WB1ManagedUtils.Logger
-    except:
+    except (ImportError, RuntimeError):
         raise Exception("Logging cannot be used until after Mechanical embedding is initialized.")
 
 

ansys/mechanical/core/embedding/poster.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
 #
 #
@@ -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,15 +50,36 @@ 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
         in order for this to work from a background thread. Use
         the `sleep` routine from the `utils` module to make
         Mechanical available to receive messages.
+
+        Returns the result of `callable` if any.
         """
         import System
 
-        action = System.Action(callable)
-        self._poster.Post(action)
+        func = System.Func[System.Object](callable)
+        return self._poster.Get[System.Object](func)

ansys/mechanical/core/embedding/resolver.py

@@ -1,44 +1,41 @@
-# Copyright (C) 2022 - 2024 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.
-
-"""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
-"""
-
-
-def resolve(version):
-    """Resolve function for all versions of Ansys Mechanical."""
-    import clr  # isort: skip
-    import System  # isort: skip
-
-    clr.AddReference("Ansys.Mechanical.Embedding")
-    import Ansys  # isort: skip
-
-    assembly_resolver = Ansys.Mechanical.Embedding.AssemblyResolver
-    if version == 231:  # pragma: no cover
-        resolve_handler = assembly_resolver.WindowsResolveEventHandler
-    else:
-        resolve_handler = assembly_resolver.MechanicalResolveEventHandler
-    System.AppDomain.CurrentDomain.AssemblyResolve += resolve_handler
+# 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.
+
+"""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
+"""
+
+
+def resolve(version):
+    """Resolve function for all versions of Ansys Mechanical."""
+    import clr  # isort: skip
+    import System  # isort: skip
+
+    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

ansys/mechanical/core/embedding/runtime.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
 #
 #