javonet-ruby-sdk 2.6.3 → 2.6.5

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

@@ -27,7 +27,7 @@ final class ExceptionSerializer
         $exceptionName = basename(str_replace('\\', '/', get_class($exception)));
 
         $exceptionCommand = $exceptionCommand->addArgToPayload(ExceptionType::getExceptionCodeByExceptionName($exceptionName));
-        $exceptionCommand = $exceptionCommand->addArgToPayload($command);
+        $exceptionCommand = $exceptionCommand->addArgToPayload((string)$command);
         $exceptionCommand = $exceptionCommand->addArgToPayload($exceptionName);
         $exceptionCommand = $exceptionCommand->addArgToPayload($exception->getMessage());
         $exceptionCommand = $exceptionCommand->addArgToPayload($stackClasses);
@@ -45,12 +45,19 @@ final class ExceptionSerializer
         string &$stackLines,
         string &$stackFiles
     ): void {
+        $classes = $methods = $lines = $files = [];
+
         foreach ($trace as $frame) {
-            $stackClasses .= ($frame['class'] ?? 'undefined') . '|';
-            $stackMethods .= ($frame['function'] ?? 'undefined') . '|';
-            $stackLines .= ($frame['line'] ?? '0') . '|';
-            $stackFiles .= ($frame['file'] ?? 'undefined') . '|';
+            $classes[] = $frame['class']    ?? 'undefined';
+            $methods[] = $frame['function'] ?? 'undefined';
+            $lines[]   = isset($frame['line']) ? (string)$frame['line'] : '0';
+            $files[]   = $frame['file']     ?? 'undefined';
         }
+
+        $stackClasses = implode('|', $classes);
+        $stackMethods = implode('|', $methods);
+        $stackLines   = implode('|', $lines);
+        $stackFiles   = implode('|', $files);
     }
 
     private static function getStackTraceAfterReflection(array $trace): array

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

@@ -9,6 +9,7 @@ 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
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class GetGlobalFieldHandler(AbstractCommandHandler):
@@ -27,7 +28,9 @@ class GetGlobalFieldHandler(AbstractCommandHandler):
             module_name, field_name = full_field_name.rsplit(".", 1)
 
             try:
-                module = importlib.import_module(module_name)
+                module = LazyModuleLoader.get_module(module_name)
+                if module is None:
+                    raise ImportError(f"Could not import module '{module_name}'.")
             except ImportError as e:
                 raise ImportError(f"Could not import module '{module_name}'.") from e
 

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class GetInstanceFieldHandler(AbstractCommandHandler):
@@ -13,9 +14,9 @@ class GetInstanceFieldHandler(AbstractCommandHandler):
             clazz = command.payload[0]
             field = command.payload[1]
             try:
-                return getattr(clazz, field)
+                return LazyModuleLoader.safe_getattr(clazz, field)
             except AttributeError:
-                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
+                fields = [field for field in dir(clazz) if not callable(LazyModuleLoader.safe_getattr(clazz, field))]
                 message = "Field {} not found in class {}. Available fields:\n".format(field, clazz.__class__.__name__)
                 for field in fields:
                     message += "{}\n".format(field)

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class GetInstanceMethodAsDelegateHandler(AbstractCommandHandler):
@@ -13,9 +14,9 @@ class GetInstanceMethodAsDelegateHandler(AbstractCommandHandler):
 
             class_instance = command.payload[0]
             try:
-                method = getattr(class_instance, command.payload[1])
+                method = LazyModuleLoader.safe_getattr(class_instance, command.payload[1])
             except AttributeError:
-                methods = [method for method in dir(class_instance) if callable(getattr(class_instance, method))]
+                methods = [method for method in dir(class_instance) if callable(LazyModuleLoader.safe_getattr(class_instance, method))]
                 message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1],
                                                                                          class_instance.__class__.__name__)
                 for method in methods:

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class GetStaticFieldHandler(AbstractCommandHandler):
@@ -13,9 +14,9 @@ class GetStaticFieldHandler(AbstractCommandHandler):
             clazz = command.payload[0]
             field = command.payload[1]
             try:
