javonet-ruby-sdk 2.6.7 → 2.6.10

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/protocol/CommandSerializer.php

@@ -16,53 +16,95 @@ use utils\TypesHandler;
 
 final class CommandSerializer
 {
+    private const DEFAULT_SERIALIZER_CONNECTION_DATA = [0, 0, 0, 0, 0, 0, 0];
+
     private function __construct()
     {
     }
 
-    private const DEFAULT_SERIALIZER_CONNECTION_DATA = [0, 0, 0, 0, 0, 0, 0];
-
+    /**
+     * Serialize command to array of bytes (ints 0–255).
+     *
+     * @return int[]
+     */
     public static function serialize(CommandInterface $rootCommand, ?IConnectionData $connectionData): array
     {
         try {
+            $buffer = [];
+
+            // Write runtime and version
             $buffer[] = $rootCommand->getRuntimeName()->getValue();
             $buffer[] = 0; // runtimeVersion
-            array_push($buffer, ...self::getDataByConnectionData($connectionData));
-            $buffer[] = RuntimeName::PHP;
-            $buffer[] = $rootCommand->getCommandType()->getValue();
 
+            // Write connection data
+            self::insertIntoBuffer($buffer, self::getDataByConnectionData($connectionData));
+
+            // Write runtime name and command type header for PHP runtime
+            self::insertIntoBuffer($buffer, [
+                RuntimeName::PHP,
+                $rootCommand->getCommandType()->getValue(),
+            ]);
+
+            // Serialize payload recursively
             self::serializeRecursively($rootCommand, $buffer);
 
             return $buffer;
         } catch (Exception $e) {
-            throw new RuntimeException('Error during serialization ' . $e);
+            throw new RuntimeException(
+                'Error during serialization: ' . $e->getMessage(),
+                0,
+                $e
+            );
         }
     }
 
+    /**
+     * @return int[]
+     */
     private static function getDataByConnectionData(?IConnectionData $connectionData): array
     {
-        if (null !== $connectionData) {
+        if ($connectionData !== null) {
             return $connectionData->serializeConnectionData();
         }
 
         return self::DEFAULT_SERIALIZER_CONNECTION_DATA;
     }
 
+    /**
+     * @param int[] $buffer
+     * @param int[] $data
+     */
+    private static function insertIntoBuffer(array &$buffer, array $data): void
+    {
+        foreach ($data as $value) {
+            $buffer[] = $value;
+        }
+    }
+
+    /**
+     * @param int[] $buffer
+     */
     private static function serializeRecursively(CommandInterface $command, array &$buffer): void
     {
         foreach ($command->getPayload() as $payloadItem) {
             if ($payloadItem instanceof CommandInterface) {
-                array_push($buffer, ...TypeSerializer::serializeCommand($payloadItem));
+                // Nested command
+                self::insertIntoBuffer($buffer, TypeSerializer::serializeCommand($payloadItem));
                 self::serializeRecursively($payloadItem, $buffer);
-            } else if (TypesHandler::isSimpleType($payloadItem)) {
-                array_push($buffer, ...TypeSerializer::serializePrimitive($payloadItem));
+            } elseif (TypesHandler::isSimpleType($payloadItem)) {
+                // Primitive or simple type
+                self::insertIntoBuffer($buffer, TypeSerializer::serializePrimitive($payloadItem));
             } else {
+                // Complex object – serialize as reference command
+                $referenceId = ReferencesCache::getInstance()->cacheReference($payloadItem);
+
                 $refCommand = new Command(
-                    $command->getRuntimeName(),
+                    new RuntimeName(RuntimeName::PHP),
                     CommandType::REFERENCE(),
-                    ReferencesCache::getInstance()->cacheReference($payloadItem)
+                    $referenceId
                 );
-                array_push($buffer, ...TypeSerializer::serializeCommand($refCommand));
+
+                self::insertIntoBuffer($buffer, TypeSerializer::serializeCommand($refCommand));
                 self::serializeRecursively($refCommand, $buffer);
             }
         }

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

@@ -11,18 +11,23 @@ final class Command implements CommandInterface
 {
     private RuntimeName $runtimeName;
     private CommandType $commandType;
+    /** @var array<mixed> */
     private array $payload;
 
     public function __construct(
         RuntimeName $runtimeName,
         CommandType $commandType,
-        ...$payload
+                    ...$payload
     ) {
         $this->runtimeName = $runtimeName;
         $this->commandType = $commandType;
-        $this->payload = count($payload) === 1 && is_array($payload[0])
-            ? $payload[0]
-            : $payload;
+
+        // If a single array is passed, treat it as the payload itself.
+        if (count($payload) === 1 && is_array($payload[0])) {
+            $this->payload = $payload[0];
+        } else {
+            $this->payload = $payload;
+        }
     }
 
     /**
@@ -30,7 +35,11 @@ final class Command implements CommandInterface
      */
     public function addArgToPayload($arg): CommandInterface
     {
-        return new Command($this->runtimeName, $this->commandType, array_merge($this->payload, [$arg]));
+        // Keep semantics (return new Command) but avoid array_merge overhead.
+        $newPayload = $this->payload;
+        $newPayload[] = $arg;
+
+        return new Command($this->runtimeName, $this->commandType, $newPayload);
     }
 
     /**
@@ -51,6 +60,9 @@ final class Command implements CommandInterface
         return $this->commandType;
     }
 
+    /**
+     * @return array<mixed>
+     */
     public function getPayload(): array
     {
         return $this->payload;
@@ -84,14 +96,14 @@ final class Command implements CommandInterface
             $result .= ' CommandType: ';
             $result .= $this->commandType->getName();
             $result .= ' Payload: ';
-            json_encode($this->payload);
+            $result .= json_encode($this->payload);
 
             return $result;
         } catch (Exception $e) {
             return 'Error while converting command to string: ' . $e->getMessage();
         }
     }
-    
+
     /**
      * @param mixed $response
      */
@@ -116,7 +128,11 @@ final class Command implements CommandInterface
             return new self($this->runtimeName, $this->commandType, $this->payload);
         }
 
-        return new self($this->runtimeName, $this->commandType, [$currentCommand, ...$this->payload]);
+        return new self(
+            $this->runtimeName,
+            $this->commandType,
+            [$currentCommand, ...$this->payload]
+        );
     }
 
     /**
@@ -147,15 +163,17 @@ final class Command implements CommandInterface
                 if (!$payloadItem->equals($elementPayloadItem)) {
                     return false;
                 }
+                continue;
             }
 
             if (is_object($payloadItem) && method_exists($payloadItem, 'equals') && is_object($elementPayloadItem)) {
                 if (!$payloadItem->equals($elementPayloadItem)) {
                     return false;
                 }
+                continue;
             }
 
-            elseif ($payloadItem !== $elementPayloadItem) {
+            if ($payloadItem !== $elementPayloadItem) {
                 return false;
             }
         }

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

@@ -1,4 +1,4 @@
-from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import *
 
 class AsOutHandler(AbstractCommandHandler):
     def process(self, command):

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

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

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

@@ -47,7 +47,7 @@ class GetTypeHandler(AbstractCommandHandler):
             exc_type, exc_value = type(e), e
             sys_path = "\n".join(sys.path)
             available_types = "\n".join(self.get_all_available_types())
-            new_message = str(e) + "\nMake sure to install python packages in one of this directories:\n" + sys_path  + "\n\nAvailable user types:\n" + available_types + "\n\n"
+            new_message = str(e) + "\nMake sure that your python solution is in one of this directories:\n" + sys_path  + "\n\nAvailable user types:\n" + available_types + "\n\n"
             new_exc = exc_type(new_message).with_traceback(e.__traceback__)
             raise new_exc from None
 
@@ -75,7 +75,7 @@ class GetTypeHandler(AbstractCommandHandler):
     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 directory in LoadLibraryHandler.loaded_dir_and_files:
             for root, _, files in os.walk(directory):
                 if "Binaries" in root:
                     continue

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

@@ -47,6 +47,8 @@ from javonet.core.handler.GetAsyncOperationResultHandler import GetAsyncOperatio
 from javonet.core.handler.GetKwargHandler import GetKwargHandler
 from javonet.core.handler.GetResultTypeHandler import GetResultTypeHandler
 from javonet.core.handler.GetGlobalFieldHandler import GetGlobalFieldHandler
+from javonet.core.handler.RegisterForUpdateHandler import RegisterForUpdateHandler
+from javonet.core.handler.ValueForUpdateHandler import ValueForUpdateHandler
 
 
 from javonet.core.handler.HandlerDictionary import handler_dict
@@ -108,6 +110,8 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.AsKwargs] = GetKwargHandler()
         handler_dict[CommandType.GetResultType] = GetResultTypeHandler()
         handler_dict[CommandType.GetGlobalField] = GetGlobalFieldHandler()
+        handler_dict[CommandType.RegisterForUpdate] = RegisterForUpdateHandler()
+        handler_dict[CommandType.ValueForUpdate] = ValueForUpdateHandler()
 
     def handle_command(self, command):
         try:
@@ -115,8 +119,29 @@ class Handler(AbstractHandler):
                 response_array = handler_dict[CommandType.Reference].handle_command(command.payload[0])
                 return Command.create_array_response(response_array, command.runtime_name)
 
+            # Preprocess PluginWrapper before routing to specific handler
+            if command.command_type == CommandType.PluginWrapper:
+                command = PluginWrapperHandler().handle_command(command)
+
             response = handler_dict.get(command.command_type).handle_command(command)
-            return self.__parse_response(response, command.runtime_name)
+            parsed = self.__parse_response(response, command.runtime_name)
+
+            # Append ValueForUpdate commands from RegisterForUpdateHandler contexts
+            contexts = RegisterForUpdateHandler._invocation_contexts.map
+            if contexts and len(contexts) > 0:
+                for guid, instance in list(contexts.items()):
+                    instance_guid = ReferencesCache().cache_reference(instance)
+                    update_cmd = Command(
+                        command.runtime_name,
+                        CommandType.ValueForUpdate,
+                        [str(guid) if guid is not None else "",
+                        instance_guid]
+                    )
+                    parsed = parsed.add_arg_to_payload(update_cmd)
+                # Clear all entries after processing this request
+                contexts.clear()
+
+            return parsed
         except Exception as e:
             return ExceptionSerializer.serialize_exception(e, command)
 

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

@@ -1,13 +1,15 @@
-import importlib.util
 import os
 import sys
+import py_compile
+from argparse import ArgumentError
 
 from javonet.core.handler.AbstractCommandHandler import *
 from javonet.utils.LazyModuleLoader import LazyModuleLoader
 
 
 class LoadLibraryHandler(AbstractCommandHandler):
-    loaded_directories = []
+    # Track loaded directories/files by absolute path
+    loaded_dir_and_files = set()
 
     def __init__(self):
         self._required_parameters_count = 1
@@ -17,23 +19,61 @@ class LoadLibraryHandler(AbstractCommandHandler):
             if len(command.payload) != self._required_parameters_count:
                 raise Exception("LoadLibrary payload parameters mismatch")
 
-            if os.path.isdir(command.payload[0]):
-                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]
-                LazyModuleLoader.register_module_path(module_name, command.payload[0])
-                LoadLibraryHandler.loaded_directories.append(os.path.dirname(command.payload[0]))
+            dir_or_file_to_load = command.payload[0]
+
+            if not isinstance(dir_or_file_to_load, str) or not dir_or_file_to_load:
+                raise Exception("Library path is required and must be a non-empty string")
+
+            # ------------------------------------------------------------------
+            # Normalize file extension:
+            # - If no extension is provided and "<path>.py" exists, use that.
+            # ------------------------------------------------------------------
+            normalized_path = dir_or_file_to_load
+            root, ext = os.path.splitext(normalized_path)
+            if ext == "":
+                candidate = normalized_path + ".py"
+                if os.path.isfile(candidate):
+                    normalized_path = candidate
+
+            # Use absolute path for de-duplication
+            absolute_path = os.path.abspath(normalized_path)
+
+            # Ensure path exists
+            if not os.path.exists(absolute_path):
+                raise Exception(f"{dir_or_file_to_load} does not exist")
+
+            # ------------------------------------------------------------------
+            # Load only once (by absolute path)
+            # ------------------------------------------------------------------
+            if absolute_path in LoadLibraryHandler.loaded_dir_and_files:
+                return 0
+
+            if os.path.isdir(absolute_path):
+                # Add directory to sys.path only if not already present
+                if absolute_path not in sys.path:
+                    sys.path.append(absolute_path)
+
+            elif os.path.isfile(absolute_path) and absolute_path.endswith(".py"):
+                # ------------------------------------------------------------------
+                # Validate Python syntax before registering module
+                # ------------------------------------------------------------------
+                py_compile.compile(absolute_path, doraise=True)
+
+                module_name = os.path.splitext(os.path.basename(absolute_path))[0]
+                LazyModuleLoader.register_module_path(module_name, absolute_path)
             else:
-                raise Exception(command.payload[0] + " is not a valid directory or .py file")
+                raise Exception(f"{dir_or_file_to_load} is not a valid directory or .py file")
+
+            # Mark as loaded
+            LoadLibraryHandler.loaded_dir_and_files.add(absolute_path)
 
             return 0
+
         except Exception as e:
-            exc_type, exc_value = type(e), e
-            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            new_exc = ArgumentError(None, str(e)).with_traceback(e.__traceback__)
             raise new_exc from None
 
     @staticmethod
     def get_loaded_directories():
-        return LoadLibraryHandler.loaded_directories
+        # Return a list for external callers
+        return list(LoadLibraryHandler.loaded_dir_and_files)

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

@@ -0,0 +1,38 @@
+import threading
+from uuid import UUID
+from javonet.core.handler.AbstractCommandHandler import *
+
+class _ThreadContexts(threading.local):
+    def __init__(self):
+        # guid (UUID or empty GUID) -> object
+        self.map = {}
+
+class RegisterForUpdateHandler(AbstractCommandHandler):
+    # Shared per process, separate dicts per thread
+    _invocation_contexts = _ThreadContexts()
+    _required_parameters_count = 2
+
+    @classmethod
+    def _get_or_create_context_dict(cls):
+        if getattr(cls._invocation_contexts, "map", None) is None:
+            cls._invocation_contexts.map = {}
+        return cls._invocation_contexts.map
+
+    def process(self, command):
+        # Validate minimal number of parameters
+        if command.payload is None or len(command.payload) < self._required_parameters_count:
+            raise ValueError(f"{self.__class__.__name__} requires at least {self._required_parameters_count} parameter(s).")
+
+        obj_to_register = command.payload[0]
+        guid_to_register = None
+        if len(command.payload) > 1 and command.payload[1]:
+            try:
+                guid_to_register = UUID(str(command.payload[1]))
+            except Exception:
+                # If invalid GUID, treat as no GUID
+                guid_to_register = None
+
+        ctx = self._get_or_create_context_dict()
+        # Use None as key when GUID is missing (analogous to Guid.Empty)
+        ctx[guid_to_register] = obj_to_register
+        return obj_to_register

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

@@ -0,0 +1,6 @@
+from javonet.core.handler.AbstractCommandHandler import *
+
+class ValueForUpdateHandler(AbstractCommandHandler):
+    def process(self, command):
+        # Special-cased in Handler.handle_command; placeholder only.
+        raise NotImplementedError(f"{self.__class__.__name__} is not implemented in Python.")

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

@@ -49,4 +49,6 @@ class CommandType(Enum):
     GetAsyncOperationResult = 44
     AsKwargs = 45
     GetResultType = 46
-    GetGlobalField = 47
+    GetGlobalField = 47
+    RegisterForUpdate = 48
+    ValueForUpdate = 49