javonet-ruby-sdk 2.6.10 → 2.6.12

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

@@ -7,194 +7,151 @@ 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.StringEncodingMode import StringEncodingMode
 from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class CommandDeserializer(object):
     """
-    Class responsible for command deserialization.
+    Static class for deserializing commands from byte arrays.
     """
-    position = 0
-    buffer = []
-    command = 0
-    buffer_len = 0
-
-    def __init__(self, buffer):
-        """
-        Initializes a new command deserializer.
-
-        :param buffer: Buffer with data to deserialize
-        """
-        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
-
-    def is_at_end(self):
-        """
-        Checks if the end of buffer has been reached.
-
-        :return: True if end of buffer is reached, False otherwise
-        """
-        return self.position >= self.buffer_len
-
-    def deserialize(self):
-        """
-        Deserializes a command.
 
-        :return: Deserialized command
+    @staticmethod
+    def deserialize(buffer):
         """
-        while not self.is_at_end():
-            self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
-        return self.command
+        Deserialize a command from a byte array.
 
-    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.
-
-        :param type_num: Type number
-        :return: Read object
-        """
-        type_value = Type(type_num)
-        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,
-            Type.JavonetNoneType: self.read_none
-        }
-        func = switch.get(type_value)
-        if func is None:
-            raise ValueError("Type not supported: " + str(type_num))
-        return func()
-
-    def read_command(self):
-        """
-        Reads a command from the buffer.
-
-        :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
-
-        payload = []
-        for _ in xrange(number_of_elements_in_payload):
-            payload.append(self.read_object(self.buffer[self.position]))
-
-        return Command(RuntimeName(runtime), CommandType(command_type), payload)
-
-    def read_string(self):
-        """
-        Reads a string from the buffer.
+        Args:
+            buffer: The byte array containing the serialized command.
 
-        :return: Read string
+        Returns:
+            Command: The deserialized command.
         """
-        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):
-        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):
-        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):
-        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):
-        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):
-        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):
-        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):
-        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):
-        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):
-        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):
-        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])
+        buffer_len = len(buffer)
+        command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
+        position = 11
+
+        # Use a list to hold position (mutable reference for nested functions)
+        pos_ref = [position]
+
+        def is_at_end():
+            return pos_ref[0] == buffer_len
+
+        def read_object(type_num):
+            type_value = Type(type_num)
+            switch = {
+                Type.Command: read_command,
+                Type.JavonetString: read_string,
+                Type.JavonetInteger: read_int,
+                Type.JavonetBoolean: read_bool,
+                Type.JavonetFloat: read_float,
+                Type.JavonetByte: read_byte,
+                Type.JavonetChar: read_char,
+                Type.JavonetLongLong: read_longlong,
+                Type.JavonetDouble: read_double,
+                Type.JavonetUnsignedLongLong: read_ullong,
+                Type.JavonetUnsignedInteger: read_uint,
+                Type.JavonetNoneType: read_none
+            }
+            func = switch.get(type_value)
+            if func is None:
+                raise Exception("Type not supported")
+            return func()
+
+        def read_command():
+            p = pos_ref[0]
+            number_of_elements_in_payload = TypeDeserializer.deserialize_int(buffer[p + 1: p + 5])
+            runtime = buffer[p + 5]
+            command_type = buffer[p + 6]
+            pos_ref[0] += 7
+
+            payload = [
+                read_object(buffer[pos_ref[0]])
+                for _ in range(number_of_elements_in_payload)
+            ]
+            return Command(RuntimeName(runtime), CommandType(command_type), payload)
+
+        def read_string():
+            p = pos_ref[0]
+            string_encoding_mode = StringEncodingMode(buffer[p + 1])
+            size = TypeDeserializer.deserialize_int(buffer[p + 2:p + 6])
+            pos_ref[0] += 6
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_string(string_encoding_mode, buffer[p:p + size])
+
+        def read_int():
+            size = 4
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_int(buffer[p:p + size])
+
+        def read_bool():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_bool(buffer[p:p + size])
+
+        def read_float():
+            size = 4
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_float(buffer[p:p + size])
+
+        def read_byte():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_byte(buffer[p:p + size])
+
+        def read_char():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_char(buffer[p:p + size])
+
+        def read_longlong():
+            size = 8
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_longlong(buffer[p:p + size])
+
+        def read_double():
+            size = 8
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_double(buffer[p:p + size])
+
+        def read_ullong():
+            size = 8
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_ullong(buffer[p:p + size])
+
+        def read_uint():
+            size = 4
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_uint(buffer[p:p + size])
+
+        def read_none():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_none(buffer[p:p + size])
+
+        # Main deserialization loop
+        while not is_at_end():
+            command = command.add_arg_to_payload(read_object(buffer[pos_ref[0]]))
+
+        return command

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