-                value = getattr(clazz, field)
+                value = LazyModuleLoader.safe_getattr(clazz, field)
             except:
-                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
+                fields = [field for field in dir(clazz) if not callable(LazyModuleLoader.safe_getattr(clazz, field))]
                 message = "Field {} not found in class {}. Available fields:\n".format(field, clazz.__name__)
                 for field in fields:
                     message += "{}\n".format(field)

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class GetStaticMethodAsDelegateHandler(AbstractCommandHandler):
@@ -13,9 +14,9 @@ class GetStaticMethodAsDelegateHandler(AbstractCommandHandler):
 
             clazz = command.payload[0]
             try:
-                method = getattr(clazz, command.payload[1])
+                method = LazyModuleLoader.safe_getattr(clazz, command.payload[1])
             except AttributeError:
-                methods = [method for method in dir(clazz) if callable(getattr(clazz, method))]
+                methods = [method for method in dir(clazz) if callable(LazyModuleLoader.safe_getattr(clazz, method))]
                 message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1],
                                                                                          clazz.__name__)
                 for method in methods:

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

@@ -1,3 +1,4 @@
+import ast
 import importlib
 import inspect
 import logging
@@ -9,6 +10,7 @@ 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
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class GetTypeHandler(AbstractCommandHandler):
@@ -53,7 +55,10 @@ class GetTypeHandler(AbstractCommandHandler):
         if len(command.payload) == 1:
             type_name = command.payload[0].split(".")
             if len(type_name) == 1:
-                return import_module(type_name[0])
+                module = LazyModuleLoader.get_module(type_name[0])
+                if module is None:
+                    raise ImportError(f"Module {type_name[0]} not found")
+                return module
             else:
                 return self._get_type_from_nested_payload(type_name)
         else:
@@ -62,10 +67,13 @@ class GetTypeHandler(AbstractCommandHandler):
     def _get_type_from_nested_payload(self, payload):
         module_name = ".".join(payload[:-1])
         class_name = payload[-1]
-        loaded_module = import_module(module_name)
+        loaded_module = LazyModuleLoader.get_module(module_name)
+        if loaded_module is None:
+            raise ImportError(f"Module {module_name} not found")
         return getattr(loaded_module, class_name)
 
     def get_all_available_types(self):
+        """Get all available types without loading/executing any modules."""
         available_types = set()
         for directory in LoadLibraryHandler.loaded_directories:
             for root, _, files in os.walk(directory):
@@ -73,13 +81,40 @@ class GetTypeHandler(AbstractCommandHandler):
                     continue
                 for file in files:
                     if file.lower().endswith(".py") and file != "__init__.py":
+                        file_path = os.path.join(root, file)
                         module_name = os.path.splitext(file)[0]
                         module_path = os.path.relpath(os.path.join(root, module_name), directory).replace(os.sep, ".")
+                        
                         try:
-                            module = importlib.import_module(module_path)
-                            for name, obj in inspect.getmembers(module, inspect.isclass):
-                                qualified_name = f"{module_path}.{name}"
+                            # Extract class names using AST without executing code
+                            class_names = self._extract_classes_from_file(file_path)
+                            for class_name in class_names:
+                                qualified_name = f"{module_path}.{class_name}"
                                 available_types.add(qualified_name)
                         except Exception:
+                            # Skip files that can't be parsed
                             pass
-        return list(available_types)
+        return sorted(list(available_types))
+
+    def _extract_classes_from_file(self, file_path):
+        """Extract class names from a Python file using AST parsing (no code execution)."""
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+            
+            # Parse the file into an Abstract Syntax Tree
+            tree = ast.parse(content, filename=file_path)
+            class_names = []
+            
+            # Walk through all nodes in the AST
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef):
+                    # Only include public classes (not starting with underscore)
+                    if not node.name.startswith('_'):
+                        class_names.append(node.name)
+            
+            return class_names
+            
+        except (SyntaxError, UnicodeDecodeError, FileNotFoundError, OSError):
+            # Return empty list if file can't be parsed or read
+            return []

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

