javonet-ruby-sdk 2.5.1 → 2.5.3

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

@@ -51,6 +51,7 @@ class GetTypeHandler(AbstractCommandHandler):
             return self._get_type_from_nested_payload(command.payload)
 
     def _get_type_from_nested_payload(self, payload):
-        for i in range(len(payload) - 1):
-            loaded_module = import_module(".".join(payload[:i + 1]))
-        return getattr(loaded_module, payload[-1])
+        module_name = ".".join(payload[:-1])
+        class_name = payload[-1]
+        loaded_module = import_module(module_name)
+        return getattr(loaded_module, class_name)

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

@@ -22,6 +22,11 @@ from javonet.core.handler.GetEnumNameHandler import GetEnumNameHandler
 from javonet.core.handler.GetEnumValueHandler import GetEnumValueHandler
 from javonet.core.handler.EnableNamespaceHandler import EnableNamespaceHandler
 from javonet.core.handler.EnableTypeHandler import EnableTypeHandler
+from javonet.core.handler.GetStaticMethodAsDelegateHandler import GetStaticMethodAsDelegateHandler
+from javonet.core.handler.GetInstanceMethodAsDelegateHandler import GetInstanceMethodAsDelegateHandler
+from javonet.core.handler.PassDelegateHandler import PassDelegateHandler
+from javonet.core.handler.InvokeDelegateHandler import InvokeDelegateHandler
+
 
 from javonet.core.handler.HandlerDictionary import handler_dict
 from javonet.core.referenceCache.ReferencesCache import ReferencesCache
@@ -56,6 +61,10 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
         handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
         handler_dict[CommandType.EnableType] = EnableTypeHandler()
+        handler_dict[CommandType.GetStaticMethodAsDelegate] = GetStaticMethodAsDelegateHandler()
+        handler_dict[CommandType.GetInstanceMethodAsDelegate] = GetInstanceMethodAsDelegateHandler()
+        handler_dict[CommandType.PassDelegate] = PassDelegateHandler()
+        handler_dict[CommandType.InvokeDelegate] = InvokeDelegateHandler()
 
     def handle_command(self, command):
         try:

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

@@ -0,0 +1,27 @@
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class InvokeDelegateHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            delegates_cache = DelegatesCache()
+            method = delegates_cache.resolve_delegate(command)
+            if len(command.payload) > 1:
+                method_arguments = command.payload[1:]
+                return method(*method_arguments)
+            else:
+                return method()
+        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/InvokeStaticMethodHandler.py

@@ -1,5 +1,3 @@
-import traceback
-
 from javonet.core.handler.AbstractCommandHandler import *
 
 

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

@@ -0,0 +1,21 @@
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class PassDelegateHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            # 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
+
+

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

@@ -7,7 +7,6 @@ from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 handler = Handler()
 
-
 class Interpreter:
 
     def execute(self, command, connection_data: IConnectionData):

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

@@ -6,6 +6,7 @@ from javonet.utils.Type import Type
 from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
+
 class CommandDeserializer:
     position = 0
     buffer = []

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

@@ -1,6 +1,3 @@
-from collections import deque
-from typing import Deque
-
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
 from javonet.utils.RuntimeName import RuntimeName
@@ -8,54 +5,24 @@ from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 
 class CommandSerializer:
-    byte_buffer = []
+    buffer = []
 
     def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
-        queue: Deque[Command] = deque()
-        queue.append(root_command)
         self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
         self.insert_into_buffer(connection_data.serialize_connection_data())
         self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
-        return self.serialize_recursively(queue)
-
-    @staticmethod
-    def serialize_primitive(payload_item):
-        if payload_item is None:
-            return TypeSerializer.serialize_none()
-        if isinstance(payload_item, bool):
-            return TypeSerializer.serialize_bool(payload_item)
-        elif isinstance(payload_item, int):
-            if payload_item in range(-2 ** 31, 2 ** 31):
-                return TypeSerializer.serialize_int(payload_item)
-            elif payload_item in range(-2 ** 63, 2 ** 63):
-                return TypeSerializer.serialize_longlong(payload_item)
+        self.serialize_recursively(root_command)
+        return self.buffer
+
+    def serialize_recursively(self, command):
+        for item in command.get_payload():
+            if isinstance(item, Command):
+                self.insert_into_buffer(TypeSerializer.serialize_command(item))
+                self.serialize_recursively(item)
             else:
-                return TypeSerializer.serialize_ullong(payload_item)
-        elif isinstance(payload_item, float):
-            return TypeSerializer.serialize_double(payload_item)
-        elif isinstance(payload_item, str):
-            return TypeSerializer.serialize_string(payload_item)
-        else:
-            raise Exception("Python: Type serialization not supported for type: " + payload_item)
-
-    def insert_into_buffer(self, arguments):
-        self.byte_buffer = self.byte_buffer + arguments
+                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
 
