javonet-nodejs-sdk 2.1.10 → 2.1.12

package/Binaries/Python/Linux/X64/javonet/core/handler/Handler.py

@@ -1,5 +1,3 @@
-import traceback
-
 from javonet.core.handler.AbstractHandler import AbstractHandler
 from javonet.core.handler.CommandHandler.ValueHandler import ValueHandler
 from javonet.core.handler.CommandHandler.LoadLibraryHandler import LoadLibraryHandler
@@ -25,7 +23,7 @@ from javonet.core.handler.CommandHandler.GetEnumValueHandler import GetEnumValue
 
 from javonet.core.handler.HandlerDictionary import handler_dict
 from javonet.core.handler.ReferencesCache import ReferencesCache
-from javonet.core.exception.ExceptionSerializer import ExceptionSerializer
+from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 from javonet.utils.CommandType import CommandType
 from javonet.utils.Command import Command
 

package/Binaries/Python/Linux/X64/javonet/core/interpreter/Interpreter.py

@@ -10,7 +10,7 @@ class Interpreter:
 
     def execute(self, command, connection_type, tcp_address):
         command_serializer = CommandSerializer()
-        serialized_command = command_serializer.encode(command, connection_type, tcp_address)
+        serialized_command = command_serializer.serialize(command, connection_type, tcp_address)
         if command.runtime_name == RuntimeName.python:
             from javonet.core.receiver.Receiver import Receiver
             response = Receiver().SendCommand(serialized_command, len(serialized_command))
@@ -19,13 +19,13 @@ class Interpreter:
             response = PythonTransmitter.send_command(serialized_command)
         command_deserializer = CommandDeserializer(response, len(response))
 
-        return command_deserializer.decode()
+        return command_deserializer.deserialize()
 
     def process(self, byte_array, byte_array_len):
         command_deserializer = CommandDeserializer(byte_array, byte_array_len)
-        received_command = command_deserializer.decode()
+        received_command = command_deserializer.deserialize()
         python_handler = Handler()
         command_serializer = CommandSerializer()
         response_command = python_handler.handle_command(received_command)
-        encoded_response = command_serializer.encode(response_command, 0, "0.0.0.0:0")
+        encoded_response = command_serializer.serialize(response_command, 0, "0.0.0.0:0")
         return encoded_response

package/Binaries/Python/Linux/X64/javonet/core/protocol/CommandDeserializer.py

@@ -21,41 +21,38 @@ class CommandDeserializer:
     def is_at_end(self):
         return self.position == self.buffer_len
 
-    def decode(self):
+    def deserialize(self):
         while not self.is_at_end():
             self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
         return self.command
 
     # def copy_from(self, bytes_to_copy, elements_to_skip):
     #     size = len(bytes_to_copy) - elements_to_skip
-    #     new_byte_array = bytes_to_copy[size]
-    #
-    #
+    #     new_byte_array = bytes_to_copy[size:]
     #     return new_byte_array
 
     def read_object(self, type_num):
         type_value = Type(type_num)
-        if type_value == Type.Command:
-            return self.read_command()
-        elif type_value == Type.JavonetInteger:
-            return self.read_int()
-        elif type_value == Type.JavonetString:
-            return self.read_string()
-        elif type_value == Type.JavonetBoolean:
-            return self.read_bool()
-        elif type_value == Type.JavonetFloat:
-            return self.read_float()
-        elif type_value == Type.JavonetDouble:
-            return self.read_double()
-        else:
-            Exception("Type not supported")
+        switch = {
+            Type.Command: self.read_command,
+            Type.JavonetString: self.read_string,
+            Type.JavonetInteger: self.read_int,
+            Type.JavonetBoolean: self.read_bool,
+            Type.JavonetFloat: self.read_float,
+            Type.JavonetByte: self.read_byte,
+            Type.JavonetChar: self.read_char,
+            Type.JavonetLongLong: self.read_longlong,
+            Type.JavonetDouble: self.read_double,
+            Type.JavonetUnsignedLongLong: self.read_ullong,
+            Type.JavonetUnsignedInteger: self.read_uint,
+        }
+        return switch.get(type_value, lambda: Exception("Type not supported"))()
 
     def read_command(self):
         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)
