javonet-ruby-sdk 2.6.10 → 2.6.11

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

@@ -8,47 +8,90 @@ from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeLogger import RuntimeLogger
 from javonet.utils.RuntimeName import RuntimeName
 from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 from javonet.utils.messageHelper.MessageHelper import MessageHelper
 
 
 class Receiver:
+    _original_excepthook = None
+    _exception_handler_initialized = False
 
-    def __init__(self):
-        self.connection_data = InMemoryConnectionData()
+    @staticmethod
+    def initialize_exception_handler():
+        """Initialize the global exception handler. Should be called once."""
+        try:
+            if not Receiver._exception_handler_initialized:
+                # Store the original excepthook
+                Receiver._original_excepthook = sys.excepthook
+
+                # Set up global exception handler
+                def custom_excepthook(exc_type, exc_value, exc_traceback):
+                    # Format the exception
+                    exception_string = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+                    # Send to App Insights
+                    MessageHelper.send_message_to_app_insights_sync("ReceiverUnhandledException", exception_string)
+                    print(exception_string)
+                    # Call the original handler
+                    if Receiver._original_excepthook:
+                        Receiver._original_excepthook(exc_type, exc_value, exc_traceback)
 
-        # Store the original excepthook
-        self.original_excepthook = sys.excepthook
+                # Register the custom exception handler
+                sys.excepthook = custom_excepthook
+                Receiver._exception_handler_initialized = True
+        except Exception as ex:
+            print("Failed to initialize exception handler: {}".format(str(ex)))
 
-        # Set up global exception handler
-        def custom_excepthook(exc_type, exc_value, exc_traceback):
-            # Format the exception
-            exception_string = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
-            # Send to App Insights
-            MessageHelper.send_message_to_app_insights_sync("ReceiverUnhandledException", exception_string)
-            print(exception_string)
-            # Call the original handler
-            self.original_excepthook(exc_type, exc_value, exc_traceback)
 
-        # Register the custom exception handler
-        sys.excepthook = custom_excepthook
+    @staticmethod
+    def send_command(message_byte_array, connection_data: IConnectionData = None):
+        """
+        Process a command message and return the response.
 
-    def SendCommand(self, message_byte_array):
+        Args:
+            message_byte_array: The byte array containing the command message.
+            connection_data: Optional connection data. If None, uses InMemoryConnectionData.
+
+        Returns:
+            bytearray: The response byte array.
+        """
+        if connection_data is None:
+            connection_data = InMemoryConnectionData()
+        
         try:
-            result = Interpreter().process(message_byte_array)
-            return bytearray(CommandSerializer().serialize(result, self.connection_data))
+            result = Interpreter.process(message_byte_array)
+            return bytearray(CommandSerializer.serialize(result, connection_data))
         except Exception as ex:
             exception_command = ExceptionSerializer.serialize_exception(
                 ex,
                 Command(RuntimeName.python, CommandType.Exception, [])
             )
-            return bytearray(CommandSerializer().serialize(exception_command, self.connection_data))
+            return bytearray(CommandSerializer.serialize(exception_command, connection_data))
+
+    @staticmethod
+    def heart_beat(message_byte_array):
+        """
+        Process a heartbeat message and return the response.
 
-    def HeartBeat(self, message_byte_array):
+        Args:
+            message_byte_array: The byte array containing the heartbeat message.
+
+        Returns:
+            bytearray: The response byte array.
+        """
         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 get_runtime_info():
+        """
+        Get runtime information.
+
+        Returns:
+            str: Runtime information string.
+        """
         return RuntimeLogger().get_runtime_info()
+

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

@@ -3,88 +3,157 @@ from javonet.utils.CommandType import CommandType
 
 class Command:
 
-    def __init__(self, runtime_name, command_type, payload):
+    def __init__(self, runtime_name, command_type, payload=None):
+        """
+        Initialize a Command.
+        Matches C# constructor: Command(RuntimeName runtimeName, CommandType commandType, params object[] payload)
+        and: Command(RuntimeName runtimeName, CommandType commandType, Array payload)
+
+        Args:
+            runtime_name: The runtime name.
+            command_type: The command type.
+            payload: The payload. Can be None, a list/tuple (array-like), or a single item.
+                    If None, defaults to empty list.
+        """
         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 = []
