javonet-ruby-sdk 2.6.8 → 2.6.11

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/Handler.py

@@ -47,6 +47,8 @@ from javonet.core.handler.GetAsyncOperationResultHandler import GetAsyncOperatio
 from javonet.core.handler.GetKwargHandler import GetKwargHandler
 from javonet.core.handler.GetResultTypeHandler import GetResultTypeHandler
 from javonet.core.handler.GetGlobalFieldHandler import GetGlobalFieldHandler
+from javonet.core.handler.RegisterForUpdateHandler import RegisterForUpdateHandler
+from javonet.core.handler.ValueForUpdateHandler import ValueForUpdateHandler
 
 
 from javonet.core.handler.HandlerDictionary import handler_dict
@@ -58,65 +60,108 @@ from javonet.utils.Command import Command
 
 
 class Handler(AbstractHandler):
+    _initialized = False
+
+    @staticmethod
+    def _initialize():
+        """Initialize the handler dictionary. Should be called once."""
+        if not Handler._initialized:
+            handler_dict[CommandType.Value] = ValueHandler()
+            handler_dict[CommandType.LoadLibrary] = LoadLibraryHandler()
+            handler_dict[CommandType.InvokeStaticMethod] = InvokeStaticMethodHandler()
+            handler_dict[CommandType.GetStaticField] = GetStaticFieldHandler()
+            handler_dict[CommandType.SetStaticField] = SetStaticFieldHandler()
+            handler_dict[CommandType.CreateClassInstance] = CreateClassInstanceHandler()
+            handler_dict[CommandType.GetType] = GetTypeHandler()
+            handler_dict[CommandType.Reference] = ResolveInstanceHandler()
+            handler_dict[CommandType.GetModule] = GetModuleHandler()
+            handler_dict[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodHandler()
+            handler_dict[CommandType.Exception] = ExceptionHandler()
+            handler_dict[CommandType.HeartBeat] = HeartBeatHandler()
+            handler_dict[CommandType.Cast] = CastingHandler()
+            handler_dict[CommandType.GetInstanceField] = GetInstanceFieldHandler()
+            handler_dict[CommandType.Optimize] = OptimizeHandler()
+            handler_dict[CommandType.GenerateLib] = GenerateLibHandler()
+            handler_dict[CommandType.InvokeGlobalFunction] = InvokeGlobalFunctionHandler()
+            handler_dict[CommandType.DestructReference] = DestructReferenceHandler()
+            handler_dict[CommandType.ArrayReference] = ArrayReferenceHandler()
+            handler_dict[CommandType.ArrayGetItem] = ArrayGetItemHandler()
+            handler_dict[CommandType.ArrayGetSize] = ArrayGetSizeHandler()
+            handler_dict[CommandType.ArrayGetRank] = ArrayGetRankHandler()
+            handler_dict[CommandType.ArraySetItem] = ArraySetItemHandler()
+            handler_dict[CommandType.Array] = ArrayHandler()
+            handler_dict[CommandType.RetrieveArray] = RetrieveArrayHandler()
+            handler_dict[CommandType.SetInstanceField] = SetInstanceFieldHandler()
+            handler_dict[CommandType.InvokeGenericStaticMethod] = InvokeGenericStaticMethodHandler()
+            handler_dict[CommandType.InvokeGenericMethod] = InvokeGenericMethodHandler()
+            handler_dict[CommandType.GetEnumItem] = GetEnumItemHandler()
+            handler_dict[CommandType.GetEnumName] = GetEnumNameHandler()
+            handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
+            handler_dict[CommandType.AsRef] = AsRefHandler()
+            handler_dict[CommandType.AsOut] = AsOutHandler()
+            handler_dict[CommandType.GetRefValue] = GetRefValueHandler()
+            handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
+            handler_dict[CommandType.EnableType] = EnableTypeHandler()
+            handler_dict[CommandType.CreateNull] = CreateNullHandler()
+            handler_dict[CommandType.GetStaticMethodAsDelegate] = GetStaticMethodAsDelegateHandler()
+            handler_dict[CommandType.GetInstanceMethodAsDelegate] = GetInstanceMethodAsDelegateHandler()
+            handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
+            handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
+            handler_dict[CommandType.ConvertType] = ConvertTypeHandler()
+            handler_dict[CommandType.AddEventListener] = AddEventListenerHandler()
+            handler_dict[CommandType.PluginWrapper] = PluginWrapperHandler()
+            handler_dict[CommandType.GetAsyncOperationResult] = GetAsyncOperationResultHandler()
+            handler_dict[CommandType.AsKwargs] = GetKwargHandler()
+            handler_dict[CommandType.GetResultType] = GetResultTypeHandler()
+            handler_dict[CommandType.GetGlobalField] = GetGlobalFieldHandler()
+            handler_dict[CommandType.RegisterForUpdate] = RegisterForUpdateHandler()
+            handler_dict[CommandType.ValueForUpdate] = ValueForUpdateHandler()
+            Handler._initialized = True
 
     def __init__(self):
-        handler_dict[CommandType.Value] = ValueHandler()
-        handler_dict[CommandType.LoadLibrary] = LoadLibraryHandler()
-        handler_dict[CommandType.InvokeStaticMethod] = InvokeStaticMethodHandler()
-        handler_dict[CommandType.GetStaticField] = GetStaticFieldHandler()
-        handler_dict[CommandType.SetStaticField] = SetStaticFieldHandler()
-        handler_dict[CommandType.CreateClassInstance] = CreateClassInstanceHandler()
-        handler_dict[CommandType.GetType] = GetTypeHandler()
-        handler_dict[CommandType.Reference] = ResolveInstanceHandler()
-        handler_dict[CommandType.GetModule] = GetModuleHandler()
-        handler_dict[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodHandler()
-        handler_dict[CommandType.Exception] = ExceptionHandler()
-        handler_dict[CommandType.HeartBeat] = HeartBeatHandler()
-        handler_dict[CommandType.Cast] = CastingHandler()
-        handler_dict[CommandType.GetInstanceField] = GetInstanceFieldHandler()
-        handler_dict[CommandType.Optimize] = OptimizeHandler()
-        handler_dict[CommandType.GenerateLib] = GenerateLibHandler()
-        handler_dict[CommandType.InvokeGlobalFunction] = InvokeGlobalFunctionHandler()
-        handler_dict[CommandType.DestructReference] = DestructReferenceHandler()
-        handler_dict[CommandType.ArrayReference] = ArrayReferenceHandler()
-        handler_dict[CommandType.ArrayGetItem] = ArrayGetItemHandler()
-        handler_dict[CommandType.ArrayGetSize] = ArrayGetSizeHandler()
-        handler_dict[CommandType.ArrayGetRank] = ArrayGetRankHandler()
-        handler_dict[CommandType.ArraySetItem] = ArraySetItemHandler()
-        handler_dict[CommandType.Array] = ArrayHandler()
-        handler_dict[CommandType.RetrieveArray] = RetrieveArrayHandler()
-        handler_dict[CommandType.SetInstanceField] = SetInstanceFieldHandler()
-        handler_dict[CommandType.InvokeGenericStaticMethod] = InvokeGenericStaticMethodHandler()
-        handler_dict[CommandType.InvokeGenericMethod] = InvokeGenericMethodHandler()
-        handler_dict[CommandType.GetEnumItem] = GetEnumItemHandler()
-        handler_dict[CommandType.GetEnumName] = GetEnumNameHandler()
-        handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
-        handler_dict[CommandType.AsRef] = AsRefHandler()
-        handler_dict[CommandType.AsOut] = AsOutHandler()
-        handler_dict[CommandType.GetRefValue] = GetRefValueHandler()
-        handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
-        handler_dict[CommandType.EnableType] = EnableTypeHandler()
-        handler_dict[CommandType.CreateNull] = CreateNullHandler()
-        handler_dict[CommandType.GetStaticMethodAsDelegate] = GetStaticMethodAsDelegateHandler()
-        handler_dict[CommandType.GetInstanceMethodAsDelegate] = GetInstanceMethodAsDelegateHandler()
-        handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
-        handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
-        handler_dict[CommandType.ConvertType] = ConvertTypeHandler()
-        handler_dict[CommandType.AddEventListener] = AddEventListenerHandler()
-        handler_dict[CommandType.PluginWrapper] = PluginWrapperHandler()
-        handler_dict[CommandType.GetAsyncOperationResult] = GetAsyncOperationResultHandler()
-        handler_dict[CommandType.AsKwargs] = GetKwargHandler()
-        handler_dict[CommandType.GetResultType] = GetResultTypeHandler()
-        handler_dict[CommandType.GetGlobalField] = GetGlobalFieldHandler()
+        """Initialize Handler instance and set up handler dictionary if not already done."""
+        Handler._initialize()
+
+    @staticmethod
+    def handle_command(command):
+        """
+        Handle a command by routing it to the appropriate handler.
 
-    def handle_command(self, command):
+        Args:
+            command: The command to handle.
+
+        Returns:
+            Command: The response command.
+        """
+        Handler._initialize()
         try:
             if command.command_type == CommandType.RetrieveArray:
                 response_array = handler_dict[CommandType.Reference].handle_command(command.payload[0])
                 return Command.create_array_response(response_array, command.runtime_name)
 
+            # Preprocess PluginWrapper before routing to specific handler
+            if command.command_type == CommandType.PluginWrapper:
+                command = PluginWrapperHandler().handle_command(command)
+
             response = handler_dict.get(command.command_type).handle_command(command)
-            return self.__parse_response(response, command.runtime_name)
+            parsed = Handler.__parse_response(response, command.runtime_name)
+
+            # Append ValueForUpdate commands from RegisterForUpdateHandler contexts
+            contexts = RegisterForUpdateHandler._invocation_contexts.map
+            if contexts and len(contexts) > 0:
+                for guid, instance in list(contexts.items()):
+                    instance_guid = ReferencesCache().cache_reference(instance)
+                    update_cmd = Command(
+                        command.runtime_name,
+                        CommandType.ValueForUpdate,
+                        [str(guid) if guid is not None else "",
+                        instance_guid]
+                    )
+                    parsed = parsed.add_arg_to_payload(update_cmd)
+                # Clear all entries after processing this request
+                contexts.clear()
+
+            return parsed
         except Exception as e:
             return ExceptionSerializer.serialize_exception(e, command)
 

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/PassDelegateHandler.py

@@ -31,7 +31,7 @@ class PassDelegateHandler(AbstractCommandHandler):
                     args_array
                 )
                 from javonet.core.interpreter.Interpreter import Interpreter
-                response = Interpreter().execute(invoke_delegate_command, InMemoryConnectionData())
+                response = Interpreter.execute(invoke_delegate_command, InMemoryConnectionData())
                 if response.command_type == CommandType.Exception:
                     raise Exception("Exception occurred while invoking delegate:\n" + str(ExceptionThrower.throw_exception(response)))
 

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/RegisterForUpdateHandler.py

@@ -0,0 +1,38 @@
+import threading
+from uuid import UUID
+from javonet.core.handler.AbstractCommandHandler import *
+
+class _ThreadContexts(threading.local):
+    def __init__(self):
+        # guid (UUID or empty GUID) -> object
+        self.map = {}
+
+class RegisterForUpdateHandler(AbstractCommandHandler):
+    # Shared per process, separate dicts per thread
+    _invocation_contexts = _ThreadContexts()
+    _required_parameters_count = 2
+
+    @classmethod
+    def _get_or_create_context_dict(cls):
+        if getattr(cls._invocation_contexts, "map", None) is None:
+            cls._invocation_contexts.map = {}
+        return cls._invocation_contexts.map
+
+    def process(self, command):
+        # Validate minimal number of parameters
+        if command.payload is None or len(command.payload) < self._required_parameters_count:
+            raise ValueError(f"{self.__class__.__name__} requires at least {self._required_parameters_count} parameter(s).")
+
+        obj_to_register = command.payload[0]
+        guid_to_register = None
+        if len(command.payload) > 1 and command.payload[1]:
+            try:
+                guid_to_register = UUID(str(command.payload[1]))
+            except Exception:
+                # If invalid GUID, treat as no GUID
+                guid_to_register = None
+
+        ctx = self._get_or_create_context_dict()
+        # Use None as key when GUID is missing (analogous to Guid.Empty)
+        ctx[guid_to_register] = obj_to_register
+        return obj_to_register

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/ValueForUpdateHandler.py

@@ -0,0 +1,6 @@
+from javonet.core.handler.AbstractCommandHandler import *
+
+class ValueForUpdateHandler(AbstractCommandHandler):
+    def process(self, command):
+        # Special-cased in Handler.handle_command; placeholder only.
+        raise NotImplementedError(f"{self.__class__.__name__} is not implemented in Python.")

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/interpreter/Interpreter.py

@@ -7,18 +7,17 @@ from javonet.utils.RuntimeName import RuntimeName
 from javonet.utils.connectionData.IConnectionData import IConnectionData
 from javonet.utils.messageHelper.MessageHelper import MessageHelper
 
-handler = Handler()
-
 
 class Interpreter:
     debug_mode = os.environ.get("JAVONET_DEBUG") == "TRUE"
 
-    def execute(self, command, connection_data: IConnectionData):
-        if self.debug_mode:
+    @staticmethod
+    def execute(command, connection_data: IConnectionData):
+        if Interpreter.debug_mode:
             print("Sent command: " + str(command))
             MessageHelper.send_message_to_app_insights("SentCommand", str(command))
 
-        message_byte_array = CommandSerializer().serialize(command, connection_data)
+        message_byte_array = CommandSerializer.serialize(command, connection_data)
 
         if connection_data.connection_type == ConnectionType.WebSocket:
             from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
@@ -26,29 +25,30 @@ class Interpreter:
         elif (command.runtime_name == RuntimeName.python) & (
                 connection_data.connection_type == ConnectionType.InMemory):
             from javonet.core.receiver.Receiver import Receiver
-            response_byte_array = Receiver().SendCommand(message_byte_array)
+            response_byte_array = Receiver.send_command(message_byte_array)
         else:
             from javonet.core.transmitter.Transmitter import Transmitter
             response_byte_array = Transmitter.send_command(message_byte_array)
 
-        response = CommandDeserializer(response_byte_array).deserialize()
+        response = CommandDeserializer.deserialize(response_byte_array)
 
-        if self.debug_mode:
+        if Interpreter.debug_mode:
             print("Response command: " + str(response))
             MessageHelper.send_message_to_app_insights("ResponseCommand", str(response))
 
         return response
 
-    def process(self, message_byte_array):
-        received_command = CommandDeserializer(message_byte_array).deserialize()
+    @staticmethod
+    def process(message_byte_array):
+        received_command = CommandDeserializer.deserialize(message_byte_array)
 
-        if self.debug_mode:
+        if Interpreter.debug_mode:
             print("Received command: " + str(received_command))
             MessageHelper.send_message_to_app_insights("ReceivedCommand", str(received_command))
 
-        response = handler.handle_command(received_command)
+        response = Handler.handle_command(received_command)
 
-        if self.debug_mode:
+        if Interpreter.debug_mode:
             print("Response command: " + str(response))
             MessageHelper.send_message_to_app_insights("ResponseCommand", str(response))
 

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

@@ -6,159 +6,147 @@ from javonet.utils.Type import Type
 from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
-
 class CommandDeserializer:
-    position = 0
-    buffer = []
-    command = 0
-    buffer_len = 0
-
-    def __init__(self, buffer):
-        self.buffer = buffer
-        self.buffer_len = len(buffer)
-        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
-        self.position = 11
-
-    def is_at_end(self):
-        return self.position == self.buffer_len
-
-    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:]
-    #     return new_byte_array
-
-    def read_object(self, type_num):
-        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 Exception("Type not supported")
-        return func()
-
-    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
-        
-        payload = [
-            self.read_object(self.buffer[self.position])
-            for _ in range(number_of_elements_in_payload)
-        ]
-        return Command(RuntimeName(runtime), CommandType(command_type), payload)
-
-    # old implementation
-    # 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)
-    #
-    # def read_command_recursively(self, number_of_elements_in_payload_left, cmd):
-    #     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)
-
-    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
-        self.position += size
-        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
-
-    def read_int(self):
-        size = 4
-        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.position += 2
-        p = self.position
-        self.position += size
-        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
-        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
-        self.position += size
-        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
-
-    def read_double(self):
-        size = 8
-        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.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
-        self.position += size
-        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
-
-    def read_none(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])
+    """
+    Static class for deserializing commands from byte arrays.
+    """
+
+    @staticmethod
+    def deserialize(buffer):
+        """
+        Deserialize a command from a byte array.
+
+        Args:
+            buffer: The byte array containing the serialized command.
+
+        Returns:
+            Command: The deserialized command.
+        """
+        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/Python/javonet/core/protocol/CommandSerializer.py

