javonet-ruby-sdk 2.5.19 → 2.6.0

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

@@ -0,0 +1,26 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.CommandType import CommandType
+
+
+class GetKwargHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("GetKwargHandler parameters mismatch!")
+
+            # kwargs are passed as a list in the payload as "key1", "value1", "key2", "value2"
+            if len(command.payload) % 2 != 0:
+                raise Exception("GetKwargHandler parameters mismatch! Payload should contain an even number of elements.")
+
+            kwargs = dict(zip(command.payload[::2], command.payload[1::2]))
+            return (CommandType.AsKwargs, kwargs)
+
+
+        except Exception as e:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None

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

@@ -27,6 +27,8 @@ from javonet.core.handler.GetInstanceMethodAsDelegateHandler import GetInstanceM
 from javonet.core.handler.PassDelegateHandler import PassDelegateHandler
 from javonet.core.handler.InvokeDelegateHandler import InvokeDelegateHandler
 from javonet.core.handler.InvokeGlobalFunctionHandler import InvokeGlobalFunctionHandler
+from javonet.core.handler.ConvertTypeHandler import ConvertTypeHandler
+from javonet.core.handler.GetKwargHandler import GetKwargHandler
 
 
 from javonet.core.handler.HandlerDictionary import handler_dict
@@ -68,6 +70,8 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
         handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
         handler_dict[CommandType.InvokeGlobalFunction] = InvokeGlobalFunctionHandler()
+        handler_dict[CommandType.ConvertType] = ConvertTypeHandler()
+        handler_dict[CommandType.AsKwargs] = GetKwargHandler()
 
     def handle_command(self, command):
         try:
@@ -91,3 +95,4 @@ class Handler(AbstractHandler):
     @staticmethod
     def __is_response_array(response):
         return isinstance(response, list)
+

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

@@ -1,5 +1,6 @@
 from javonet.core.delegateCache.DelegatesCache import DelegatesCache
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeDelegateHandler(AbstractCommandHandler):
@@ -9,16 +10,24 @@ class InvokeDelegateHandler(AbstractCommandHandler):
 
     def process(self, command):
         try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("ResolveInstanceHandler parameters mismatch!")
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(f"{self.__class__.__name__} parameters mismatch")
 
             delegates_cache = DelegatesCache()
-            method = delegates_cache.resolve_delegate(command)
+            method = delegates_cache.get_delegate(command.payload[0])
+            arguments = []
+            kwargs = {}
             if len(command.payload) > 1:
-                method_arguments = command.payload[1:]
-                return method(*method_arguments)
-            else:
-                return method()
+                arguments = command.payload[1:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return method(*arguments, **kwargs)
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

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

@@ -1,5 +1,6 @@
 import importlib
 from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeGlobalFunctionHandler(AbstractCommandHandler):
@@ -37,8 +38,19 @@ class InvokeGlobalFunctionHandler(AbstractCommandHandler):
             if not callable(function):
                 raise Exception(f"Attribute '{function_name}' in module '{module_name}' is not callable.")
 
-            function_args = command.payload[1:]
-            return function(*function_args)
+            arguments = []
+            kwargs = {}
+            if len(command.payload) > 1:
+                arguments = command.payload[1:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return function(*arguments, **kwargs)
 
         except Exception as e:
             exc_type, exc_value = type(e), e

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeInstanceMethodHandler(AbstractCommandHandler):
@@ -20,11 +21,20 @@ class InvokeInstanceMethodHandler(AbstractCommandHandler):
                 for method in methods:
                     message += "{}\n".format(method)
                 raise AttributeError(message)
-            
+
+            arguments = []
+            kwargs = {}
             if len(command.payload) > 2:
-                method_arguments = command.payload[2:]
-                return method(*method_arguments)
-            return method()
+                arguments = command.payload[2:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return method(*arguments, **kwargs)
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.CommandType import CommandType
 
 
 class InvokeStaticMethodHandler(AbstractCommandHandler):
@@ -21,10 +22,20 @@ class InvokeStaticMethodHandler(AbstractCommandHandler):
                     message += "{}\n".format(method)
                 raise AttributeError(message)
             
+            arguments = []
+            kwargs = {}
             if len(command.payload) > 2:
-                method_arguments = command.payload[2:]
-                return method(*method_arguments)
-            return method()
+                arguments = command.payload[2:]
+
+                last_arg = arguments[-1]
+                if isinstance(last_arg, tuple) and last_arg[0] == CommandType.AsKwargs:
+                    if not isinstance(last_arg[1], dict):
+                        raise ValueError("Kwargs must be a dictionary, got: " + str(type(last_arg[1]).__name__))
+                    kwargs = last_arg[1]
+                    arguments = arguments[:-1]
+
+            return method(*arguments, **kwargs)
+
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

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

@@ -1,21 +1,49 @@
-from javonet.core.delegateCache.DelegatesCache import DelegatesCache
-from javonet.core.handler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
+from javonet.utils.Command import Command
+from javonet.utils.exception.ExceptionThrower import ExceptionThrower
 
 
 class PassDelegateHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 1
+    _required_parameters_count = 1
 
     def process(self, command):
         try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("ResolveInstanceHandler parameters mismatch!")
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(f"{self.__class__.__name__} parameters mismatch")
+
+            delegate_guid = command.payload[0]
+            calling_runtime = RuntimeName(command.payload[1])
+
+            # not used in this context, but kept for reference
+            #parameters_from_command = command.payload[2:] if len(command.payload) > 2 else []
+            #delegate_param_types = parameters_from_command[:-1]
+            #delegate_return_type = parameters_from_command[-1] if parameters_from_command else None
+
+            def dynamic_delegate(*args):
+                # Prepare the command to invoke the delegate
+                args_array = [delegate_guid] + list(args)
+                invoke_delegate_command = Command(
+                    calling_runtime,
+                    CommandType.InvokeDelegate,
+                    args_array
+                )
+                from javonet.core.interpreter.Interpreter import Interpreter
+                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)))
+
+                # not used in this context, but kept for reference
+                # if delegate_return_type is not None and delegate_return_type.__name__ == "JavonetVoidType":
+                #     return None
+
+                return response.payload[0] if response.payload else None
+
+            return dynamic_delegate
 