@@ -1,6 +1,7 @@
 import importlib
 from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 from javonet.utils.CommandType import CommandType
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class InvokeGlobalFunctionHandler(AbstractCommandHandler):
@@ -23,7 +24,9 @@ class InvokeGlobalFunctionHandler(AbstractCommandHandler):
             module_name, function_name = full_function_name.rsplit('.', 1)
 
             try:
-                module = importlib.import_module(module_name)
+                module = LazyModuleLoader.get_module(module_name)
+                if module is None:
+                    raise ImportError(f"Could not import module '{module_name}'.")
             except ImportError as e:
                 raise ImportError(f"Could not import module '{module_name}'.") from e
 

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

@@ -1,5 +1,6 @@
 from javonet.core.handler.AbstractCommandHandler import *
 from javonet.utils.CommandType import CommandType
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class InvokeInstanceMethodHandler(AbstractCommandHandler):
@@ -14,9 +15,9 @@ class InvokeInstanceMethodHandler(AbstractCommandHandler):
 
             class_instance = command.payload[0]
             try:
-                method = getattr(class_instance, command.payload[1])
+                method = LazyModuleLoader.safe_getattr(class_instance, command.payload[1])
             except AttributeError:
-                methods = [method for method in dir(class_instance) if callable(getattr(class_instance, method))]
+                methods = [method for method in dir(class_instance) if callable(LazyModuleLoader.safe_getattr(class_instance, method))]
                 message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], class_instance.__class__.__name__)
                 for method in methods:
                     message += "{}\n".format(method)

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

@@ -1,5 +1,6 @@
 from javonet.core.handler.AbstractCommandHandler import *
 from javonet.utils.CommandType import CommandType
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class InvokeStaticMethodHandler(AbstractCommandHandler):
@@ -14,9 +15,9 @@ class InvokeStaticMethodHandler(AbstractCommandHandler):
 
             clazz = command.payload[0]
             try:
-                method = getattr(clazz, command.payload[1])
+                method = LazyModuleLoader.safe_getattr(clazz, command.payload[1])
             except AttributeError:
-                methods = [method for method in dir(clazz) if callable(getattr(clazz, method))]
+                methods = [method for method in dir(clazz) if callable(LazyModuleLoader.safe_getattr(clazz, method))]
                 message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], clazz.__name__)
                 for method in methods:
                     message += "{}\n".format(method)

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

@@ -3,6 +3,7 @@ import os
 import sys
 
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class LoadLibraryHandler(AbstractCommandHandler):
@@ -20,11 +21,9 @@ class LoadLibraryHandler(AbstractCommandHandler):
                 sys.path.append(command.payload[0])
                 LoadLibraryHandler.loaded_directories.append(command.payload[0])
             elif os.path.isfile(command.payload[0]) and command.payload[0].endswith(".py"):
+                # Use LazyModuleLoader for proper lazy loading
                 module_name = os.path.splitext(os.path.basename(command.payload[0]))[0]
-                spec = importlib.util.spec_from_file_location(module_name, command.payload[0])
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)
-                sys.modules[module_name] = module
+                LazyModuleLoader.register_module_path(module_name, command.payload[0])
                 LoadLibraryHandler.loaded_directories.append(os.path.dirname(command.payload[0]))
             else:
                 raise Exception(command.payload[0] + " is not a valid directory or .py file")
@@ -37,4 +36,4 @@ class LoadLibraryHandler(AbstractCommandHandler):
 
     @staticmethod
     def get_loaded_directories():
-        return LoadLibraryHandler.loaded_directories
+        return LoadLibraryHandler.loaded_directories

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class SetInstanceFieldHandler(AbstractCommandHandler):
@@ -16,7 +17,7 @@ class SetInstanceFieldHandler(AbstractCommandHandler):
             try:
                 setattr(instance, field, new_value)
             except AttributeError:
