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

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

@@ -25,7 +25,6 @@
 A useful subset of what is imported by
 Ansys Inc/v{NNN}/ACT/apis/Mechanical.py
 """
-
 import clr
 
 clr.AddReference("Ansys.Mechanical.DataModel")

ansys/mechanical/core/embedding/global_importer.py

@@ -0,0 +1,50 @@
+# 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.
+"""Import Mechanical globals."""
+
+from ansys.mechanical.core.embedding.app import is_initialized
+
+if not is_initialized():
+    raise Exception("Globals cannot be imported until the embedded app is initialized.")
+
+import clr
+
+clr.AddReference("Ansys.Mechanical.DataModel")
+clr.AddReference("Ansys.ACT.Interfaces")
+
+
+clr.AddReference("System.Collections")
+clr.AddReference("Ansys.ACT.WB1")
+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  # noqa isort: skip
+from Ansys.ACT.Math import Vector3D  # noqa isort: skip
+from Ansys.Core.Units import Quantity  # noqa isort: skip
+from Ansys.Mechanical.DataModel import MechanicalEnums  # noqa isort: skip
+from Ansys.Mechanical.Graphics import Point, SectionPlane  # noqa isort: skip
+
+from ansys.mechanical.core.embedding.transaction import Transaction  # noqa isort: skip
+
+import System  # noqa isort: skip
+import Ansys  # noqa isort: skip

ansys/mechanical/core/embedding/imports.py

@@ -46,36 +46,37 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     To also import all the enums, set the parameter enums to true.
     """
     vars = global_entry_points(app)
-    import clr  # isort: skip
-
-    clr.AddReference("System.Collections")
-    clr.AddReference("Ansys.ACT.WB1")
-    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
-
-    vars["Quantity"] = Quantity
-    vars["System"] = System
-    vars["Ansys"] = Ansys
+
+    from ansys.mechanical.core.embedding.app import is_initialized
+    from ansys.mechanical.core.embedding.transaction import Transaction
+
     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
+
+    # Import modules if the app is initialized
+    if is_initialized():
+        from ansys.mechanical.core.embedding.global_importer import (
+            Ansys,
+            MechanicalEnums,
+            Point,
+            Point2D,
+            Point3D,
+            Quantity,
+            SectionPlane,
+            System,
+            Vector3D,
+        )
+
+        vars["Quantity"] = Quantity
+        vars["System"] = System
+        vars["Ansys"] = Ansys
+        vars["MechanicalEnums"] = MechanicalEnums
+        # Graphics
+        vars["Point"] = Point
+        vars["SectionPlane"] = SectionPlane
+        # Math
+        vars["Point2D"] = Point2D
+        vars["Point3D"] = Point3D
+        vars["Vector3D"] = Vector3D
 
     if enums:
         vars.update(get_all_enums())
@@ -95,32 +96,3 @@ def get_all_enums() -> typing.Dict[str, typing.Any]:
         if type(the_enum).__name__ == "CLRMetatype":
             enums[attr] = the_enum
     return enums
-
-
-class Transaction:  # When ansys-pythonnet issue #14 is fixed, this class will be removed
-    """
-    A class to speed up bulk user interactions using Ansys ACT Mechanical Transaction.
-
-    Example
-    -------
-    >>> with Transaction() as transaction:
-    ...     pass   # Perform bulk user interactions here
-    ...
-    """
-
-    def __init__(self):
-        """Initialize the Transaction class."""
-        import clr
-
-        clr.AddReference("Ansys.ACT.WB1")
-        import Ansys
-
-        self._transaction = Ansys.ACT.Mechanical.Transaction()
-
-    def __enter__(self):
-        """Enter the context of the transaction."""
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit the context of the transaction and disposes of resources."""
-        self._transaction.Dispose()

ansys/mechanical/core/embedding/initializer.py

@@ -30,6 +30,7 @@ import warnings
 
 from ansys.mechanical.core.embedding.loader import load_clr
 from ansys.mechanical.core.embedding.resolver import resolve
+from ansys.mechanical.core.mechanical import LOG
 
 INITIALIZED_VERSION = None
 """Constant for the initialized version."""
@@ -85,7 +86,6 @@ def _get_latest_default_version() -> int:
     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 not awp_roots:
         raise Exception("No Mechanical installations found.")
 
@@ -94,13 +94,15 @@ def _get_latest_default_version() -> int:
         folder = os.path.basename(os.path.normpath(path))
         version = folder.split("v")[-1]
         versions_found.append(int(version))
+
+    LOG.info(f"Available versions of Mechanical: {versions_found}")
+
     latest_version = max(versions_found)
 
     if len(awp_roots) > 1:
-        warnings.warn(
+        LOG.warning(
             f"Multiple versions of Mechanical found! Using latest version {latest_version} ..."
         )
-
     return latest_version
 
 
@@ -159,7 +161,7 @@ def __check_loaded_libs(version: int = None):  # pragma: no cover
     # 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(
+        LOG.warning(
             "libX11.so is loaded prior to initializing the Embedded Instance of Mechanical.\
                       Python will crash on shutdown..."
         )

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

@@ -1,219 +1,219 @@
-# 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)
+# 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)