+        if payload is None:
+            self.payload = [None]
+        elif isinstance(payload, (list, tuple)):
+            # If it's a list or tuple, convert to list (matching C# Array handling)
+            # For list, reuse directly for efficiency (matching C# object[] case)
+            if isinstance(payload, list):
+                self.payload = payload
+            else:
+                # For tuple or other sequence, convert to list
+                self.payload = list(payload)
+        else:
+            # Single item - wrap in list
+            self.payload = [payload]
+
+    @property
+    def RuntimeName(self):
+        """Get the runtime name (property accessor matching C# style)."""
+        return self.runtime_name
+
+    @property
+    def CommandType(self):
+        """Get the command type (property accessor matching C# style)."""
+        return self.command_type
+
+    @property
+    def Payload(self):
+        """Get the payload (property accessor matching C# style)."""
+        return self.payload
 
     def get_payload(self):
+        """Get the payload (legacy method for backward compatibility)."""
         return self.payload
 
     @staticmethod
     def create_response(response, runtime_name):
-        return Command(runtime_name, CommandType.Value, [response])
+        return Command(runtime_name, CommandType.Value, response)
 
     @staticmethod
     def create_reference(guid, runtime_name):
-        return Command(runtime_name, CommandType.Reference, [guid])
+        return Command(runtime_name, CommandType.Reference, guid)
 
     @staticmethod
     def create_array_response(array, runtime_name):
         return Command(runtime_name, CommandType.Array, array)
 
     def drop_first_payload_argument(self):
-        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)
-
-    def add_arg_to_payload(self, argument):
-        merged_payload = self.payload + [argument]
-        return Command(self.runtime_name, self.command_type, merged_payload)
-
-    def prepend_arg_to_payload(self, current_command):
-        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)
+        """Legacy method name for backward compatibility."""
+        return self.drop_first_payload_arg()
+
+    def drop_first_payload_arg(self):
+        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 range(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, arg):
+        old_length = len(self.payload)
+        new_payload = [None] * (old_length + 1)
+        
+        if old_length > 0:
+            for i in range(old_length):
+                new_payload[i] = self.payload[i]
+        
+        new_payload[old_length] = arg
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
+
+    def prepend_arg_to_payload(self, arg_command):
+        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
+        
+        if old_length > 0:
+            for i in range(old_length):
+                new_payload[i + 1] = self.payload[i]
+        
+        return Command(self.runtime_name, self.command_type, new_payload)
 
     def to_string(self):
-        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
-            self.command_type) + ' Payload: ' + str(self.payload)
+        """Legacy method for backward compatibility."""
+        return str(self)
 
     def __eq__(self, element):
-        self.is_equal = False
         if self is element:
-            self.is_equal = True
+            return True
         if element is None or self.__class__ != element.__class__:
-            self.is_equal = False
-        if self.command_type is element.command_type and self.runtime_name is element.runtime_name:
-            self.is_equal = True
-        if len(self.payload) == len(element.payload):
-            i = 0
-            array_item_equal = False
-            for payload_item in self.payload:
-                if payload_item.__eq__(element.payload[i]):
-                    array_item_equal = True
-                else:
-                    array_item_equal = False
-                i += 1
-            self.is_equal = array_item_equal
-        else:
-            self.is_equal = False
-        return self.is_equal
+            return False
+        if self.command_type != element.command_type or self.runtime_name != element.runtime_name:
+            return False
+        if len(self.payload) != len(element.payload):
+            return False
+        
+        for i, payload_item in enumerate(self.payload):
+            if payload_item != element.payload[i]:
+                return False
+        
+        return True
 
     def __str__(self):
         try:
             result = "RuntimeName "
-            result += str(self.runtime_name).capitalize()
+            result += str(self.runtime_name)
             result += " "
             result += "CommandType "
             result += str(self.command_type)
             result += " "
             result += "Payload "
-
-            for i, item in enumerate(self.payload):
+            
+            payload = self.payload
+            length = len(payload)
+            
+            for i in range(length):
+                item = payload[i]
                 if item is None:
                     result += "null"
                 else:
                     result += str(item)
-
-                if i < len(self.payload) - 1:
+                
+                if i < length - 1:
                     result += " "
