py-neuromodulation 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

packages/tmsi/build/lib/apex_sdk/tmsi_errors/error.py

@@ -0,0 +1,126 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file error.py 
+ * @brief 
+ * TMSi Error interface.
+ */
+
+
+"""
+
+from enum import Enum, unique
+
+
+@unique
+class TMSiErrorCode(Enum):
+    general_error = 0
+    missing_dll = 1
+    already_in_use_dll = 2
+    device_error = 100
+    device_not_connected = 101
+    no_devices_found = 102
+    api_no_driver = 200
+    api_incorrect_argument = 201
+    api_invalid_command = 202
+    file_writer_error = 300
+
+
+class TMSiError(Exception):
+    def __init__(self, error_code, dll_error_code=None):
+        self.dll_error_code = None
+        self.error_code = error_code
+        if dll_error_code:
+            self.dll_error_code = hex(dll_error_code.value)
+
+    def __str__(self):
+        if self.dll_error_code:
+            return "Error code {}: {} \nDLL Error code {}: {}".format(
+                self.error_code.value,
+                SdkErrorLookupTable(str(self.error_code.value)),
+                self.dll_error_code,
+                DeviceErrorLookupTable(self.dll_error_code),
+            )
+        return "Error code {}: {}".format(
+            self.error_code.value,
+            SdkErrorLookupTable(str(self.error_code.value)),
+        )
+
+
+def DeviceErrorLookupTable(code):
+    _lookup_table = {
+        "0x0000000": "",
+        "0x1010001": "DR reported 'Checksum error in received block'",
+        "0x2010001": "DS reported 'Checksum error in received block'",
+        "0x1010002": "DR reported 'Unknown command'",
+        "0x2010002": "DS reported 'Unknown command'",
+        "0x1010003": "DR reported 'Response timeout'",
+        "0x2010003": "DS reported 'Response timeout'",
+        "0x1010004": "DR reported 'Device busy try again in x msec'",
+        "0x2010004": "DS reported 'Device busy try again in x msec'",
+        "0x1010005": "DR reported 'Command not supported over current interface'",
+        "0x2010005": "DS reported 'Command not supported over current interface'",
+        "0x1010006": "DR reported 'Command not possible, device is recording'",
+        "0x1010007": "DR reported 'Device not available'",
+        "0x2010007": "DS reported 'Device not available'",
+        "0x2010008": "DS reported 'Interface not available'",
+        "0x2010009": "DS reported 'Command not allowed in current mode'",
+        "0x201000A": "DS reported 'Processing error'",
+        "0x201000B": "DS reported 'Unknown internal error'",
+        "0x1030001": "DR reported 'Command not supported by Channel'",
+        "0x1030002": "DR reported 'Illegal start control for ambulant recording",
+        "0x201000C": "DS reports that data request does not fit with one Device Api Packet",
+        "0x201000D": "DS reports that DR is already opened",
+        "0x3001000": "DLL Function is declared, but not yet implemented",
+        "0x3001001": "DLL Function called with invalid parameters",
+        "0x3001002": "Incorrect checksum of response message",
+        "0x3001003": "DLL Function failed because of header failure",
+        "0x3001004": "DLL Function failed because an underlying process failed",
+        "0x3001005": "DLL Function called with a too small buffer",
+        "0x3001006": "DLL Function called with a Handle that's not assigned to a device",
+        "0x3002000": "DLL Function failed becasue could not open selected interface",
+        "0x3002001": "DLL Function failed because could not close selected interface",
+        "0x3002002": "DLL Function failed because could not send command-data",
+        "0x3002003": "DLL Function failed because could not receive data",
+        "0x3002004": "DLL Function failed because commination timed out",
+        "0x3002005": "Lost connection to DS, USB / Ethernet disconnect",
+    }
+
+    return _lookup_table[code]
+
+
+def SdkErrorLookupTable(code):
+    _lookup_table = {
+        "0": "general error",
+        "1": "missing dll",
+        "2": "already in use dll",
+        "100": "device error",
+        "101": "device not connected",
+        "102": "no devices found",
+        "200": "api no driver",
+        "201": "api incorrect argument",
+        "202": "api invalid command",
+        "300": "file writer error",
+    }
+    return _lookup_table[code]

packages/tmsi/build/lib/apex_sdk/tmsi_sdk.py

@@ -0,0 +1,113 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file tmsi_sdk.py 
+ * @brief 
+ * Singleton class which handles the discovery of TMSi devices.
+ */
+
+
+"""
+
+from .tmsi_utilities.singleton import Singleton
+from .device.tmsi_device_enums import *
+from .device.devices.apex.apex_device import ApexDevice
+
+
+class TMSiSDK(metaclass=Singleton):
+    """Singleton class which handles the discovery of TMSi devices"""
+
+    def __init__(self):
+        """Initializes the object."""
+        self.__apex_device_list = []
+        self.__apex_dongle_list = []
+        self.__saga_device_list = []
+
+    def discover(
+        self,
+        dev_type=DeviceType.apex,
+        dr_interface=DeviceInterfaceType.usb,
+        ds_interface=DeviceInterfaceType.none,
+        num_retries=3,
+    ):
+        """Discovers if there are available devices.
+
+        :param dev_type: device tipe to search, defaults to DeviceType.apex
+        :type dev_type: DeviceType, optional
+        :param dr_interface: datarecorder interface, defaults to DeviceInterfaceType.usb
+        :type dr_interface: DeviceInterfaceType, optional
+        :param ds_interface: dockstation interface (if needed), defaults to DeviceInterfaceType.none
+        :type ds_interface: DeviceInterfaceType, optional
+        :param num_retries: number of retry if nothing found
+        :type num_retries: int, optional
+        :return: _description_
+        :rtype: tuple[list[TMSiDevice], list[TMSiDongle]]
+        """
+        if dev_type == DeviceType.apex:
+            ApexDevice.discover(dr_interface, num_retries)
+            self.__apex_device_list = ApexDevice.get_device_list(dr_interface)
+            self.__apex_dongle_list = ApexDevice.get_dongle_list()
+            return (self.__apex_device_list, self.__apex_dongle_list)
+
+    def get_device_list(self, dev_type=DeviceType.apex):
+        """Gets the list of available devices.
+
+        :param dev_type: device to get, defaults to DeviceType.apex
+        :type dev_type: DeviceType, optional
+        :return: list of available devices.
+        :rtype: list[TMSiDevice]
+        """
+        if dev_type == DeviceType.apex:
+            return self.__apex_device_list
+        elif dev_type == DeviceType.saga:
+            return self.__saga_device_list
+
+    def get_dongle_list(self, dev_type=DeviceType.apex):
+        """Gets the list of available dongles.
+
+        :param dev_type: device type dongle to get, defaults to DeviceType.apex
+        :type dev_type: DeviceType, optional
+        :return: list of available dongles.
+        :rtype: list[TMSiDongle]
+        """
+        if dev_type == DeviceType.apex:
+            return self.__apex_dongle_list
+
+    def get_driver_version(self, dev_type=DeviceType.apex) -> str:
+        """Gets the driver version
+
+        :param dev_type: the device type for the drivers, defaults to DeviceType.apex
+        :type dev_type: DeviceType, optional
+        :return: driver version
+        :rtype: str
+        """
+        if dev_type == DeviceType.apex:
+            version = ApexDevice.get_driver_version()
+            dll_version = "".join(
+                [chr(i) for i in version.DllVersionString if i != 0]
+            )
+            usb_version = "".join(
+                [chr(i) for i in version.LibUsbVersionString if i != 0]
+            )
+            return (dll_version, usb_version)