@@ -68,45 +65,75 @@ class CommandDeserializer:
             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)
 
-    def read_int(self):
-        self.position += 2
-        p = self.position
-        self.position += 4
-        return TypeDeserializer.deserialize_int(self.buffer[p:p + 4])
-
     def read_string(self):
         p = self.position
         string_encoding_mode = StringEncodingMode(self.buffer[p+1])
         size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
         self.position += 6
         p = self.position
-        decoded_string = TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
         self.position += size
-        return decoded_string
+        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
 
-    def read_bool(self):
+    def read_int(self):
+        size = 4
+        self.position += 2
         p = self.position
-        size = self.buffer[p + 1]
+        self.position += size
+        return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
+
+    def read_bool(self):
+        size = 1
         self.position += 2
         p = self.position
-        decoded_bool = TypeDeserializer.deserialize_bool(self.buffer[p:p + size])
         self.position += size
-        return decoded_bool
+        return TypeDeserializer.deserialize_bool(self.buffer[p:p+size])
 
     def read_float(self):
+        size = 4
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
+    
+    def read_byte(self):
+        size = 1
+        self.position += 2
         p = self.position
-        size = self.buffer[p + 1]
+        self.position += size
+        return TypeDeserializer.deserialize_byte(self.buffer[p:p+size])
+    
+    def read_char(self):
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_char(self.buffer[p:p+size])
+
+    def read_longlong(self):
+        size = 8
         self.position += 2
         p = self.position
-        decoded_float = TypeDeserializer.deserialize_float(self.buffer[p:p + size])
         self.position += size
-        return decoded_float
+        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
 
     def read_double(self):
+        size = 8
+        self.position += 2
         p = self.position
-        size = self.buffer[p + 1]
+        self.position += size
+        return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
+
+    def read_ullong(self):
+        size = 8
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
+
+    def read_uint(self):
+        size = 4
         self.position += 2
         p = self.position
-        decoded_double = TypeDeserializer.deserialize_double(self.buffer[p:p + size])
         self.position += size
-        return decoded_double
+        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
+    

package/Binaries/Python/Linux/X64/javonet/core/protocol/CommandSerializer.py

@@ -11,7 +11,7 @@ from javonet.utils.RuntimeName import RuntimeName
 class CommandSerializer:
     byte_buffer = []
 
-    def encode(self, root_command, connection_type, tcp_address=None, runtime_version=0):
+    def serialize(self, root_command, connection_type, tcp_address=None, runtime_version=0):
         queue: Deque[Command] = deque()
         queue.append(root_command)
         self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
@@ -41,19 +41,26 @@ class CommandSerializer:
     @staticmethod
     def serialize_primitive(payload_item):
         if isinstance(payload_item, bool):
-            serialized_bool = TypeSerializer.serialize_bool(payload_item)
-            return serialized_bool
+            return TypeSerializer.serialize_bool(payload_item)
+        
+        elif isinstance(payload_item, bytes):
+            return TypeSerializer.serialize_byte(payload_item)
+        
         elif isinstance(payload_item, int):
-            serialized_int = TypeSerializer.serialize_int(payload_item)
-            return serialized_int
+            if payload_item in range(-2**31, 2**31):
+                return TypeSerializer.serialize_int(payload_item)
+            elif payload_item in range(-2**63, 2**63):
+                return TypeSerializer.serialize_longlong(payload_item)
+            else:
+                return TypeSerializer.serialize_ullong(payload_item)
+            
         elif isinstance(payload_item, float):
-            serialized_float = TypeSerializer.serialize_float(payload_item)
-            return serialized_float
+            return TypeSerializer.serialize_double(payload_item)
+        
         elif isinstance(payload_item, str):
-            serialized_string = TypeSerializer.serialize_string(payload_item)
-            return serialized_string
+                return TypeSerializer.serialize_string(payload_item)
         else:
-            return None
+            raise Exception("Python: Type serialization not supported for type: " + payload_item)
 
     def insert_into_buffer(self, arguments):
         self.byte_buffer = self.byte_buffer + arguments

