javonet-ruby-sdk 2.5.20 → 2.6.1

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/messagehelper/MessageHelper.php

@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils\messagehelper;
+
+use DateTime;
+use DateTimeZone;
+use Exception;
+use GuzzleHttp\Promise\Create;
+use GuzzleHttp\Promise\PromiseInterface;
+use sdk\tools\HttpConnection;
+use utils\RuntimeName;
+use utils\Uri;
+use utils\UtilsConst;
+
+final class MessageHelper
+{
+    private const ADDRESS = 'https://dc.services.visualstudio.com/v2/track';
+    private const DEFAULT_PACKAGE_VER = '2.0.0';
+    private static ?MessageHelper $instance = null;
+    private HttpConnection $connection;
+    private string $instrumentationKey;
+    private string $javonetVersion;
+    private string $nodeName;
+    private string $osName;
+
+    private function __construct()
+    {
+        $this->connection = new HttpConnection(new Uri(self::ADDRESS));
+        $this->instrumentationKey = getenv('JAVONET_INSTRUMENTATION_KEY') ?: '2c751560-90c8-40e9-b5dd-534566514723';
+        $this->javonetVersion = $this->getJavonetVersion();
+        $this->nodeName = $this->getHostName();
+        $this->osName = php_uname('s');
+    }
+
+    public static function getInstance(): MessageHelper
+    {
+        if (self::$instance === null) {
+            self::$instance = new MessageHelper();
+        }
+        return self::$instance;
+    }
+
+    public function sendMessageToAppInsights(string $operationName, string $message): PromiseInterface
+    {
+        try {
+            $licenseKey = UtilsConst::getLicenseKey();
+            if (strpos($message, 'BinariesUnloader exception') !== false && $licenseKey === 'javonet-functional-tests-key') {
+                return Create::promiseFor(0);
+            }
+
+            $formattedDateTime = (new DateTime('now', new DateTimeZone('GMT')))
+                ->format('Y-m-d\TH:i:s');
+
+            $jsonPayload = sprintf("{\"name\":\"AppEvents\",\"time\":\"%s\",\"iKey\":\"%s\",\"tags\":{\"ai.application.ver\":\"%s\",\"ai.cloud.roleInstance\":\"%s\",\"ai.operation.id\":\"0\",\"ai.operation.parentId\":\"0\",\"ai.operation.name\":\"%s\",\"ai.internal.sdkVersion\":\"javonet:2\",\"ai.internal.nodeName\":\"%s\"},\"data\":{\"baseType\":\"EventData\",\"baseData\":{\"ver\":2,\"name\":\"%s\",\"properties\":{\"OperatingSystem\":\"%s\",\"LicenseKey\":\"%s\",\"CallingTechnology\":\"%s\"}}}}",
+                $formattedDateTime, $this->instrumentationKey, $this->javonetVersion, $this->nodeName,
+                $operationName, $this->nodeName, $message, $this->osName, $licenseKey, RuntimeName::PHP()->getName());
+
+            return $this->connection->sendAsync($jsonPayload);
+
+        } catch (Exception $e) {
+            return Create::rejectionFor(-1);
+        }
+    }
+
+    private function getJavonetVersion(): string
+    {
+        $composerJsonPath = dirname(__DIR__,4) . '/composer.json';
+        if (!file_exists($composerJsonPath)) {
+            return self::DEFAULT_PACKAGE_VER;
+        }
+
+        $composerJsonFile = json_decode(file_get_contents($composerJsonPath));
+        if (json_last_error() !== JSON_ERROR_NONE || !isset($composerJsonFile->name)) {
+            return self::DEFAULT_PACKAGE_VER;
+        }
+
+        $composerInstalledJsonPath = dirname(__DIR__, 3) . '/composer/installed.json';
+        if (!file_exists($composerInstalledJsonPath)) {
+            return self::DEFAULT_PACKAGE_VER;
+        }
+
+        $composerInstalledFile = json_decode(file_get_contents($composerInstalledJsonPath), true);
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            return self::DEFAULT_PACKAGE_VER;
+        }
+
+        foreach ($composerInstalledFile['packages'] ?? [] as $package)
+        {
+            if ($package['name'] === $composerJsonFile->name) {
+                return $package['version'] ?? self::DEFAULT_PACKAGE_VER;
+            }
+        }
+
+        return self::DEFAULT_PACKAGE_VER;
+    }
+
+    private function getHostName(): string
+    {
+        return gethostname() ?: 'Unknown Host';
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/type/CommandType.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils\type;
+
+use utils\Enum;
+
+final class CommandType extends Enum
+{
+    public const VALUE = 0;
+    public const LOAD_LIBRARY = 1;
+    public const INVOKE_STATIC_METHOD = 2;
+    public const GET_STATIC_FIELD = 3;
+    public const SET_STATIC_FIELD = 4;
+    public const CREATE_INSTANCE = 5;
+    public const GET_TYPE = 6;
+    public const REFERENCE = 7;
+    public const GET_MODULE = 8;
+    public const INVOKE_INSTANCE_METHOD = 9;
+    public const EXCEPTION = 10;
+    public const HEART_BEAT = 11;
+    public const CAST = 12;
+    public const GET_INSTANCE_FIELD = 13;
+    public const OPTIMIZE = 14;
+    public const GENERATE_LIB = 15;
+    public const INVOKE_GLOBAL_FUNCTION = 16;
+    public const DESTRUCT_REFERENCE = 17;
+    public const ARRAY_REFERENCE = 18;
+    public const ARRAY_GET_ITEM = 19;
+    public const ARRAY_GET_SIZE = 20;
+    public const ARRAY_GET_RANK = 21;
+    public const ARRAY_SET_ITEM = 22;
+    public const ARRAY = 23;
+    public const RETRIEVE_ARRAY = 24;
+    public const SET_INSTANCE_FIELD = 25;
+    public const INVOKE_GENERIC_STATIC_METHOD = 26;
+    public const INVOKE_GENERIC_METHOD = 27;
+    public const GET_ENUM_ITEM = 28;
+    public const GET_ENUM_NAME = 29;
+    public const GET_ENUM_VALUE = 30;
+    public const AS_REF = 31;
+    public const AS_OUT = 32;
+    public const GET_REF_VALUE = 33;
+    public const ENABLE_NAMESPACE = 34;
+    public const ENABLE_TYPE = 35;
+    public const CREATE_NULL = 36;
+    public const GET_STATIC_METHOD_AS_DELEGATE = 37;
+    public const GET_INSTANCE_METHOD_AS_DELEGATE = 38;
+    public const PASS_DELEGATE = 39;
+    public const INVOKE_DELEGATE = 40;
+    public const CONVERT_TYPE = 41;
+    public const ADD_EVENT_LISTENER = 42;
+    public const PLUGIN_WRAPPER = 43;
+    public const GET_ASYNC_OPERATION_RESULT = 44;
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/type/ConnectionType.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils\type;
+
+use utils\Enum;
+
+final class ConnectionType extends Enum
+{
+    public const IN_MEMORY = 0;
+    public const TCP = 1;
+    public const WEB_SOCKET = 2;
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/type/ExceptionType.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils\type;
+
+use utils\Enum;
+
+final class ExceptionType extends Enum
+{
+    public const EXCEPTION = 0;
+    public const IO_EXCEPTION = 1;
+    public const FILE_NOT_FOUND_EXCEPTION = 2;
+    public const RUNTIME_EXCEPTION = 3;
+    public const ARITHMETIC_EXCEPTION = 4 ;
+    public const ILLEGAL_ARGUMENT_EXCEPTION = 5;
+    public const INDEX_OUT_OF_BOUNDS_EXCEPTION = 6;
+    public const NULL_POINTER_EXCEPTION = 7;
+    public const DIVIDE_BY_ZERO_EXCEPTION = 8;
+
+    public static function getExceptionCodeByExceptionName(string $exceptionName): int
+    {
+        switch ($exceptionName) {
+            case 'IOException':
+                return self::IO_EXCEPTION;
+            case 'FileNotFoundException':
+                return self::FILE_NOT_FOUND_EXCEPTION;
+            case 'RuntimeException':
+                return self::RUNTIME_EXCEPTION;
+            case 'ArithmeticError':
+                return self::ARITHMETIC_EXCEPTION;
+            case 'InvalidArgumentException':
+                return self::ILLEGAL_ARGUMENT_EXCEPTION;
+            case 'OutOfBoundsException':
+            case 'OutOfRangeException':
+                return self::INDEX_OUT_OF_BOUNDS_EXCEPTION;
+            case 'TypeError':
+                return self::NULL_POINTER_EXCEPTION;
+            case 'DivisionByZeroError':
+                return self::DIVIDE_BY_ZERO_EXCEPTION;
+            default:
+                return self::EXCEPTION;
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/type/JType.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils\type;
+
+use utils\Enum;
+
+final class JType extends Enum
+{
+    public const JAVONET_COMMAND = 0;
+    public const JAVONET_STRING = 1;
+    public const JAVONET_INTEGER = 2;
+    public const JAVONET_BOOLEAN = 3;
+    public const JAVONET_FLOAT = 4;
+    public const JAVONET_BYTE = 5;
+    public const JAVONET_CHAR = 6;
+    public const JAVONET_LONG = 7;
+    public const JAVONET_DOUBLE = 8;
+    public const JAVONET_UNSIGNED_LONG_LONG = 9;
+    public const JAVONET_UNSIGNED_INTEGER = 10;
+    public const JAVONET_NULL = 11;
+    public const JAVONET_VOID = 12;
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/type/SizeType.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils\type;
+
+use utils\Enum;
+
+final class SizeType extends Enum
+{
+    public const JAVONET_BOOLEAN_SIZE = 1;
+    public const JAVONET_BYTE_SIZE = 1;
+    public const JAVONET_CHAR_SIZE = 1;
+    public const JAVONET_INTEGER_SIZE = 4;
+    public const JAVONET_FLOAT_SIZE = 4;
+    public const JAVONET_LONG_SIZE = 8;
+    public const JAVONET_DOUBLE_SIZE = 8;
+    public const JAVONET_UNSIGNED_LONG_LONG_SIZE = 8;
+    public const JAVONET_UNSIGNED_INTEGER_SIZE  = 4;
+    public const JAVONET_NULL_SIZE = 1;
+}

data/lib/javonet-ruby-sdk/Binaries/Php/phpunit.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="vendor/autoload.php"
+         stopOnError="false"
+         stopOnSkipped="false"
+         colors="true">
+    <testsuites>
+        <testsuite name="Application Test Suite">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <php>
+        <ini name="memory_limit" value="512M"/>
+    </php>
+</phpunit>

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

@@ -1,7 +1,12 @@
+from ctypes import *
+
 def callbackFunc(message_byte_array, message_byte_array_len):
+    message_byte_array_py = bytearray((c_ubyte * message_byte_array_len).from_address(
+        addressof(message_byte_array.contents)))
+    message_byte_array_len_py = int(message_byte_array_len)
     from javonet.core.receiver.Receiver import Receiver
     python_receiver = Receiver()
     if message_byte_array[10] == 11:
-        return python_receiver.HeartBeat(message_byte_array, message_byte_array_len)
+        return python_receiver.HeartBeat(message_byte_array_py, message_byte_array_len_py)
     else:
-        return python_receiver.SendCommand(message_byte_array, message_byte_array_len)
+        return python_receiver.SendCommand(message_byte_array_py, message_byte_array_len_py)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/delegateCache/DelegatesCache.py

@@ -14,26 +14,15 @@ class DelegatesCache(object):
                 cls._instance = super(DelegatesCache, cls).__new__(cls)
         return cls._instance
 
-    def cache_delegate(self, object_delegate):
+    def add_delegate(self, object_delegate):
         with self._lock:
             uuid_ = str(uuid.uuid4())
             self.delegates_cache[uuid_] = object_delegate
             return uuid_
 
-    def resolve_delegate(self, command):
-        if command.command_type != CommandType.Reference:
-            raise Exception(
-                "Failed to find delegate")
+    def get_delegate(self, delegate_guid):
         with self._lock:
             try:
-                return self.delegates_cache[command.payload[0]]
-            except KeyError:
-                raise Exception("Object not found in delegates")
-
-    def delete_delegate(self, delegate_guid):
-        with self._lock:
-            try:
-                del self.delegates_cache[delegate_guid]
-                return 0
+                return self.delegates_cache[delegate_guid]
             except KeyError:
                 raise Exception("Object not found in delegates")

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

@@ -0,0 +1,7 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Type import Type
+
+
+class ConvertTypeHandler(AbstractCommandHandler):
+    def process(self, command):
+        return Type.JavonetNoneType

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/GetResultTypeHandler.py

@@ -0,0 +1,10 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils import CommandType
+
+
+class GetResultTypeHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        return f"{command.payload[0].__class__.__module__}.{command.payload[0].__class__.__name__}"

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

@@ -27,6 +27,9 @@ 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.GetResultTypeHandler import GetResultTypeHandler
 
 
 from javonet.core.handler.HandlerDictionary import handler_dict
@@ -68,6 +71,9 @@ 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()
+        handler_dict[CommandType.GetResultType] = GetResultTypeHandler()
 
     def handle_command(self, command):
         try:
@@ -91,3 +97,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/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)