packages/tmsi/build/lib/apex_sdk/tmsi_utilities/apex/apex_structure_generator.py

@@ -0,0 +1,134 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file apex_structure_generator.py 
+ * @brief 
+ * Object that creates the structures needed to communicate with APEX.
+ */
+
+
+"""
+
+import datetime
+
+from ...device.devices.apex import apex_API_structures as ApexStructures
+from ...device.devices.apex import apex_API_enums as ApexEnums
+from ...device.devices.apex.apex_device import ApexDevice
+
+
+class ApexStructureGenerator:
+    def create_card_record_configuration(
+        device: ApexDevice,
+        start_control: ApexEnums.ApexStartCardRecording,
+        prefix_file_name: str = None,
+        start_time: datetime.datetime = None,
+        stop_time: datetime.datetime = None,
+        pre_measurement_imp=None,
+        pre_measeurement_imp_seconds=None,
+        user_string_1: str = None,
+        user_string_2: str = None,
+    ) -> ApexStructures.TMSiDevCardRecCfg:
+        """Creates the TMSiDevCardRecCfg structure with provided parameters
+
+        :param device: device to pull the configuration from
+        :type device: ApexDevice
+        :param prefix_file_name: prefix file name, defaults to None.
+        :type prefix_file_name: str, optional
+        :param start_time: datetime of the start, defaults to None.
+        :type start_time: datetime.datetime, optional
+        :param stop_time: datetime of the stop, defaults to None.
+        :type stop_time: datetime.datetime, optional
+        :param user_string_1: user string, defaults to None.
+        :type user_string_1: str, optional
+        :param user_string_2: user string, defaults to None.
+        :type user_string_2: str, optional
+        :return: the structure containing provided information
+        :rtype: ApexStructures.TMSiDevCardRecCfg
+        """
+
+        config = device.get_card_recording_config()
+        config.StartControl = start_control.value
+        if prefix_file_name is not None:
+            converted_str = bytearray(
+                ApexEnums.ApexStringLengths.PrefixFileName.value
+            )
+            for character in range(len(prefix_file_name)):
+                converted_str[character] = ord(prefix_file_name[character])
+            config.PrefixFileName = bytes(converted_str)
+        if user_string_1 is not None:
+            converted_str = bytearray(
+                ApexEnums.ApexStringLengths.UserString.value
+            )
+            for character in range(len(user_string_1)):
+                converted_str[character] = ord(user_string_1[character])
+            config.UserString1 = bytes(converted_str)
+        if user_string_2 is not None:
+            converted_str = bytearray(
+                ApexEnums.ApexStringLengths.UserString.value
+            )
+            for character in range(len(user_string_2)):
+                converted_str[character] = ord(user_string_2[character])
+            config.UserString2 = bytes(converted_str)
+        if start_time is not None:
+            ApexStructureGenerator.from_datetime_to_tmsitime(
+                start_time, config.StartTime
+            )
+        if stop_time is not None:
+            ApexStructureGenerator.from_datetime_to_tmsitime(
+                stop_time, config.StopTime
+            )
+        if pre_measurement_imp is not None:
+            config.PreImp = pre_measurement_imp
+        if pre_measeurement_imp_seconds is not None:
+            config.PreImpSec = pre_measeurement_imp_seconds
+        return config
+
+    def from_qdatetime_to_tmsitime(qdatetime, tmsi_time):
+        tmsi_time.Seconds = qdatetime.time().second()
+        tmsi_time.Minutes = qdatetime.time().minute()
+        tmsi_time.Hours = qdatetime.time().hour()
+        tmsi_time.DayOfMonth = qdatetime.date().day()
+        tmsi_time.Month = qdatetime.date().month() - 1
+        tmsi_time.Year = qdatetime.date().year() - 1900
+        return tmsi_time
+
+    def from_datetime_to_tmsitime(date_time, tmsi_time):
+        tmsi_time.Seconds = date_time.time().second
+        tmsi_time.Minutes = date_time.time().minute
+        tmsi_time.Hours = date_time.time().hour
+        tmsi_time.DayOfMonth = date_time.date().day
+        tmsi_time.Month = date_time.date().month - 1
+        tmsi_time.Year = date_time.date().year - 1900
+        return tmsi_time
+
+    def from_tmsitime_to_datetime(tmsi_time, date_time):
+        date_time = datetime.datetime(
+            tmsi_time.Year + 1900,
+            tmsi_time.Month + 1,
+            tmsi_time.DayOfMonth,
+            tmsi_time.Hours,
+            tmsi_time.Minutes,
+            tmsi_time.Seconds,
+        )
+        return date_time

packages/tmsi/build/lib/apex_sdk/tmsi_utilities/decorators.py

@@ -0,0 +1,60 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file decorators.py 
+ * @brief 
+ * Decorator class to handle decorative functions.
+ */
+
+
+"""
+
+import time
+import os
+
+from .tmsi_logger import TMSiLoggerPerformance
+
+
+def LogPerformances(func):
+    def performance_logger(*args, **kwargs):
+        if "TMSi_ENV" in os.environ:
+            env = os.environ["TMSi_ENV"]
+        else:
+            env = "DLL"
+        if "TMSi_PERF" not in os.environ:
+            response = func(*args, **kwargs)
+        elif os.environ["TMSi_PERF"] == "ON":
+            tic = time.perf_counter()
+            response = func(*args, **kwargs)
+            toc = time.perf_counter()
+            TMSiLoggerPerformance().log(
+                "{} | {}: {:.3f} ms".format(
+                    env, func.__qualname__, (toc - tic) * 1_000
+                )
+            )
+        else:
+            response = func(*args, **kwargs)
+        return response
+
+    return performance_logger