@@ -8,7 +8,8 @@ from javonet.utils.TypesHandler import TypesHandler
 from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 class CommandSerializer:
-    def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
+    @staticmethod
+    def serialize(root_command: Command, connection_data: IConnectionData, runtime_version=0):
         ms = io.BytesIO()
 
         ms.write(bytes([root_command.runtime_name.value, runtime_version]))
@@ -20,18 +21,19 @@ class CommandSerializer:
 
         ms.write(bytes([RuntimeName.python.value, root_command.command_type.value]))
 
-        self.serialize_recursively(root_command, ms)
+        CommandSerializer.serialize_recursively(root_command, ms)
         return ms.getvalue()
 
-    def serialize_recursively(self, command: Command, ms: io.BytesIO):
+    @staticmethod
+    def serialize_recursively(command: Command, ms: io.BytesIO):
         for item in command.get_payload():
             if isinstance(item, Command):
                 ms.write(bytes(TypeSerializer.serialize_command(item)))
-                self.serialize_recursively(item, ms)
+                CommandSerializer.serialize_recursively(item, ms)
             elif TypesHandler.is_primitive_or_none(item):
                 ms.write(bytes(TypeSerializer.serialize_primitive(item)))
             else:
                 cached_reference = ReferencesCache().cache_reference(item)
                 ref_command = Command(RuntimeName.python, CommandType.Reference, cached_reference)
                 ms.write(bytes(TypeSerializer.serialize_command(ref_command)))
-                self.serialize_recursively(ref_command, ms)
+                CommandSerializer.serialize_recursively(ref_command, ms)