package/Binaries/Python/Linux/X64/javonet/core/protocol/TypeDeserializer.py

@@ -7,70 +7,54 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 class TypeDeserializer:
 
     @staticmethod
-    def deserialize_int(encoded_int):
-        int_value = struct.unpack("<i", bytearray(encoded_int))[0]
-        return int_value
-
-    @staticmethod
-    def deserialize_unsigned_int(encoded_unsigned_int):
-        unsigned_int_value = struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
-        return unsigned_int_value
-
-    @staticmethod
-    def deserialize_longlong(encoded_longlong):
-        longlong_value = struct.unpack("<q", bytearray(encoded_longlong))[0]
-        return longlong_value
-
-    @staticmethod
-    def deserialize_unsignedlonglong(encoded_unsigned_longlong):
-        unsigned_longlong_value = struct.unpack("<Q", bytearray(encoded_unsigned_longlong[2:]))[0]
-        return unsigned_longlong_value
-
-    @staticmethod
-    def deserialize_double(encoded_double):
-        double_value = struct.unpack("<d", bytearray(encoded_double))[0]
-        return double_value
+    def deserialize_command(command_byte_array):
+        return Command(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
 
     @staticmethod
     def deserialize_string(string_encoding_mode, encoded_string):
-
         if string_encoding_mode == StringEncodingMode.ASCII:
-            string_value = bytearray(encoded_string).decode('ascii')
-            return string_value
+            return bytearray(encoded_string).decode('ascii')
         if string_encoding_mode == StringEncodingMode.UTF8:
-            string_value = bytearray(encoded_string).decode('utf-8')
-            return string_value
+            return bytearray(encoded_string).decode('utf-8')
         if string_encoding_mode == StringEncodingMode.UTF16:
-            string_value = bytearray(encoded_string).decode('utf-16')
-            return string_value
+            return bytearray(encoded_string).decode('utf-16')
         if string_encoding_mode == StringEncodingMode.UTF32:
-            string_value = bytearray(encoded_string).decode('utf-32')
-            return string_value
+            return bytearray(encoded_string).decode('utf-32')
 
         raise IndexError("String encoding mode out of range")
 
-
     @staticmethod
-    def deserialize_float(encoded_float):
-        float_value = struct.unpack("<f", bytearray(encoded_float))[0]
-        return float_value
-
+    def deserialize_int(encoded_int):
+        return struct.unpack("<i", bytearray(encoded_int))[0]
+    
     @staticmethod
     def deserialize_bool(encoded_bool):
-        bool_value = struct.unpack("?", bytearray(encoded_bool))[0]
-        return bool_value
+        return struct.unpack("<?", bytearray(encoded_bool))[0]
+    
+    @staticmethod
+    def deserialize_float(encoded_float):
+        return struct.unpack("<f", bytearray(encoded_float))[0]
 
+    @staticmethod
+    def deserialize_byte(encoded_byte):
+        return struct.unpack("<B", bytearray(encoded_byte))[0]
+    
     @staticmethod
     def deserialize_char(encoded_char):
-        char_value = struct.unpack("<c", bytearray(encoded_char))[0]
-        return char_value
+        return struct.unpack("<b", bytearray(encoded_char))[0]
 
     @staticmethod
-    def deserialize_bytes(encoded_bytes):
-        bytes_value = struct.unpack("<c", bytearray(encoded_bytes))[0]
-        return bytes_value
+    def deserialize_longlong(encoded_longlong):
+        return struct.unpack("<q", bytearray(encoded_longlong))[0]
 
     @staticmethod
-    def deserialize_command(command_byte_array):
-        command = Command(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
-        return command
+    def deserialize_double(encoded_double):
+        return struct.unpack("<d", bytearray(encoded_double))[0]
+
+    @staticmethod
+    def deserialize_ullong(encoded_unsigned_longlong):
+        return struct.unpack("<Q", bytearray(encoded_unsigned_longlong))[0]
+
+    @staticmethod
+    def deserialize_uint(encoded_unsigned_int):
+        return struct.unpack("<I", bytearray(encoded_unsigned_int))[0]

package/Binaries/Python/Linux/X64/javonet/core/protocol/TypeSerializer.py

@@ -5,22 +5,47 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeSerializer:
+    
+    @staticmethod
+    def serialize_command(command):
+        length = list(bytearray(struct.pack("<i", len(command.payload))))
+        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]
 
     @staticmethod
-    def serialize_type(type_value):
-        return TypeSerializer.serialize_int(type_value)
+    def serialize_string(string_value):
+        encoded_string_list = list(bytearray(string_value, 'utf-8'))
+        length = list(bytearray(struct.pack("<i", len(encoded_string_list))))
+        return [Type.JavonetString.value] + [StringEncodingMode.UTF8.value] + length + encoded_string_list
 
     @staticmethod
     def serialize_int(int_value):
         encoded_int_list = list(bytearray(struct.pack("<i", int_value)))
         length = len(encoded_int_list)
         return [Type.JavonetInteger.value, length] + encoded_int_list
+    
+    @staticmethod
+    def serialize_bool(bool_value):
+        encoded_bool_list = list(bytearray(struct.pack("?", bool_value)))
+        length = len(encoded_bool_list)
+        return [Type.JavonetBoolean.value, length] + encoded_bool_list
+    
+    @staticmethod
+    def serialize_float(float_value):
+        encoded_float_list = list(bytearray(struct.pack("<f", float_value)))
+        length = len(encoded_float_list)
+        return [Type.JavonetFloat.value, length] + encoded_float_list
 
     @staticmethod
-    def serialize_unsigned_int(unsigned_int_value):
-        encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
-        length = len(encoded_unsigned_int_list)
-        return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list
+    def serialize_byte(bytes_value):
+        encoded_byte_list = list(bytearray(struct.pack("<B", bytes_value)))
+        length = len(encoded_byte_list)
+        return [Type.JavonetByte.value, length] + encoded_byte_list
+    
+    @staticmethod
+    def serialize_char(char_value):
+        encoded_char_list = list(bytearray(struct.pack("<b", char_value)))
+        length = len(encoded_char_list)
+        return [Type.JavonetChar.value, length] + encoded_char_list
 
     @staticmethod
     def serialize_longlong(longlong_value):
@@ -28,12 +53,6 @@ class TypeSerializer:
         length = len(encoded_longlong_list)
         return [Type.JavonetLongLong.value, length] + encoded_longlong_list
 
-    @staticmethod
-    def serialize_unsignedlonglong(unsigned_longlong_value):
-        encoded_unsignedlonglong_list = list(bytearray(struct.pack("<q", unsigned_longlong_value)))
-        length = len(encoded_unsignedlonglong_list)
-        return [Type.JavonetUnsignedLongLong.value, length] + encoded_unsignedlonglong_list
-
     @staticmethod
     def serialize_double(double_value):
         encoded_double_list = list(bytearray(struct.pack("<d", double_value)))
@@ -41,36 +60,13 @@ class TypeSerializer:
         return [Type.JavonetDouble.value, length] + encoded_double_list
 
     @staticmethod
-    def serialize_string(string_value):
-        encoded_string_list = list(bytearray(string_value, 'utf-8'))
-        length = list(bytearray(struct.pack("<i", len(encoded_string_list))))
-        return [Type.JavonetString.value] + [StringEncodingMode.UTF8.value] + length + encoded_string_list
-
-    @staticmethod
-    def serialize_float(float_value):
-        encoded_float_list = list(bytearray(struct.pack("<f", float_value)))
-        length = len(encoded_float_list)
-        return [Type.JavonetFloat.value, length] + encoded_float_list
-
-    @staticmethod
-    def serialize_bool(bool_value):
-        encoded_bool_list = list(bytearray(struct.pack("?", bool_value)))
-        length = len(encoded_bool_list)
-        return [Type.JavonetBoolean.value, length] + encoded_bool_list
-
-    @staticmethod
-    def serialize_char(char_value):
-        encoded_char_list = list(bytearray(struct.pack("<c", char_value)))
-        length = len(encoded_char_list)
-        return [Type.JavonetChar.value, length] + encoded_char_list
-
-    @staticmethod
-    def serialize_bytes(bytes_value):
-        encoded_bytes_list = list(bytearray(struct.pack("<s", bytes_value)))
-        length = len(encoded_bytes_list)
-        return [Type.JavonetBytes.value, length] + encoded_bytes_list
+    def serialize_ullong(unsigned_longlong_value):
+        encoded_unsignedlonglong_list = list(bytearray(struct.pack("<Q", unsigned_longlong_value)))
+        length = len(encoded_unsignedlonglong_list)
+        return [Type.JavonetUnsignedLongLong.value, length] + encoded_unsignedlonglong_list
 
     @staticmethod
-    def serialize_command(command):
-        length = list(bytearray(struct.pack("<i", len(command.payload))))
-        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]
+    def serialize_uint(unsigned_int_value):
+        encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
+        length = len(encoded_unsigned_int_list)
+        return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list