-    def serialize_recursively(self, queue):
-        if not queue:
-            return self.byte_buffer
-        command = queue.pop()
-        queue.append(command.drop_first_payload_argument())
-        if len(command.get_payload()) > 0:
-            if isinstance(command.get_payload()[0], Command):
-                inner_command = command.get_payload()[0]
-                self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
-                queue.append(inner_command)
-            else:
-                result = self.serialize_primitive(command.get_payload()[0])
-                self.insert_into_buffer(result)
-            return self.serialize_recursively(queue)
-        else:
-            queue.pop()
+        return
 
-        return self.serialize_recursively(queue)
+    def insert_into_buffer(self, arguments):
+        self.buffer = self.buffer + arguments

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

@@ -5,7 +5,27 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeSerializer:
-    
+
+    @staticmethod
+    def serialize_primitive(payload_item):
+        if payload_item is None:
+            return TypeSerializer.serialize_none()
+        if isinstance(payload_item, bool):
+            return TypeSerializer.serialize_bool(payload_item)
+        elif isinstance(payload_item, int):
+            if payload_item in range(-2 ** 31, 2 ** 31):
+                return TypeSerializer.serialize_int(payload_item)
+            elif payload_item in range(-2 ** 63, 2 ** 63):
+                return TypeSerializer.serialize_longlong(payload_item)
+            else:
+                return TypeSerializer.serialize_ullong(payload_item)
+        elif isinstance(payload_item, float):
+            return TypeSerializer.serialize_double(payload_item)
+        elif isinstance(payload_item, str):
+            return TypeSerializer.serialize_string(payload_item)
+        else:
+            raise Exception("Python: Type serialization not supported for type: " + payload_item)
+
     @staticmethod
     def serialize_command(command):
         length = list(bytearray(struct.pack("<i", len(command.payload))))

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

@@ -1,11 +1,16 @@
+import sys
+
 from javonet.core.interpreter.Interpreter import Interpreter
 from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.RuntimeLogger import RuntimeLogger
 from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 
 
 class Receiver:
 
     def __init__(self):
+        RuntimeLogger.print_runtime_info()
+        sys.stdout.flush()
         self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, message_byte_array, messageByteArrayLen):

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

@@ -24,6 +24,8 @@ class TransmitterWrapper:
         python_lib_path = file_path + f'/Binaries/Native/Linux/{arch}/libJavonetPythonRuntimeNative.so'
     elif platform.system() == 'Darwin':
         python_lib_path = file_path + f'/Binaries/Native/MacOs/{arch}/libJavonetPythonRuntimeNative.dylib'
+    else:
+        raise RuntimeError("Unsupported OS: " + platform.system())
 
     python_lib = cdll.LoadLibrary(python_lib_path)
     python_lib.SetCallback(callbackFunction)
@@ -69,10 +71,11 @@ class TransmitterWrapper:
             get_native_error.argtypes = []
             error_message = get_native_error()
             raise RuntimeError(
-                "Javonet activation result: " + str(activation_result) + ". Native error message: " + str(error_message))
+                "Javonet activation result: " + str(activation_result) + ". Native error message: " + str(
+                    error_message))
         else:
             return activation_result
-        
+
     @staticmethod
     def set_config_source(sourcePath):
         set_config_source = TransmitterWrapper.python_lib.SetConfigSource
@@ -87,6 +90,7 @@ class TransmitterWrapper:
             get_native_error.argtypes = []
             error_message = get_native_error()
             raise RuntimeError(
-                "Javonet set config source result: " + str(set_config_result) + ". Native error message: " + str(error_message))
+                "Javonet set config source result: " + str(set_config_result) + ". Native error message: " + str(
+                    error_message))
         else:
             return set_config_result

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

@@ -39,3 +39,7 @@ class CommandType(Enum):
     EnableNamespace = 34
     EnableType = 35
     CreateNull = 36
+    GetStaticMethodAsDelegate = 37
+    GetInstanceMethodAsDelegate = 38
+    PassDelegate = 39
+    InvokeDelegate = 40

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

@@ -0,0 +1,30 @@
+import platform
+import os
+import sys
+
+
+class RuntimeLogger:
+
+    not_logged_yet = True
+    @staticmethod
+    def get_runtime_info():
+        try:
+            return (
+                "Python Managed Runtime Info:\n"
+                f"Python Version: {platform.python_version()}\n"
+                f"Python executable path: {sys.executable}\n"
+                f"Python Path: {sys.path}\n"
+                f"Python Implementation: {platform.python_implementation()}\n"
+                f"OS Version: {platform.system()} {platform.version()}\n"
+                f"Process Architecture: {platform.machine()}\n"
+                f"Current Directory: {os.getcwd()}\n"
+            )
+        except Exception as e:
+            return "Python Managed Runtime Info: Error while fetching runtime info"
+
+    @staticmethod
+    def print_runtime_info():
+        if RuntimeLogger.not_logged_yet:
+            print(RuntimeLogger.get_runtime_info())
+            RuntimeLogger.not_logged_yet = False
+    

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/interpreter/interpreter.rb

