javonet-ruby-sdk 2.5.20 → 2.6.1

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/transmitter/TransmitterWrapper.py

@@ -13,24 +13,38 @@ class TransmitterWrapper:
     @staticmethod
     def get_native_lib():
         if TransmitterWrapper._python_lib is None:
-            file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
             machine = platform.machine().lower()
             if '64' in machine:
                 arch = 'X64'
             elif 'arm' in machine:
                 arch = 'ARM64' if '64' in machine else 'ARM'
-            else:
+            elif '32' in machine or 'i386' in machine:
                 arch = 'X86'
+            else:
+                raise RuntimeError("Unsupported architecture: " + machine)
 
             if platform.system() == 'Windows':
-                python_lib_path = file_path + f'/Binaries/Native/Windows/{arch}/JavonetPythonRuntimeNative.dll'
+                os_name = 'Windows'
+                lib_name = 'JavonetPythonRuntimeNative.dll'
             elif platform.system() == 'Linux':
-                python_lib_path = file_path + f'/Binaries/Native/Linux/{arch}/libJavonetPythonRuntimeNative.so'
+                os_name = 'Linux'
+                lib_name = 'libJavonetPythonRuntimeNative.so'
             elif platform.system() == 'Darwin':
-                python_lib_path = file_path + f'/Binaries/Native/MacOs/{arch}/libJavonetPythonRuntimeNative.dylib'
+                os_name = 'MacOs'
+                lib_name = 'libJavonetPythonRuntimeNative.dylib'
             else:
-                raise RuntimeError("Unsupported OS: " + platform.system())
-            lib = cdll.LoadLibrary(python_lib_path)
+                raise RuntimeError("Unsupported operating system: " + platform.system())
+
+            relative_path = f'Binaries/Native/{os_name}/{arch}/{lib_name}'
+            native_lib_path = os.path.join(os.path.curdir, relative_path)
+
+            if not os.path.exists(native_lib_path):
+                this_file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+                native_lib_path = os.path.join(this_file_path, relative_path)
+
+
+            lib = cdll.LoadLibrary(native_lib_path)
             lib.SetCallback(callbackFunction)
             TransmitterWrapper._python_lib = lib
         return TransmitterWrapper._python_lib

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/webSocketClient/WebSocketClient.py

@@ -8,7 +8,7 @@ class WebSocketClient:
 
     def __init__(self, uri: str):
         self.uri = uri
-        self.ws = connect(uri)
+        self.ws = connect(uri, max_size=None)
 
     @staticmethod
     def add_or_get_client(uri: str) -> 'WebSocketClient':

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/CommandType.py

@@ -44,3 +44,8 @@ class CommandType(Enum):
     PassDelegate = 39
     InvokeDelegate = 40
     ConvertType = 41
+    AddEventListener = 42
+    PluginWrapper = 43
+    GetAsyncOperationResult = 44
+    AsKwargs = 45
+    GetResultType = 46

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/exception/ExceptionSerializer.py

@@ -4,50 +4,94 @@ import traceback
 from javonet.utils.ExceptionType import ExceptionType
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ExceptionSerializer:
 
     @staticmethod
     def serialize_exception(exception, command):
-        exception_command = Command(command.runtime_name, CommandType.Exception, [])
-        tb = exception.__traceback__
-        trace = traceback.extract_tb(tb)
-        exception_message = str(exception)
-        exception_name = exception.__cause__.__class__.__name__
-
-        # Use lists to collect strings, then join using the pipe separator.
+        exception_command = Command(RuntimeName.python, CommandType.Exception, [])
         stack_classes = []
         stack_methods = []
         stack_lines = []
         stack_files = []
 