package/Binaries/Python/Linux/X64/javonet/utils/CommandType.py

@@ -30,7 +30,9 @@ class CommandType(Enum):
     SetInstanceField = 25
     InvokeGenericStaticMethod = 26
     InvokeGenericMethod = 27
-    CreateGenericClassInstance = 28
-    GetEnumItem = 29
-    GetEnumName = 30
-    GetEnumValue = 31
+    GetEnumItem = 28
+    GetEnumName = 29
+    GetEnumValue = 30
+    AsRef = 31
+    AsOut = 32
+    GetRefValue = 33

package/Binaries/Python/Linux/X64/javonet/utils/Type.py

@@ -7,11 +7,10 @@ class Type(Enum):
     JavonetInteger = 2
     JavonetBoolean = 3
     JavonetFloat = 4
-    JavonetBytes = 5
+    JavonetByte = 5
     JavonetChar = 6
     JavonetLongLong = 7
     JavonetDouble = 8
     JavonetUnsignedLongLong = 9
     JavonetUnsignedInteger = 10
     JavonetNoneType = 11
-

package/Binaries/Python/{Windows/X64/javonet/core → Linux/X64/javonet/utils}/exception/ExceptionThrower.py

@@ -1,48 +1,63 @@
-import re
-
-from javonet.core.exception.JavonetException import JavonetException
-from javonet.utils.Command import Command
-from javonet.utils.ExceptionType import ExceptionType
-
-
-class ExceptionThrower:
-
-    @staticmethod
-    def throw_exception(command_exception: Command):
-        original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
-        javonet_stack_command = command_exception.get_payload()[1]
-        exception_name = command_exception.get_payload()[2]
-        exception_message = command_exception.get_payload()[3]
-
-        stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(
-            command_exception.get_payload()[4],
-            command_exception.get_payload()[5],
-            command_exception.get_payload()[6],
-            command_exception.get_payload()[7])
-        traceback_str = ""
-
-        for i in range(len(stack_classes)):
-            if i < len(stack_files) and stack_files[i]:
-                traceback_str += "File \"{}\"".format(stack_files[i])
-            if i < len(stack_lines) and stack_lines[i]:
-                traceback_str += ", line {}".format(stack_lines[i])
-            if i < len(stack_methods) and stack_methods[i]:
-                traceback_str += ", in {}".format(stack_methods[i])
-            traceback_str += "\n"
-            if i < len(stack_classes) and stack_classes[i]:
-                traceback_str += "    {}\n".format(stack_classes[i])
-
-        return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
-
-    @staticmethod
-    def raise_exception(original_exception, exception_message, traceback_str):
-        return JavonetException(str(original_exception), exception_message, traceback_str)
-
-    @staticmethod
-    def get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
-        stack_classes = re.split("\\|", stack_trace_classes)
-        stack_methods = re.split("\\|", stack_trace_methods)
-        stack_lines = re.split("\\|", stack_trace_lines)
-        stack_files = re.split("\\|", stack_trace_files)
-
-        return [stack_classes, stack_methods, stack_lines, stack_files]
+import re
+
+from javonet.utils.exception.JavonetException import JavonetException
+from javonet.utils.Command import Command
+from javonet.utils.ExceptionType import ExceptionType
+
+
+class ExceptionThrower:
+
+    @staticmethod
+    def throw_exception(command_exception: Command):
+        stack_classes, stack_methods, stack_lines, stack_files = "", "", "", ""
+        exception_message = "Python Exception with empty message"
+        exception_name = "Python exception"
+        javonet_stack_command = ""
+        traceback_str = ""
+
+        exception_payload_len = len(command_exception.payload)
+        if exception_payload_len >=8:
+            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(
+                command_exception.get_payload()[4],
+                command_exception.get_payload()[5],
+                command_exception.get_payload()[6],
+                command_exception.get_payload()[7])
+
+        if exception_payload_len >= 4:
+            exception_message = command_exception.get_payload()[3]
+
+        if exception_payload_len >= 3:
+            exception_name = command_exception.get_payload()[2]
+
+        if exception_payload_len >= 2:
+            javonet_stack_command = command_exception.get_payload()[1]
+
+        if exception_payload_len >= 1:
+            original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
+
+
+        for i in range(len(stack_classes)):
+            if i < len(stack_files) and stack_files[i]:
+                traceback_str += "File \"{}\"".format(stack_files[i])
+            if i < len(stack_lines) and stack_lines[i]:
+                traceback_str += ", line {}".format(stack_lines[i])
+            if i < len(stack_methods) and stack_methods[i]:
+                traceback_str += ", in {}".format(stack_methods[i])
+            traceback_str += "\n"
+            if i < len(stack_classes) and stack_classes[i]:
+                traceback_str += "    {}\n".format(stack_classes[i])
+
+        return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
+
+    @staticmethod
+    def raise_exception(original_exception, exception_message, traceback_str):
+        return JavonetException(str(original_exception), exception_message, traceback_str)
+
+    @staticmethod
+    def get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
+        stack_classes = re.split("\\|", stack_trace_classes)
+        stack_methods = re.split("\\|", stack_trace_methods)
+        stack_lines = re.split("\\|", stack_trace_lines)
+        stack_files = re.split("\\|", stack_trace_files)
+
+        return [stack_classes, stack_methods, stack_lines, stack_files]

