javonet-ruby-sdk 2.5.2 → 2.5.4

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

@@ -1,6 +1,11 @@
+import importlib
+import inspect
+import os
+import sys
 from importlib import import_module
 
 from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.LoadLibraryHandler import LoadLibraryHandler
 from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
 from javonet.core.typeCache.TypeCache import TypeCache
 
@@ -37,7 +42,10 @@ class GetTypeHandler(AbstractCommandHandler):
 
         except Exception as e:
             exc_type, exc_value = type(e), e
-            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            sys_path = "\n".join(sys.path)
+            available_types = "\n".join(self.get_all_available_types())
+            new_message = str(e) + "\nLoaded directories: " + sys_path  + "\nAvailable user types:\n" + available_types + "\n\n\n"
+            new_exc = exc_type(new_message).with_traceback(e.__traceback__)
             raise new_exc from None
 
     def _get_type_from_payload(self, command):
@@ -55,3 +63,21 @@ class GetTypeHandler(AbstractCommandHandler):
         class_name = payload[-1]
         loaded_module = import_module(module_name)
         return getattr(loaded_module, class_name)
+
+
+    def get_all_available_types(self):
+        available_types = list()
+        for directory in LoadLibraryHandler.loaded_directories:
+            for root, _, files in os.walk(directory):
+                for file in files:
+                    if file.endswith(".py") and file != "__init__.py":
+                        module_name = os.path.splitext(file)[0]
+                        module_path = os.path.relpath(os.path.join(root, module_name), directory)
+                        module_path = module_path.replace(os.sep, ".")
+                        try:
+                            module = importlib.import_module(module_path)
+                            for name, obj in inspect.getmembers(module, inspect.isclass):
+                                available_types.append(name)
+                        except Exception as e:
+                            print(f"Error importing {module_path}: {e}")
+        return available_types

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

@@ -2,9 +2,10 @@ from javonet.core.handler.AbstractCommandHandler import *
 import sys
 import os
 
-
 class LoadLibraryHandler(AbstractCommandHandler):
 
+    loaded_directories = []
+
     def __init__(self):
         self._required_parameters_count = 1
 
@@ -15,11 +16,16 @@ class LoadLibraryHandler(AbstractCommandHandler):
 
             if os.path.isdir(command.payload[0]):
                 sys.path.append(command.payload[0])
+                LoadLibraryHandler.loaded_directories.append(command.payload[0])
             else:
-                raise Exception(command.payload[0] + " does not exist");
+                raise Exception(command.payload[0] + " is not a valid directory")
 
             return 0
         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
+
+    @staticmethod
+    def get_loaded_directories():
+        return LoadLibraryHandler.loaded_directories

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/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/utils/runtime_logger.rb

@@ -0,0 +1,22 @@
+class RuntimeLogger
+
+  @not_logged_yet = true
+
+  def self.get_runtime_info
+    begin
+      "Ruby Managed Runtime Info:\n" \
+        "Ruby Version: #{RUBY_VERSION}\n" \
+        "Ruby Implementation: #{RUBY_ENGINE}\n" \
+        "Current Directory: #{Dir.pwd}\n"
+    rescue => e
+      "Ruby Managed Runtime Info: Error while fetching runtime info"
+    end
+  end
+
+  def self.print_runtime_info
+    if @not_logged_yet
+      puts get_runtime_info
+      @not_logged_yet = false
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/utils/runtime_logger.rb

@@ -0,0 +1,22 @@
+class RuntimeLogger
+
+  @not_logged_yet = true
+
+  def self.get_runtime_info
+    begin
+      "Ruby Managed Runtime Info:\n" \
+        "Ruby Version: #{RUBY_VERSION}\n" \
+        "Ruby Implementation: #{RUBY_ENGINE}\n" \
+        "Current Directory: #{Dir.pwd}\n"
+    rescue => e
+      "Ruby Managed Runtime Info: Error while fetching runtime info"
+    end
+  end
+
+  def self.print_runtime_info
+    if @not_logged_yet
+      puts get_runtime_info
+      @not_logged_yet = false
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/utils/runtime_logger.rb

@@ -0,0 +1,22 @@
+class RuntimeLogger
+
+  @not_logged_yet = true
+
+  def self.get_runtime_info
+    begin
+      "Ruby Managed Runtime Info:\n" \
+        "Ruby Version: #{RUBY_VERSION}\n" \
+        "Ruby Implementation: #{RUBY_ENGINE}\n" \
+        "Current Directory: #{Dir.pwd}\n"
+    rescue => e
+      "Ruby Managed Runtime Info: Error while fetching runtime info"
+    end
+  end
+
+  def self.print_runtime_info
+    if @not_logged_yet
+      puts get_runtime_info
+      @not_logged_yet = false
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/version.txt

@@ -1 +1 @@
-2.5.2
+2.5.4

data/lib/javonet-ruby-sdk/utils/runtime_logger.rb

@@ -0,0 +1,22 @@
+class RuntimeLogger
+
+  @not_logged_yet = true
+
+  def self.get_runtime_info
+    begin
+      "Ruby Managed Runtime Info:\n" \
+        "Ruby Version: #{RUBY_VERSION}\n" \
+        "Ruby Implementation: #{RUBY_ENGINE}\n" \
+        "Current Directory: #{Dir.pwd}\n"
+    rescue => e
+      "Ruby Managed Runtime Info: Error while fetching runtime info"
+    end
+  end
+
+  def self.print_runtime_info
+    if @not_logged_yet
+      puts get_runtime_info
+      @not_logged_yet = false
+    end
+  end
+end