-        is_debug = False
-
-        for frame_summary in trace:
-            if "javonet" not in frame_summary.filename or is_debug:
-                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename))
-                stack_methods.append(frame_summary.name)
-                stack_lines.append(str(frame_summary.lineno))
-                stack_files.append(frame_summary.filename)
-
-        # Join list items with '|' and add a trailing '|' if needed.
-        stack_classes_str = "|".join(stack_classes) + "|" if stack_classes else ""
-        stack_methods_str = "|".join(stack_methods) + "|" if stack_methods else ""
-        stack_lines_str = "|".join(stack_lines) + "|" if stack_lines else ""
-        stack_files_str = "|".join(stack_files) + "|" if stack_files else ""
-
-        exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(command))
-        exception_command = exception_command.add_arg_to_payload(exception_name)
-        exception_command = exception_command.add_arg_to_payload(str(exception_message))
-        exception_command = exception_command.add_arg_to_payload(stack_classes_str)
-        exception_command = exception_command.add_arg_to_payload(stack_methods_str)
-        exception_command = exception_command.add_arg_to_payload(stack_lines_str)
-        exception_command = exception_command.add_arg_to_payload(stack_files_str)
+        try:
+            tb = exception.__traceback__
+            trace = traceback.extract_tb(tb)
+            exception_message = str(exception)
+            exception_name = exception.__class__.__name__
+
+            for frame_summary in trace:
+                class_name = ExceptionSerializer.safe_get_class_name(frame_summary)
+                method_name = ExceptionSerializer.safe_get_method_name(frame_summary)
+                file_name = ExceptionSerializer.safe_get_file_name(frame_summary)
+                line = ExceptionSerializer.safe_get_line(frame_summary)
+
+                if "javonet" not in class_name and "reflect" not in class_name:
+                    stack_classes.append(class_name)
+                    stack_methods.append(method_name)
+                    stack_lines.append(str(line))
+                    stack_files.append(file_name)
+
+            stack_classes_str = "|".join(stack_classes)
+            stack_methods_str = "|".join(stack_methods)
+            stack_lines_str = "|".join(stack_lines)
+            stack_files_str = "|".join(stack_files)
+
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(exception_name))
+            exception_command = exception_command.add_arg_to_payload(str(command))
+            exception_command = exception_command.add_arg_to_payload(exception_name)
+            exception_command = exception_command.add_arg_to_payload(str(exception_message))
+            exception_command = exception_command.add_arg_to_payload(stack_classes_str)
+            exception_command = exception_command.add_arg_to_payload(stack_methods_str)
+            exception_command = exception_command.add_arg_to_payload(stack_lines_str)
+            exception_command = exception_command.add_arg_to_payload(stack_files_str)
+
+        except Exception as ex:
+            exception_command = Command(RuntimeName.python, CommandType.Exception, [])
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(ex.__class__.__name__))
+            exception_command = exception_command.add_arg_to_payload(command if command else "Command is null")
+            exception_command = exception_command.add_arg_to_payload("Python Exception Serialization Error")
+            exception_command = exception_command.add_arg_to_payload(str(ex))
+            exception_command = exception_command.add_arg_to_payload("ExceptionSerializer")
+            exception_command = exception_command.add_arg_to_payload("serialize_exception")
+            exception_command = exception_command.add_arg_to_payload("undefined")
+            exception_command = exception_command.add_arg_to_payload("ExceptionSerializer.py")
 
         return exception_command
 
+    @staticmethod
+    def safe_get_class_name(frame_summary):
+        try:
+            return ExceptionSerializer.format_class_name_from_file(frame_summary.filename)
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_method_name(frame_summary):
+        try:
+            return frame_summary.name if frame_summary.name else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_file_name(frame_summary):
+        try:
+            return frame_summary.filename if frame_summary.filename else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_line(frame_summary):
+        try:
+            return frame_summary.lineno if frame_summary.lineno >= 0 else 0
+        except Exception:
+            return 0
+
     @staticmethod
     def get_exception_code(exception_name):
         return ExceptionType.to_enum(exception_name)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/ResolveInstanceHandler.py

@@ -4,6 +4,7 @@ import traceback
 
 from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ResolveInstanceHandler(AbstractCommandHandler):
@@ -23,8 +24,10 @@ class ResolveInstanceHandler(AbstractCommandHandler):
             if len(command.payload) != self._required_parameters_count:
                 raise Exception("ResolveInstanceHandler parameters mismatch!")
 
-            references_cache = ReferencesCache()
-            return references_cache.resolve_reference(command)
+            if command.runtime_name == RuntimeName.python27: 
+                return ReferencesCache().resolve_reference(command)
+            else:
+                return Command(command.runtime_name, CommandType.Reference, command.payload[0])
             
         except Exception as e:
             # W Python 2.7 nie ma with_traceback i from None

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/protocol/CommandDeserializer.py