@@ -3,59 +3,63 @@
 The CommandSerializer module implements command serialization.
 """
 
+import io
+
 from javonet.core.protocol.TypeSerializer import TypeSerializer
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.connectionData.IConnectionData import IConnectionData
 from javonet.utils.TypesHandler import TypesHandler
-from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
 
 class CommandSerializer(object):
     """
     Class responsible for command serialization.
     """
-    buffer = []
 
-    def serialize(self, root_command, connection_data, runtime_version=0):
+    @staticmethod
+    def serialize(root_command, connection_data, runtime_version=0):
         """
         Serializes a command.
 
         :param root_command: Command to serialize
         :param connection_data: Connection data
         :param runtime_version: Runtime version
-        :return: Serialized command
+        :return: Serialized command as bytearray
         """
-        self.buffer = []  # Reset buffer for each serialization
-        self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
-        self.insert_into_buffer(connection_data.serialize_connection_data())
-        self.insert_into_buffer([RuntimeName.python27.value, root_command.command_type.value])
-        self.serialize_recursively(root_command)
-        return self.buffer
-
-    def serialize_recursively(self, command):
+        ms = io.BytesIO()
+
+        ms.write(bytearray([root_command.runtime_name.value, runtime_version]))
+
+        if connection_data is not None:
+            ms.write(bytearray(connection_data.serialize_connection_data()))
+        else:
+            ms.write(bytearray([0, 0, 0, 0, 0, 0, 0]))
+
+        ms.write(bytearray([RuntimeName.python27.value, root_command.command_type.value]))
+
+        CommandSerializer.serialize_recursively(root_command, ms)
+
+        return list(bytearray(ms.getvalue()))
+
+    @staticmethod
+    def serialize_recursively(command, ms):
         """
         Serializes a command recursively.
 
         :param command: Command to serialize
+        :param ms: BytesIO buffer to write to
         """
         for item in command.get_payload():
             if isinstance(item, Command):
-                self.insert_into_buffer(TypeSerializer.serialize_command(item))
-                self.serialize_recursively(item)
+                ms.write(bytearray(TypeSerializer.serialize_command(item)))
+                CommandSerializer.serialize_recursively(item, ms)
             elif TypesHandler.is_primitive_or_none(item):
-                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
+                ms.write(bytearray(TypeSerializer.serialize_primitive(item)))
             else:
                 cached_reference = ReferencesCache().cache_reference(item)
-                ref_command = Command(RuntimeName.python, CommandType.Reference, cached_reference)
-                self.serialize_recursively(ref_command)
-
-        return
-
-    def insert_into_buffer(self, arguments):
-        """
-        Inserts arguments into the buffer.
-
-        :type arguments: list
-        """
-        self.buffer = self.buffer + arguments 
+                ref_command = Command(RuntimeName.python27, CommandType.Reference, cached_reference)
+                ms.write(bytearray(TypeSerializer.serialize_command(ref_command)))
+                CommandSerializer.serialize_recursively(ref_command, ms)

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

@@ -6,7 +6,6 @@ from javonet.core.interpreter.Interpreter import Interpreter
 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
@@ -18,29 +17,31 @@ class Receiver(object):
     Class implementing the message receiver.
     """
 
-    def __init__(self):
-        self.connection_data = InMemoryConnectionData()
-
-    def SendCommand(self, message_byte_array_as_string, messageByteArrayLen):
+    @staticmethod
+    def SendCommand(message_byte_array_as_string):
         try:
+            connection_data = InMemoryConnectionData()
             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_command = Interpreter.process(message_byte_array)
+            serialized_response = CommandSerializer.serialize(response_command, connection_data)
             return bytearray(serialized_response)
         except Exception as ex:
+            connection_data = InMemoryConnectionData()
             exception_command = ExceptionSerializer.serialize_exception(
                 ex,
                 Command(RuntimeName.python27, CommandType.Exception, [])
             )
-            serialized_exception = CommandSerializer().serialize(exception_command, self.connection_data)
+            serialized_exception = CommandSerializer.serialize(exception_command, connection_data)
             return bytearray(serialized_exception)
 
-    def HeartBeat(self, message_byte_array_as_string, messageByteArrayLen):
+    @staticmethod
+    def HeartBeat(message_byte_array_as_string):
         message_byte_array = bytearray(message_byte_array_as_string)
         response_byte_array = bytearray(2)
         response_byte_array[0] = message_byte_array[11]
         response_byte_array[1] = message_byte_array[12] - 2
         return response_byte_array
 
-    def GetRuntimeInfo(self):
+    @staticmethod
+    def GetRuntimeInfo():
         return RuntimeLogger().get_runtime_info()

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

@@ -5,7 +5,6 @@ The Command class represents a command sent to the Javonet runtime environment.
 
 from javonet.utils.CommandType import CommandType
 
-
 class Command(object):
 
     def __init__(self, runtime_name, command_type, payload):
@@ -14,11 +13,26 @@ class Command(object):
 
         :param runtime_name: Runtime environment name
         :param command_type: Command type