package/Binaries/Python/Linux/X64/javonet/{core → utils}/exception/JavonetException.py

@@ -1,5 +1,3 @@
-
-
 class JavonetException(Exception):
     def __init__(self, name, message, traceback_str):
         self.name = name

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/shared/SharedTypeHandler.py

@@ -16,7 +16,7 @@ class SharedTypeHandler(AbstractGeneratorHandler):
         if analyzed_object == "float":
             return Type.JavonetFloat.value
         if analyzed_object == "bytes":
-            return Type.JavonetBytes.value
+            return Type.JavonetByte.value
         if analyzed_object == "double":
             return Type.JavonetDouble.value
         if analyzed_object == "char":
@@ -36,7 +36,7 @@ class SharedTypeHandler(AbstractGeneratorHandler):
             existing_string_builder.append("bool")
         if used_object is Type.JavonetFloat.value:
             existing_string_builder.append("float")
-        if used_object is Type.JavonetBytes.value:
+        if used_object is Type.JavonetByte.value:
             existing_string_builder.append("bytes")
         if used_object is Type.JavonetChar.value:
             existing_string_builder.append("int")

package/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ArrayGetItemHandler.py

@@ -11,14 +11,15 @@ class ArrayGetItemHandler(AbstractCommandHandler):
                 raise Exception("ArrayGetItemHandler parameters mismatch!")
 
             array = command.payload[0]
-            indexes = command.payload[1:]
-            if len(indexes) == 1:
-                return array[indexes[0]]
+            if isinstance(command.payload[1], list):
+                indexes = command.payload[1]
             else:
-                array_copy = array.copy()
-                for i in indexes:
-                    array_copy = array_copy[i]
-                return array_copy
+                indexes = command.payload[1:]
+
+            array_copy = array.copy()
+            for i in indexes:
+                array_copy = array_copy[i]
+            return array_copy
 
         except Exception as e:
             exc_type, exc_value = type(e), e