@@ -7,8 +7,8 @@ from javonet.core.protocol.TypeDeserializer import TypeDeserializer
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.Type import Type
 from javonet.utils.StringEncodingMode import StringEncodingMode
+from javonet.utils.Type import Type
 
 
 class CommandDeserializer(object):
@@ -28,6 +28,8 @@ class CommandDeserializer(object):
         """
         self.buffer = buffer
         self.buffer_len = len(buffer)
+        if self.buffer_len < 11:
+            raise ValueError("Buffer too small to contain a command header.")
         self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
         self.position = 11
 
@@ -37,7 +39,7 @@ class CommandDeserializer(object):
 
         :return: True if end of buffer is reached, False otherwise
         """
-        return self.position == self.buffer_len
+        return self.position >= self.buffer_len
 
     def deserialize(self):
         """
@@ -49,6 +51,11 @@ class CommandDeserializer(object):
             self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
         return self.command
 
+    def _check_buffer(self, required_size):
+        """Checks if there are enough bytes left in the buffer."""
+        if self.position + required_size > self.buffer_len:
+            raise IndexError("Not enough data in buffer to read next value.")
+
     def read_object(self, type_num):
         """
         Reads an object from the buffer based on its type.
@@ -71,7 +78,10 @@ class CommandDeserializer(object):
             Type.JavonetUnsignedInteger: self.read_uint,
             Type.JavonetNoneType: self.read_none
         }
-        return switch.get(type_value, lambda: Exception("Type not supported"))()
+        func = switch.get(type_value)
+        if func is None:
+            raise ValueError("Type not supported: " + str(type_num))
+        return func()
 
     def read_command(self):
         """
@@ -79,28 +89,18 @@ class CommandDeserializer(object):
 
         :return: Read command
         """
+        self._check_buffer(7)
         p = self.position
         number_of_elements_in_payload = TypeDeserializer.deserialize_int(self.buffer[p + 1: p + 5])
         runtime = self.buffer[p + 5]
         command_type = self.buffer[p + 6]
         self.position += 7
-        return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
-        return self.read_command_recursively(number_of_elements_in_payload, return_command)
 
-    def read_command_recursively(self, number_of_elements_in_payload_left, cmd):
-        """
-        Recursively reads a command from the buffer.
+        payload = []
+        for _ in xrange(number_of_elements_in_payload):
+            payload.append(self.read_object(self.buffer[self.position]))
 
-        :param number_of_elements_in_payload_left: Number of elements left to read
-        :param cmd: Command to populate
-        :return: Populated command
-        """
-        if number_of_elements_in_payload_left == 0:
-            return cmd
-        else:
-            p = self.position
-            cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
-            return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
+        return Command(RuntimeName(runtime), CommandType(command_type), payload)
 
     def read_string(self):
         """
@@ -108,130 +108,93 @@ class CommandDeserializer(object):
 
         :return: Read string
         """
+        self._check_buffer(6)
         p = self.position
         string_encoding_mode = StringEncodingMode(self.buffer[p + 1])
         size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
         self.position += 6
+        self._check_buffer(size)
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
 
     def read_int(self):
-        """
-        Reads an integer from the buffer.
-
-        :return: Read integer
-        """
         size = 4
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
 
     def read_bool(self):
-        """
-        Reads a boolean from the buffer.
-
-        :return: Read boolean
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_bool(self.buffer[p:p + size])
 
     def read_float(self):
-        """
-        Reads a float from the buffer.
-
-        :return: Read float
-        """
         size = 4
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
 
     def read_byte(self):
-        """
-        Reads a byte from the buffer.
-
-        :return: Read byte
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_byte(self.buffer[p:p + size])
 
     def read_char(self):