-        :param payload: Command payload
+        :param payload: Command payload (list, tuple, single value, or None)
+                        If not provided, creates empty list.
+                        If None is explicitly passed, creates [None].
         """
         self.runtime_name = runtime_name
         self.command_type = command_type
-        self.payload = payload
+        
+        if isinstance(payload, list) and len(payload) == 0:
+            # Payload is empty - create empty list
+            self.payload = []
+        elif payload is None:
+            # None explicitly passed - wrap in list
+            self.payload = [None]
+        elif isinstance(payload, (list, tuple)):
+            # Convert to list if tuple, reuse list directly
+            # None values in the payload are preserved
+            self.payload = list(payload) if isinstance(payload, tuple) else payload
+        else:
+            # Single item - wrap in list
+            self.payload = [payload]
 
     def get_payload(self):
         """
@@ -37,7 +51,7 @@ class Command(object):
         :param runtime_name: Runtime environment name
         :return: New response command
         """
-        return Command(runtime_name, CommandType.Value, [response])
+        return Command(runtime_name, CommandType.Value, response)
 
     @staticmethod
     def create_reference(guid, runtime_name):
@@ -48,7 +62,7 @@ class Command(object):
         :param runtime_name: Runtime environment name
         :return: New reference command
         """
-        return Command(runtime_name, CommandType.Reference, [guid])
+        return Command(runtime_name, CommandType.Reference, guid)
 
     @staticmethod
     def create_array_response(array, runtime_name):
@@ -61,39 +75,64 @@ class Command(object):
         """
         return Command(runtime_name, CommandType.Array, array)
 
-    def drop_first_payload_argument(self):
+    def drop_first_payload_arg(self):
         """
         Removes the first argument from the payload.
 
         :return: New command without the first argument
         """
-        payload_args = []
-        payload_args.extend(self.payload)
-        if len(payload_args) != 0:
-            payload_args.pop(0)
-        return Command(self.runtime_name, self.command_type, payload_args)
+        if len(self.payload) <= 1:
+            return Command(self.runtime_name, self.command_type, [])
+        
+        new_length = len(self.payload) - 1
+        new_payload = [None] * new_length
+        
+        # Copy from index 1 to end
+        for i in xrange(new_length):
+            new_payload[i] = self.payload[i + 1]
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
-    def add_arg_to_payload(self, argument):
+    def add_arg_to_payload(self, arg):
         """
         Adds an argument to the payload.
 
-        :param argument: Argument to add
+        :param arg: Argument to add
         :return: New command with the added argument
         """
-        merged_payload = self.payload + [argument]
-        return Command(self.runtime_name, self.command_type, merged_payload)
+        old_length = len(self.payload)
+        new_payload = [None] * (old_length + 1)
+        
+        # Copy existing payload
+        for i in xrange(old_length):
+            new_payload[i] = self.payload[i]
+        
+        # Add new argument at the end
+        new_payload[old_length] = arg
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
-    def prepend_arg_to_payload(self, current_command):
+    def prepend_arg_to_payload(self, arg_command):
         """
         Adds an argument to the beginning of the payload.
 
-        :param current_command: Current command
+        :param arg_command: Command to prepend
         :return: New command with the argument added at the beginning
         """
-        if current_command is None:
-            return Command(self.runtime_name, self.command_type, self.payload)
-        else:
-            return Command(self.runtime_name, self.command_type, [current_command] + self.payload)
+        if arg_command is None:
+            return self
+        
+        old_length = len(self.payload)
+        new_payload = [None] * (old_length + 1)
+        
+        # Put new element at the front
+        new_payload[0] = arg_command
+        
+        # Copy existing payload starting from index 1
+        for i in xrange(old_length):
+            new_payload[i + 1] = self.payload[i]
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
     def to_string(self):
         """
@@ -101,8 +140,29 @@ class Command(object):
 
         :return: Text representation of the command
         """
-        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
-            self.command_type) + ' Payload: ' + str(self.payload)
+        try:
+            sb = []
+            sb.append("RuntimeName ")
+            sb.append(str(self.runtime_name))
+            sb.append(" ")
+            sb.append("CommandType ")
+            sb.append(str(self.command_type))
+            sb.append(" ")
+            sb.append("Payload ")
+            
+            payload = self.payload
+            payload_len = len(payload)
+            
+            for i in xrange(payload_len):
+                item = payload[i]
+                sb.append(str(item) if item is not None else "null")
+                
+                if i < payload_len - 1:
+                    sb.append(" ")
+            
+            return ''.join(sb)
+        except Exception as ex:
+            return "Error while converting command to string:" + str(ex)
 
     def __eq__(self, other):
         """
@@ -137,8 +197,13 @@ class Command(object):
         
         # Compare each payload item
         for i in range(len(self.payload)):
+            # Handle None values explicitly
+            if self.payload[i] is None and other.payload[i] is None:
+                continue
+            elif self.payload[i] is None or other.payload[i] is None:
+                return False
             # For simple types
-            if self.payload[i] != other.payload[i]:
+            elif self.payload[i] != other.payload[i]:
                 return False
                 
         return True

data/lib/javonet-ruby-sdk/Binaries/version.txt

@@ -1 +1 @@
-2.6.10
+2.6.12