@@ -3,10 +3,10 @@ require_relative '../protocol/command_deserializer'
 require_relative '../handler/handler'
 
 class Interpreter
-  def execute(command, connection_type, tcp_connection_data)
+  @@handler = Handler.new
 
-    command_serializer = CommandSerializer.new
-    message_byte_array = command_serializer.serialize(command, connection_type, tcp_connection_data)
+  def execute(command, connection_type, tcp_connection_data)
+    message_byte_array = CommandSerializer.new.serialize(command, connection_type, tcp_connection_data)
     if command.runtime_name == RuntimeName::RUBY && connection_type == ConnectionType::IN_MEMORY
       require_relative '../receiver/receiver'
       response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
@@ -15,15 +15,11 @@ class Interpreter
       response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)
     end
 
-    command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
-    command_deserializer.deserialize
+    CommandDeserializer.new(response_byte_array).deserialize
   end
 
   def process(byte_array, byte_array_len)
-    command_deserializer = CommandDeserializer.new(byte_array,byte_array_len)
-    received_command = command_deserializer.deserialize
-    handler = Handler.new
-    command_serializer = CommandSerializer.new
-    command_serializer.serialize(handler.handle_command(received_command))
+    received_command = CommandDeserializer.new(byte_array).deserialize
+    CommandSerializer.new.serialize(@@handler.handle_command(received_command))
   end
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/protocol/command_deserializer.rb

@@ -5,9 +5,9 @@ require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
-  def initialize(buffer, byte_array_len)
+  def initialize(buffer)
     @buffer = buffer
-    @byte_array_len = byte_array_len
+    @byte_array_len = buffer.length
     @command = Command.new(buffer[0], buffer[10], [])
     @position = 11
   end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/transmitter/transmitter.rb

@@ -22,20 +22,8 @@ class Transmitter
     end
   end
 
-  def self.activate_with_license_file()
-    return activate()
-  end
-
-  def self.activate_with_credentials(licenseKey)
-    return activate(licenseKey)
-  end
-
-  def self.activate_with_credentials_and_proxy(licenseKey, proxyHost, proxyUserName, proxyPassword)
-    return activate(licenseKey, proxyHost, proxyUserName, proxyPassword)
-  end
-
-  private_class_method def self.activate(licenseKey = "", proxyHost = "", proxyUserName = "", proxyUserPassword = "")
-    activation_result = TransmitterWrapper.Activate(licenseKey, proxyHost, proxyUserName, proxyUserPassword)
+  def self.activate(license_key)
+    activation_result = TransmitterWrapper.Activate(license_key, "", "", "")
     if activation_result < 0
       error_message = get_native_error
       raise Exception.new "Javonet activation result: " + activation_result.to_s + ". Native error message: " + error_message
@@ -48,8 +36,8 @@ class Transmitter
     TransmitterWrapper.GetNativeError
   end
 
-  def self.set_config_source(configPath)
-    set_config_result = TransmitterWrapper.SetConfigSource(configPath)
+  def self.set_config_source(config_path)
+    set_config_result = TransmitterWrapper.SetConfigSource(config_path)
     if set_config_result < 0
       error_message = get_native_error
       raise Exception.new "Javonet set config source result: " + set_config_result.to_s + ". Native error message: " + error_message

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/interpreter/interpreter.rb

@@ -3,10 +3,10 @@ require_relative '../protocol/command_deserializer'
 require_relative '../handler/handler'
 
 class Interpreter
-  def execute(command, connection_type, tcp_connection_data)
+  @@handler = Handler.new
 
-    command_serializer = CommandSerializer.new
-    message_byte_array = command_serializer.serialize(command, connection_type, tcp_connection_data)
+  def execute(command, connection_type, tcp_connection_data)
+    message_byte_array = CommandSerializer.new.serialize(command, connection_type, tcp_connection_data)
     if command.runtime_name == RuntimeName::RUBY && connection_type == ConnectionType::IN_MEMORY
       require_relative '../receiver/receiver'
       response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
@@ -15,15 +15,11 @@ class Interpreter
       response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)
     end
 
-    command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
-    command_deserializer.deserialize
+    CommandDeserializer.new(response_byte_array).deserialize
   end
 
   def process(byte_array, byte_array_len)
-    command_deserializer = CommandDeserializer.new(byte_array,byte_array_len)
-    received_command = command_deserializer.deserialize
-    handler = Handler.new
-    command_serializer = CommandSerializer.new
-    command_serializer.serialize(handler.handle_command(received_command))
+    received_command = CommandDeserializer.new(byte_array).deserialize
+    CommandSerializer.new.serialize(@@handler.handle_command(received_command))
   end
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/protocol/command_deserializer.rb

@@ -5,9 +5,9 @@ require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
-  def initialize(buffer, byte_array_len)
+  def initialize(buffer)
     @buffer = buffer
-    @byte_array_len = byte_array_len
+    @byte_array_len = buffer.length
     @command = Command.new(buffer[0], buffer[10], [])
     @position = 11
   end