packages/tmsi/build/lib/apex_sdk/tmsi_utilities/logger_filter.py

@@ -0,0 +1,42 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file logger_filter.py 
+ * @brief 
+ * Filter to handle the logs.
+ */
+
+
+"""
+
+PERFORMANCE_LOG = 25
+ACTIVITY_LOG = 26
+
+
+class LoggerFilter(object):
+    def __init__(self, level):
+        self.__level = level
+
+    def filter(self, log_record):
+        return log_record.levelno == self.__level

packages/tmsi/build/lib/apex_sdk/tmsi_utilities/singleton.py

@@ -0,0 +1,42 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file singleton.py 
+ * @brief 
+ * Singleton interface.
+ */
+
+
+"""
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(
+                *args, **kwargs
+            )
+        return cls._instances[cls]

packages/tmsi/build/lib/apex_sdk/tmsi_utilities/support_functions.py

@@ -0,0 +1,72 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file support_functions.py 
+ * @brief 
+ * Generic functions needed in the SDK.
+ */
+
+
+"""
+
+import ctypes.wintypes
+import os
+import struct
+
+
+def array_to_matrix(input_array, n_channels):
+    n_samples = len(input_array) // n_channels
+    return [
+        input_array[ii : n_samples * n_channels : n_channels]
+        for ii in range(n_channels)
+    ]
+
+
+def matrix_to_multiplexed_array(input_matrix):
+    return [
+        input_matrix[i][j]
+        for j in range(len(input_matrix[0]))
+        for i in range(len(input_matrix))
+    ]
+
+
+def float_to_uint(f):
+    fmt_pack = "f" * len(f)
+    fmt_unpack = "I" * len(f)
+    pack_struct = struct.Struct(fmt_pack)
+    return struct.unpack(fmt_unpack, pack_struct.pack(*list(f)))
+
+
+def get_documents_path():
+    CSIDL_PERSONAL = 5
+    SHGFP_TYPE_CURRENT = 0
+    buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH)
+    ctypes.windll.shell32.SHGetFolderPathW(
+        None, CSIDL_PERSONAL, None, SHGFP_TYPE_CURRENT, buf
+    )
+    return buf.value
+
+
+def get_local_app_data():
+    return os.getenv("LOCALAPPDATA")

packages/tmsi/build/lib/apex_sdk/tmsi_utilities/tmsi_logger.py

@@ -0,0 +1,98 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file tmsi_logger.py 
+ * @brief 
+ * Loggers used to handle console or file output for informative and debug reasons.
+ */
+
+
+"""
+
+import os
+from sys import platform
+import logging
+from .logger_filter import PERFORMANCE_LOG, LoggerFilter, ACTIVITY_LOG
+from .singleton import Singleton
+from .support_functions import get_documents_path
+
+logging.addLevelName(PERFORMANCE_LOG, "PERFORMANCE")
+logging.addLevelName(ACTIVITY_LOG, "ACTIVITY")
+formatter = logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+
+
+class TMSiLogger(metaclass=Singleton):
+    def __init__(self):
+        self.__tmsi_log = logging.getLogger("TMSi")
+        debug_stream_handler = logging.StreamHandler()
+        debug_stream_handler.setFormatter(formatter)
+        self.__tmsi_log.handlers = [debug_stream_handler]
+
+    def critical(self, message):
+        self.__tmsi_log.log(level=logging.CRITICAL, msg=message)
+
+    def debug(self, message):
+        self.__tmsi_log.log(level=logging.DEBUG, msg=message)
+
+    def info(self, message):
+        self.__tmsi_log.log(level=logging.INFO, msg=message)
+
+    def warning(self, message):
+        self.__tmsi_log.log(level=logging.WARNING, msg=message)
+
+
+class TMSiLoggerActivity(metaclass=Singleton):
+    def __init__(self):
+        self.__tmsi_perf = logging.getLogger("TMSiActivity")
+        perf_handler = logging.FileHandler("__activity.log")
+        perf_handler.setFormatter(formatter)
+        perf_handler.setLevel(ACTIVITY_LOG)
+        perf_handler.addFilter(LoggerFilter(ACTIVITY_LOG))
+        self.__tmsi_perf.handlers = [perf_handler]
+
+    def log(self, message):
+        self.__tmsi_perf.log(level=ACTIVITY_LOG, msg=message)
+
+
+class TMSiLoggerPerformance(metaclass=Singleton):
+    def __init__(self):
+        self.__tmsi_perf = logging.getLogger("TMSiPerformance")
+        if platform == "win32":
+            tmsifolder = os.path.join(
+                get_documents_path(), "TMS_International_B.V", "Apex"
+            )
+            if not os.path.exists(tmsifolder):
+                os.makedirs(tmsifolder)
+            perf_handler = logging.FileHandler(
+                os.path.join(tmsifolder, "__performance.log")
+            )
+        else:
+            perf_handler = logging.FileHandler("__performance.log")
+        perf_handler.setFormatter(formatter)
+        perf_handler.setLevel(PERFORMANCE_LOG)
+        perf_handler.addFilter(LoggerFilter(PERFORMANCE_LOG))
+        self.__tmsi_perf.handlers = [perf_handler]
+
+    def log(self, message):
+        self.__tmsi_perf.log(level=PERFORMANCE_LOG, msg=message)