-                fields = [field for field in dir(instance) if not callable(getattr(instance, field))]
+                fields = [field for field in dir(instance) if not callable(LazyModuleLoader.safe_getattr(instance, field))]
                 message = "Field {} not found in class {}. Available fields:\n".format(field, instance.__class__.__name__)
                 for field in fields:
                     message += "{}\n".format(field)

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

@@ -1,4 +1,5 @@
 from javonet.core.handler.AbstractCommandHandler import *
+from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class SetStaticFieldHandler(AbstractCommandHandler):
@@ -17,7 +18,7 @@ class SetStaticFieldHandler(AbstractCommandHandler):
             try:
                 setattr(clazz, field, new_value)
             except AttributeError:
-                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
+                fields = [field for field in dir(clazz) if not callable(LazyModuleLoader.safe_getattr(clazz, field))]
                 message = "Field {} not found in class {}. Available fields:\n".format(field, clazz.__name__)
                 for field in fields:
                     message += "{}\n".format(field)

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

@@ -26,7 +26,7 @@ class Interpreter:
         elif (command.runtime_name == RuntimeName.python) & (
                 connection_data.connection_type == ConnectionType.InMemory):
             from javonet.core.receiver.Receiver import Receiver
-            response_byte_array = Receiver().SendCommand(message_byte_array, len(message_byte_array))
+            response_byte_array = Receiver().SendCommand(message_byte_array)
         else:
             from javonet.core.transmitter.Transmitter import Transmitter
             response_byte_array = Transmitter.send_command(message_byte_array)

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

@@ -33,7 +33,7 @@ class Receiver:
         # Register the custom exception handler
         sys.excepthook = custom_excepthook
 
-    def SendCommand(self, message_byte_array, messageByteArrayLen):
+    def SendCommand(self, message_byte_array):
         try:
             result = Interpreter().process(message_byte_array)
             return bytearray(CommandSerializer().serialize(result, self.connection_data))
@@ -44,7 +44,7 @@ class Receiver:
             )
             return bytearray(CommandSerializer().serialize(exception_command, self.connection_data))
 
-    def HeartBeat(self, message_byte_array, messageByteArrayLen):
+    def HeartBeat(self, message_byte_array):
         response_byte_array = bytearray(2)
         response_byte_array[0] = message_byte_array[11]
         response_byte_array[1] = message_byte_array[12] - 2

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

@@ -0,0 +1,55 @@
+import importlib
+import importlib.util
+import sys
+from typing import Optional, Any
+
+
+class LazyModuleLoader:
+    """Centralized module loader that only executes code when actually needed."""
+    _loaded_specs = {}
+    
+    @classmethod
+    def register_module_path(cls, module_name: str, file_path: str):
+        """Register a module for lazy loading without executing it."""
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        cls._loaded_specs[module_name] = spec
+    
+    @classmethod
+    def get_module(cls, module_name: str) -> Optional[Any]:
+        """Get module, loading it only if necessary."""
+        # Check if already loaded
+        if module_name in sys.modules:
+            return sys.modules[module_name]
+        
+        # Check if we have a spec for lazy loading
+        if module_name in cls._loaded_specs:
+            spec = cls._loaded_specs[module_name]
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)  # Execute only when needed
+            sys.modules[module_name] = module
+            return module
+        
+        # Try standard import as fallback
+        try:
+            return importlib.import_module(module_name)
+        except ImportError:
+            return None
+    
+    @classmethod
+    def is_module_available(cls, module_name: str) -> bool:
+        """Check if module is available without loading it."""
+        return (module_name in sys.modules or 
+                module_name in cls._loaded_specs or
+                importlib.util.find_spec(module_name) is not None)
+    
+    @classmethod
+    def safe_getattr(cls, obj, name):
+        """Safely get attribute without triggering property getters with side effects."""
+        try:
+            # Use object.__getattribute__ to bypass descriptors when possible
+            return object.__getattribute__(obj, name)
+        except AttributeError:
+            try:
+                return getattr(obj, name)
+            except Exception:
+                raise AttributeError(f"Attribute {name} not found in {obj}")