-        """
-        Reads a character from the buffer.
-
-        :return: Read character
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_char(self.buffer[p:p + size])
 
     def read_longlong(self):
-        """
-        Reads a long long from the buffer.
-
-        :return: Read long long
-        """
         size = 8
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
 
     def read_double(self):
-        """
-        Reads a double from the buffer.
-
-        :return: Read double
-        """
         size = 8
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
+
         return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
 
     def read_ullong(self):
-        """
-        Reads an unsigned long long from the buffer.
-
-        :return: Read unsigned long long
-        """
         size = 8
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
 
     def read_uint(self):
-        """
-        Reads an unsigned integer from the buffer.
-
-        :return: Read unsigned integer
-        """
         size = 4
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
 
     def read_none(self):
-        """
-        Reads a None value from the buffer.
-
-        :return: Read None value
-        """
         size = 1
+        self._check_buffer(size + 2)
         self.position += 2
         p = self.position
         self.position += size
-        return TypeDeserializer.deserialize_none(self.buffer[p:p + size]) 
+        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/receiver/Receiver.py

@@ -7,6 +7,10 @@ from javonet.core.protocol.CommandSerializer import CommandSerializer
 from javonet.utils.RuntimeLogger import RuntimeLogger
 from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 from javonet.core.protocol.CommandDeserializer import CommandDeserializer
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 
 
 class Receiver(object):
@@ -18,11 +22,18 @@ class Receiver(object):
         self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, message_byte_array_as_string, messageByteArrayLen):
-        message_byte_array = bytearray(message_byte_array_as_string)
-        response_command = Interpreter().process(message_byte_array)
-        serialized_response = CommandSerializer().serialize(response_command, self.connection_data)
-        response_byte_array = bytearray(serialized_response)
-        return response_byte_array
+        try:
+            message_byte_array = bytearray(message_byte_array_as_string)
+            response_command = Interpreter().process(message_byte_array)
+            serialized_response = CommandSerializer().serialize(response_command, self.connection_data)
+            return bytearray(serialized_response)
+        except Exception as ex:
+            exception_command = ExceptionSerializer.serialize_exception(
+                ex,
+                Command(RuntimeName.python27, CommandType.Exception, [])
+            )
+            serialized_exception = CommandSerializer().serialize(exception_command, self.connection_data)
+            return bytearray(serialized_exception)
 
     def HeartBeat(self, message_byte_array_as_string, messageByteArrayLen):
         message_byte_array = bytearray(message_byte_array_as_string)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/CommandType.py

@@ -63,6 +63,9 @@ class CommandType(object):
     PassDelegate = None
     InvokeDelegate = None
     ConvertType = None
+    AddEventListener = None
+    PluginWrapper = None
+    GetAsyncOperationResult = None
 
     _name_map = {
         0: 'Value',
@@ -106,7 +109,10 @@ class CommandType(object):
         38: 'GetInstanceMethodAsDelegate',
         39: 'PassDelegate',
         40: 'InvokeDelegate',
-        41: 'ConvertType'
+        41: 'ConvertType',
+        42: 'AddEventListener',
+        43: 'PluginWrapper',
+        44: 'GetAsyncOperationResult'
     }
 
 # Initialize values
@@ -151,4 +157,7 @@ CommandType.GetStaticMethodAsDelegate = CommandType(37)
 CommandType.GetInstanceMethodAsDelegate = CommandType(38)
 CommandType.PassDelegate = CommandType(39)
 CommandType.InvokeDelegate = CommandType(40)
-CommandType.ConvertType = CommandType(41) 
+CommandType.ConvertType = CommandType(41)
+CommandType.AddEventListener = CommandType(42)
+CommandType.PluginWrapper = CommandType(43)
+CommandType.GetAsyncOperationResult = CommandType(44)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/exception/ExceptionSerializer.py

@@ -7,10 +7,10 @@ import os
 import sys
 import traceback
 
-from javonet.utils.PythonStringBuilder import PythonStringBuilder
 from javonet.utils.ExceptionType import ExceptionType
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ExceptionSerializer(object):
@@ -36,43 +36,89 @@ class ExceptionSerializer(object):
         :param command: Command that caused the exception
         :return: Command containing the serialized exception
         """