-
+            
             return result
         except Exception as ex:
             return f"Error while converting command to string: {str(ex)}"

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/callback/callbackFunc.py

@@ -13,8 +13,7 @@ def callbackFunc(message_byte_array, message_byte_array_len):
     :return: Response as byte array
     """
     from javonet.core.receiver.Receiver import Receiver
-    python_receiver = Receiver()
     if message_byte_array[10] == 11:
-        return python_receiver.handle_heartbeat(message_byte_array, message_byte_array_len)
+        return Receiver.HeartBeat(message_byte_array)
     else:
-        return python_receiver.send_command(message_byte_array, message_byte_array_len) 
+        return Receiver.SendCommand(message_byte_array)

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

@@ -0,0 +1,5 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+
+class GetKwargHandler(AbstractCommandHandler):
+    def process(self, command):
+        raise NotImplementedError("%s is not implemented in Python" % self.__class__.__name__)

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

@@ -3,6 +3,14 @@
 The Handler class is the main handler for all commands in Javonet.
 """
 
+from javonet.core.handler.HandlerDictionary import handler_dict
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.TypesHandler import TypesHandler
+from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
+from javonet.utils.CommandType import CommandType
+from javonet.utils.Command import Command
+
+
 from javonet.core.handler.AbstractHandler import AbstractHandler
 from javonet.core.handler.ValueHandler import ValueHandler
 from javonet.core.handler.LoadLibraryHandler import LoadLibraryHandler
@@ -22,6 +30,7 @@ from javonet.core.handler.OptimizeHandler import OptimizeHandler
 from javonet.core.handler.GenerateLibHandler import GenerateLibHandler
 from javonet.core.handler.InvokeGlobalFunctionHandler import InvokeGlobalFunctionHandler
 from javonet.core.handler.DestructReferenceHandler import DestructReferenceHandler
+from javonet.core.handler.ArrayReferenceHandler import ArrayReferenceHandler
 from javonet.core.handler.ArrayGetItemHandler import ArrayGetItemHandler
 from javonet.core.handler.ArrayGetSizeHandler import ArrayGetSizeHandler
 from javonet.core.handler.ArrayGetRankHandler import ArrayGetRankHandler
@@ -34,6 +43,9 @@ from javonet.core.handler.InvokeGenericMethodHandler import InvokeGenericMethodH
 from javonet.core.handler.GetEnumItemHandler import GetEnumItemHandler
 from javonet.core.handler.GetEnumNameHandler import GetEnumNameHandler
 from javonet.core.handler.GetEnumValueHandler import GetEnumValueHandler
+from javonet.core.handler.AsRefHandler import AsRefHandler
+from javonet.core.handler.AsOutHandler import AsOutHandler
+from javonet.core.handler.GetRefValueHandler import GetRefValueHandler
 from javonet.core.handler.EnableNamespaceHandler import EnableNamespaceHandler
 from javonet.core.handler.EnableTypeHandler import EnableTypeHandler
 from javonet.core.handler.CreateNullHandler import CreateNullHandler
@@ -45,26 +57,25 @@ from javonet.core.handler.ConvertTypeHandler import ConvertTypeHandler
 from javonet.core.handler.AddEventListenerHandler import AddEventListenerHandler
 from javonet.core.handler.PluginWrapperHandler import PluginWrapperHandler
 from javonet.core.handler.GetAsyncOperationResultHandler import GetAsyncOperationResultHandler
-from javonet.core.handler.AsKwargsHandler import AsKwargsHandler
+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.HandlerDictionary import handler_dict
-from javonet.core.referenceCache.ReferencesCache import ReferencesCache
-from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
-from javonet.utils.CommandType import CommandType
-from javonet.utils.TypesHandler import TypesHandler
-from javonet.utils.Command import Command
 
 
 class Handler(AbstractHandler):
     """
     Handler class for processing commands.
     """
-    def __init__(self):
+    _initialized = False
+
+    @staticmethod
+    def _initialize():
         """
-        Initialize the handler with all command handlers.
+        Initialize the handler dictionary with all command handlers.
         """
+        if Handler._initialized:
+            return
         handler_dict[CommandType.Value] = ValueHandler()
         handler_dict[CommandType.LoadLibrary] = LoadLibraryHandler()
         handler_dict[CommandType.InvokeStaticMethod] = InvokeStaticMethodHandler()