-            # TO BE IMPLEMENTED
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
-            raise new_exc from None
-
-
+            raise new_exc from None

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

@@ -1,5 +1,7 @@
 from javonet.core.handler.AbstractCommandHandler import *
 from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class ResolveInstanceHandler(AbstractCommandHandler):
@@ -11,8 +13,10 @@ class ResolveInstanceHandler(AbstractCommandHandler):
             if len(command.payload) != self._required_parameters_count:
                 raise Exception("ResolveInstanceHandler parameters mismatch!")
 
-            references_cache = ReferencesCache()
-            return references_cache.resolve_reference(command)
+            if command.runtime_name == RuntimeName.python:
+                return ReferencesCache().resolve_reference(command)
+            else:
+                return Command(command.runtime_name, CommandType.Reference, command.payload[0])
         except Exception as e:
             exc_type, exc_value = type(e), e
             new_exc = exc_type(exc_value).with_traceback(e.__traceback__)

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

@@ -22,7 +22,7 @@ class Interpreter:
 
         if connection_data.connection_type == ConnectionType.WebSocket:
             from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
-            response_byte_array = WebSocketClient().send_message(connection_data, message_byte_array)
+            response_byte_array = WebSocketClient.send_message(connection_data.hostname, message_byte_array)
         elif (command.runtime_name == RuntimeName.python) & (
                 connection_data.connection_type == ConnectionType.InMemory):
             from javonet.core.receiver.Receiver import Receiver

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

@@ -3,8 +3,12 @@ import traceback
 
 from javonet.core.interpreter.Interpreter import Interpreter
 from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.Command import Command
+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.exception.ExceptionSerializer import ExceptionSerializer
 from javonet.utils.messageHelper.MessageHelper import MessageHelper
 
 
@@ -30,7 +34,15 @@ class Receiver:
         sys.excepthook = custom_excepthook
 
     def SendCommand(self, message_byte_array, messageByteArrayLen):
-        return bytearray(CommandSerializer().serialize(Interpreter().process(message_byte_array), self.connection_data))
+        try:
+            result = Interpreter().process(message_byte_array)
+            return bytearray(CommandSerializer().serialize(result, self.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))
 
     def HeartBeat(self, message_byte_array, messageByteArrayLen):
         response_byte_array = bytearray(2)

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

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

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

@@ -1,32 +1,46 @@
 import struct
+
+from websockets.protocol import State
 from websockets.sync.client import connect
 
-from javonet.utils.connectionData.WsConnectionData import WsConnectionData
+clients = {}
+class WebSocketClient:
+
+    def __init__(self, uri: str):
+        self.uri = uri
+        self.ws = connect(uri)
 
+    @staticmethod
+    def add_or_get_client(uri: str) -> 'WebSocketClient':
+        client = clients.get(uri)
+        if client is not None:
+            if not client.ws.protocol.state == State.OPEN:
+                client.close()
+                client = WebSocketClient(uri)
+                clients[uri] = client
+        else:
+            client = WebSocketClient(uri)
+            clients[uri] = client
+        return client
 
-class WebSocketClient:
-    # _instance = None
-    # clients = dict()
-
-    # def __new__(cls):
-    #     if cls._instance is None:
-    #         cls._instance = super(WebSocketClient, cls).__new__(cls)
-    #     return cls._instance
-    #
-    # def add_or_get_client(self, connection_data: WsConnectionData):
-    #     if connection_data.hostname in self.clients:
-    #         return self.clients[connection_data.hostname]
-    #     else:
-    #         self.clients[connection_data.hostname] = connect(connection_data.hostname)
-    #         return self.clients[connection_data.hostname]
-
-    def send_message(self, connection_data: WsConnectionData, serialized_command):
-        byte_array = struct.pack("B" * len(serialized_command), *serialized_command)
-        return self.send(connection_data, byte_array)
-
-    def send(self, connection_data: WsConnectionData, byte_array):
-        websocket = connect(connection_data.hostname)
-        websocket.send(byte_array)
-        response = websocket.recv()
-        websocket.close()
+    def send_byte_array(self, message: bytes) -> None:
+        if self.ws is None:
+            raise RuntimeError("WebSocket is not opened")
+        self.ws.send(message)
+
+    def receive_byte_array(self) -> bytes:
+        response = self.ws.recv()
+        if isinstance(response, str):
+            response = response.encode('utf-8')
         return response
+
+    def close(self) -> None:
+        if self.ws is not None:
+            self.ws.close()
+            self.ws = None
+
+    @staticmethod
+    def send_message(uri: str, message: bytes) -> bytes:
+        client = WebSocketClient.add_or_get_client(uri)
+        client.send_byte_array(message)
+        return client.receive_byte_array()

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

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

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

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

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

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

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

@@ -20,7 +20,7 @@ class Interpreter(object):
         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, message_byte_array)
+            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