-        exception_command = Command(command.runtime_name, CommandType.Exception, [])
-        
-        # In Python 2 there's no __traceback__, we use sys.exc_info()
-        _, _, tb = sys.exc_info()
-        trace = traceback.extract_tb(tb)
-        exception_message = str(exception)
-        
-        # In Python 2 there's no __cause__, we use the exception type directly
-        exception_name = exception.__class__.__name__
-        
-        stack_classes = PythonStringBuilder()
-        stack_methods = PythonStringBuilder()
-        stack_lines = PythonStringBuilder()
-        stack_files = PythonStringBuilder()
-
-        is_debug = False
-
-        for frame in trace:
-            # In Python 2 extract_tb returns tuples (filename, line number, function name, text)
-            filename, lineno, name, _ = frame
-            if "javonet" not in filename or is_debug:
-                stack_classes.append(ExceptionSerializer.format_class_name_from_file(filename)).append("|")
-                stack_methods.append(name).append("|")
-                stack_lines.append(str(lineno)).append("|")
-                stack_files.append(filename).append("|")
-
-        exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(command))
-        exception_command = exception_command.add_arg_to_payload(exception_name)
-        exception_command = exception_command.add_arg_to_payload(str(exception_message))
-        exception_command = exception_command.add_arg_to_payload(stack_classes.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_methods.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_lines.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_files.__str__())
+        exception_command = Command(RuntimeName.python27, CommandType.Exception, [])
+        stack_classes = []
+        stack_methods = []
+        stack_lines = []
+        stack_files = []
+
+        try:
+            _, _, tb = sys.exc_info()
+            trace = traceback.extract_tb(tb)
+            exception_message = str(exception)
+
+            exception_name = exception.__class__.__name__
+
+            for frame in trace:
+                class_name = ExceptionSerializer.safe_get_class_name(frame)
+                method_name = ExceptionSerializer.safe_get_method_name(frame)
+                file_name = ExceptionSerializer.safe_get_file_name(frame)
+                line = ExceptionSerializer.safe_get_line(frame)
+
+                if "javonet" not in class_name and "reflect" not in class_name:
+                    stack_classes.append(class_name)
+                    stack_methods.append(method_name)
+                    stack_lines.append(str(line))
+                    stack_files.append(file_name)
+
+            stack_classes_str = "|".join(stack_classes)
+            stack_methods_str = "|".join(stack_methods)
+            stack_lines_str = "|".join(stack_lines)
+            stack_files_str = "|".join(stack_files)
+
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(exception_name))
+            exception_command = exception_command.add_arg_to_payload(str(command) if command else "Command is null")
+            exception_command = exception_command.add_arg_to_payload(exception_name)
+            exception_command = exception_command.add_arg_to_payload(str(exception_message))
+            exception_command = exception_command.add_arg_to_payload(stack_classes_str)
+            exception_command = exception_command.add_arg_to_payload(stack_methods_str)
+            exception_command = exception_command.add_arg_to_payload(stack_lines_str)
+            exception_command = exception_command.add_arg_to_payload(stack_files_str)
+
+        except Exception as ex:
+            exception_command = Command(command.runtime_name, CommandType.Exception, [])
+            exception_command = exception_command.add_arg_to_payload(
+                ExceptionSerializer.get_exception_code(ex.__class__.__name__))
+
+            exception_command = exception_command.add_arg_to_payload(str(command) if command else "Command is null")
+            exception_command = exception_command.add_arg_to_payload("Python Exception Serialization Error")
+            exception_command = exception_command.add_arg_to_payload(str(ex))
+            exception_command = exception_command.add_arg_to_payload("ExceptionSerializer")
+            exception_command = exception_command.add_arg_to_payload("serialize_exception")
+            exception_command = exception_command.add_arg_to_payload("undefined")
+            exception_command = exception_command.add_arg_to_payload("ExceptionSerializer.py")
 
         return exception_command
 
+    @staticmethod
+    def safe_get_class_name(frame):
+        try:
+            return ExceptionSerializer.format_class_name_from_file(frame[0])
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_method_name(frame):
+        try:
+            return frame[2] if frame[2] else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_file_name(frame):
+        try:
+            return frame[0] if frame[0] else "undefined"
+        except Exception:
+            return "undefined"
+
+    @staticmethod
+    def safe_get_line(frame):
+        try:
+            return frame[1] if frame[1] >= 0 else 0
+        except Exception:
+            return 0
+
     @staticmethod
     def get_exception_code(exception_name):
         """
@@ -91,4 +137,4 @@ class ExceptionSerializer(object):
         :param filename: File name
         :return: Class name
         """
-        return os.path.splitext((os.path.split(filename)[1]))[0] 
+        return os.path.splitext((os.path.split(filename)[1]))[0]