@@ -83,6 +94,7 @@ class Handler(AbstractHandler):
         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()
@@ -95,6 +107,9 @@ class Handler(AbstractHandler):
         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()
@@ -106,11 +121,13 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.AddEventListener] = AddEventListenerHandler()
         handler_dict[CommandType.PluginWrapper] = PluginWrapperHandler()
         handler_dict[CommandType.GetAsyncOperationResult] = GetAsyncOperationResultHandler()
-        handler_dict[CommandType.AsKwargs] = AsKwargsHandler()
+        handler_dict[CommandType.AsKwargs] = GetKwargHandler()
         handler_dict[CommandType.GetResultType] = GetResultTypeHandler()
         handler_dict[CommandType.GetGlobalField] = GetGlobalFieldHandler()
+        Handler._initialized = True
 
-    def handle_command(self, command):
+    @staticmethod
+    def handle_command(command):
         """
         Handle a command and return a response.
 
@@ -118,6 +135,7 @@ class Handler(AbstractHandler):
         :type command: Command
         :return: Response command        :rtype:
         """
+        Handler._initialize()
         try:
             if command.command_type == CommandType.RetrieveArray:
                 response_array = handler_dict[CommandType.Reference].handle_command(command.payload[0])
@@ -128,7 +146,7 @@ class Handler(AbstractHandler):
                 raise ValueError("No handler found for command type: {0}".format(command.command_type))
 
             response = handler.handle_command(command)
-            return self.__parse_response(response, command.runtime_name)
+            return Handler.__parse_response(response, command.runtime_name)
         except Exception as e:
             return ExceptionSerializer.serialize_exception(e, command)
 

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

@@ -47,8 +47,8 @@ class InvokeDelegateHandler(AbstractCommandHandler):
         :param command: Command to handle
         :return: Command with operation result
         """
-        delegate_id = command.get_payload()[0]
-        args = command.get_payload()[1:]
+        delegate_id = command.payload[0]
+        args = command.payload[1:]
         result = Command(command.runtime_name, CommandType.Value, [])
         result = result.add_arg_to_payload(delegate_id)
         for arg in args:

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

@@ -69,8 +69,8 @@ class InvokeGlobalFunctionHandler(AbstractCommandHandler):
         :param command: Command to handle
         :return: Command with operation result
         """
-        function_name = command.get_payload()[0]
-        args = command.get_payload()[1:]
+        function_name = command.payload[0]
+        args = command.payload[1:]
         result = Command(command.runtime_name, CommandType.Value, [])
         result = result.add_arg_to_payload(function_name)
         for arg in args:

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

@@ -8,29 +8,29 @@ from javonet.core.protocol.CommandSerializer import CommandSerializer
 from javonet.utils.ConnectionType import ConnectionType
 from javonet.utils.RuntimeName import RuntimeName
 
-handler = Handler()
-
 
 class Interpreter(object):
     """
     Class responsible for interpreting and executing Javonet commands.
     """
 
-    def execute(self, command, connection_data):
-        message_byte_array = CommandSerializer().serialize(command, connection_data)
+    @staticmethod
+    def execute(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
             response_byte_array = WebSocketClient.send_message(connection_data.hostname, message_byte_array)
         elif (command.runtime_name == RuntimeName.python27) & (
                 connection_data.connection_type == ConnectionType.InMemory):
             from javonet.core.receiver.Receiver import Receiver
-            response_byte_array = Receiver().SendCommand(message_byte_array, len(message_byte_array))
+            response_byte_array = Receiver.SendCommand(message_byte_array)
         else:
             from javonet.core.transmitter.Transmitter import Transmitter
             response_byte_array = Transmitter.send_command(message_byte_array)
 
-        return CommandDeserializer(response_byte_array).deserialize()
+        return CommandDeserializer.deserialize(response_byte_array)
 
-    def process(self, message_byte_array):
-        received_command = CommandDeserializer(message_byte_array).deserialize()
-        return handler.handle_command(received_command)
+    @staticmethod
+    def process(message_byte_array):
+        received_command = CommandDeserializer.deserialize(message_byte_array)
+        return Handler.handle_command(received_command)