javonet-ruby-sdk 2.5.14 → 2.5.16

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/PerlCommandType.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::PerlCommandType;
 use strict;
 use warnings;
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_command_type);
 
 my %command_type = (
     'Value'                     => 0,

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/RuntimeLib.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::RuntimeLib;
 use warnings;
 use strict;
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_runtime);
 
 my %runtimes = (
     'Clr'       => 0,
@@ -12,7 +14,9 @@ my %runtimes = (
     'Python'    => 5,
     'Ruby'      => 6,
     'Nodejs'    => 7,
-    'Cpp'       => 8
+    'Cpp'       => 8,
+    'Php'       => 9,
+    'Python2'   => 10
 );
 
 sub get_runtime {

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/RuntimeLogger.pm

@@ -1,19 +1,22 @@
 package Javonet::Sdk::Core::RuntimeLogger;
 use strict;
 use warnings;
+use Exporter qw(import);
+our @EXPORT = qw(rl_get_runtime_info print_runtime_info);
+
 use Config qw(%Config);
 use Cwd;
 use Sys::Hostname;
 
-our $not_logged_yet = 1;
+my $not_logged_yet = 1;
 
-sub get_runtime_info {
+sub rl_get_runtime_info {
     my $info;
     eval {
         $info = "Perl Managed Runtime Info:\n" .
             "Perl Version: $]\n" .
             "Perl executable path: $^X\n" .
-            "Perl \@INC Path: @INC\n" .
+            "Perl \\@INC Path: @INC\n" .
             "OS Version: " . $Config{osname} . " " . $Config{osvers} . "\n" .
             "Process Architecture: " . $Config{archname} . "\n" .
             "Current Working Directory: " . getcwd() . "\n";

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/StringEncodingMode.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::StringEncodingMode;
 use strict;
 use warnings;
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_string_encoding_mode);
 
 my %string_encoding_mode = (
     'ASCII'             => 0,

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/Type.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::Type;
 use strict;
 use warnings FATAL => 'all';
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_type);
 
 my %my_type = (
     'Command' => 0,

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/Abstract/AbstractRuntimeFactory.pm

@@ -19,6 +19,8 @@ sub nodejs : Abstract;
 
 sub python : Abstract;
 
+sub python27 : Abstract;
+
 
 no Moose;
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/RuntimeContext.pm

@@ -9,7 +9,7 @@ use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter', qw(execute_);
 use aliased 'Javonet::Core::Exception::ExceptionThrower' => 'ExceptionThrower';
 
-extends 'Javonet::Sdk::Internal::Abstract::AbstractModuleContext',
+extends 'Javonet::Sdk::Internal::Abstract::AbstractRuntimeContext',
     'Javonet::Sdk::Internal::Abstract::AbstractTypeContext';
 
 my $perl_handler = Javonet::Core::Handler::PerlHandler->new();

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/RuntimeFactory.pm

@@ -99,6 +99,16 @@ sub python {
     );
 }
 
+#@override
+sub python27 {
+    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
+        Javonet::Sdk::Core::RuntimeLib::get_runtime('Python27'),
+        $connection_type,
+        $tcp_address,
+        $path
+    );
+}
+
 
 no Moose;
 1;

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

@@ -45,7 +45,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) + "\nLoaded directories:\n" + sys_path  + "\nAvailable user types:\n" + available_types + "\n\n\n"
+            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_exc = exc_type(new_message).with_traceback(e.__traceback__)
             raise new_exc from None
 

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

@@ -1,9 +1,11 @@
-from javonet.core.handler.AbstractCommandHandler import *
-import sys
+import importlib.util
 import os
+import sys
+
+from javonet.core.handler.AbstractCommandHandler import *
 
-class LoadLibraryHandler(AbstractCommandHandler):
 
+class LoadLibraryHandler(AbstractCommandHandler):
     loaded_directories = []
 
     def __init__(self):
@@ -17,8 +19,15 @@ class LoadLibraryHandler(AbstractCommandHandler):
             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"):
+                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
+                LoadLibraryHandler.loaded_directories.append(os.path.dirname(command.payload[0]))
             else:
-                raise Exception(command.payload[0] + " is not a valid directory")
+                raise Exception(command.payload[0] + " is not a valid directory or .py file")
 
             return 0
         except Exception as e:
@@ -28,4 +37,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/protocol/CommandDeserializer.py

@@ -48,7 +48,10 @@ class CommandDeserializer:
             Type.JavonetUnsignedInteger: self.read_uint,
             Type.JavonetNoneType: self.read_none
         }
-        return switch.get(type_value, lambda: Exception("Type not supported"))()
+        func = switch.get(type_value)
+        if func is None:
+            raise Exception("Type not supported")
+        return func()
 
     def read_command(self):
         p = self.position

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

@@ -1,7 +1,6 @@
 import os
 import platform
 from ctypes import *
-
 from javonet.core.callback.callbackFunc import callbackFunc
 
 CMPFUNC = CFUNCTYPE(py_object, POINTER(c_ubyte), c_int)
@@ -9,61 +8,63 @@ callbackFunction = CMPFUNC(callbackFunc)
 
 
 class TransmitterWrapper:
-    file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-    machine = platform.machine().lower()
-    if '64' in machine:
-        arch = 'X64'
-    elif 'arm' in machine:
-        arch = 'ARM64' if '64' in machine else 'ARM'
-    else:
-        arch = 'X86'
-
-    if platform.system() == 'Windows':
-        python_lib_path = file_path + f'/Binaries/Native/Windows/{arch}/JavonetPythonRuntimeNative.dll'
-    elif platform.system() == 'Linux':
-        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 = None
 
-    python_lib = cdll.LoadLibrary(python_lib_path)
-    python_lib.SetCallback(callbackFunction)
+    @staticmethod
+    def get_native_lib():
+        if TransmitterWrapper._python_lib is None:
+            file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            machine = platform.machine().lower()
+            if '64' in machine:
+                arch = 'X64'
+            elif 'arm' in machine:
+                arch = 'ARM64' if '64' in machine else 'ARM'
+            else:
+                arch = 'X86'
+
+            if platform.system() == 'Windows':
+                python_lib_path = file_path + f'/Binaries/Native/Windows/{arch}/JavonetPythonRuntimeNative.dll'
+            elif platform.system() == 'Linux':
+                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())
+            lib = cdll.LoadLibrary(python_lib_path)
+            lib.SetCallback(callbackFunction)
+            TransmitterWrapper._python_lib = lib
+        return TransmitterWrapper._python_lib
 
     @staticmethod
     def send_command(message):
+        lib = TransmitterWrapper.get_native_lib()
         message_array = bytearray(message)
         message_ubyte_array = c_ubyte * len(message_array)
-        response_array_len = TransmitterWrapper.python_lib.SendCommand(
-            message_ubyte_array.from_buffer(message_array),
-            len(message_array))
+        response_array_len = lib.SendCommand(message_ubyte_array.from_buffer(message_array), len(message_array))
         if response_array_len > 0:
             response = bytearray(response_array_len)
             response_ubyte_array = c_ubyte * response_array_len
-            TransmitterWrapper.python_lib.ReadResponse(response_ubyte_array.from_buffer(response),
-                                                       response_array_len)
+            lib.ReadResponse(response_ubyte_array.from_buffer(response), response_array_len)
             return response
         elif response_array_len == 0:
             error_message = "Response is empty"
             raise RuntimeError(error_message)
         else:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
-            raise RuntimeError(
-                "Javonet native error code: " + str(response_array_len) + ". " + str(error_message))
+            raise RuntimeError("Javonet native error code: " + str(response_array_len) + ". " + str(error_message))
 
     @staticmethod
     def activate(license_key):
-        activate = TransmitterWrapper.python_lib.Activate
+        lib = TransmitterWrapper.get_native_lib()
+        activate = lib.Activate
         activate.restype = c_int
         activate.argtypes = [c_char_p]
-
         activation_result = activate(license_key.encode('ascii'))
-
         if activation_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
@@ -74,15 +75,14 @@ class TransmitterWrapper:
             return activation_result
 
     @staticmethod
-    def set_config_source(sourcePath):
-        set_config_source = TransmitterWrapper.python_lib.SetConfigSource
+    def set_config_source(source_path):
+        lib = TransmitterWrapper.get_native_lib()
+        set_config_source = lib.SetConfigSource
         set_config_source.restype = c_int
         set_config_source.argtypes = [c_char_p]
-
-        set_config_result = set_config_source(sourcePath.encode('utf-8'))
-
+        set_config_result = set_config_source(source_path.encode('utf-8'))
         if set_config_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
@@ -94,19 +94,17 @@ class TransmitterWrapper:
 
     @staticmethod
     def set_javonet_working_directory(path):
-        set_working_directory = TransmitterWrapper.python_lib.SetWorkingDirectory
+        lib = TransmitterWrapper.get_native_lib()
+        set_working_directory = lib.SetWorkingDirectory
         set_working_directory.restype = c_int
         set_working_directory.argtypes = [c_char_p]
-
         set_working_directory_result = set_working_directory(path.encode('utf-8'))
-
         if set_working_directory_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
-            raise RuntimeError(
-                "Javonet set working directory result: " + str(set_working_directory_result) + ". Native error message: " + str(
-                    error_message))
+            raise RuntimeError("Javonet set working directory result: " + str(
+                set_working_directory_result) + ". Native error message: " + str(error_message))
         else:
-            return set_working_directory_result
+            return set_working_directory_result

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

@@ -11,6 +11,8 @@ class RuntimeName(Enum):
     ruby = 6
     nodejs = 7
     cpp = 8
+    php = 9
+    python27 = 10
 
     def __str__(self):
         return self.name

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

@@ -22,5 +22,9 @@ class RuntimeNameHandler:
                 return "ruby"
             elif runtime_name == RuntimeName.nodejs:
                 return "nodejs"
+            elif runtime_name == RuntimeName.php:
+                return "php"
+            elif runtime_name == RuntimeName.python27:
+                return "python27"
         else:
             raise Exception("Invalid runtime name.")

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

@@ -1,9 +1,7 @@
 import os
 import traceback
 
-from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
 from javonet.utils.ExceptionType import ExceptionType
-
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 
@@ -17,28 +15,36 @@ class ExceptionSerializer:
         trace = traceback.extract_tb(tb)
         exception_message = str(exception)
         exception_name = exception.__cause__.__class__.__name__
-        stack_classes = PythonStringBuilder()
-        stack_methods = PythonStringBuilder()
-        stack_lines = PythonStringBuilder()
-        stack_files = PythonStringBuilder()
+
+        # Use lists to collect strings, then join using the pipe separator.
+        stack_classes = []
+        stack_methods = []
+        stack_lines = []
+        stack_files = []
 
         is_debug = False
 
         for frame_summary in trace:
             if "javonet" not in frame_summary.filename or is_debug:
-                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename)).append("|")
-                stack_methods.append(frame_summary.name).append("|")
-                stack_lines.append(str(frame_summary.lineno)).append("|")
-                stack_files.append(frame_summary.filename).append("|")
+                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename))
+                stack_methods.append(frame_summary.name)
+                stack_lines.append(str(frame_summary.lineno))
+                stack_files.append(frame_summary.filename)
+
+        # Join list items with '|' and add a trailing '|' if needed.
+        stack_classes_str = "|".join(stack_classes) + "|" if stack_classes else ""
+        stack_methods_str = "|".join(stack_methods) + "|" if stack_methods else ""
+        stack_lines_str = "|".join(stack_lines) + "|" if stack_lines else ""
+        stack_files_str = "|".join(stack_files) + "|" if stack_files else ""
 
         exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
         exception_command = exception_command.add_arg_to_payload(str(command))
         exception_command = exception_command.add_arg_to_payload(exception_name)
         exception_command = exception_command.add_arg_to_payload(str(exception_message))
-        exception_command = exception_command.add_arg_to_payload(stack_classes.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_methods.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_lines.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_files.__str__())
+        exception_command = exception_command.add_arg_to_payload(stack_classes_str)
+        exception_command = exception_command.add_arg_to_payload(stack_methods_str)
+        exception_command = exception_command.add_arg_to_payload(stack_lines_str)
+        exception_command = exception_command.add_arg_to_payload(stack_files_str)
 
         return exception_command
 
@@ -57,4 +63,4 @@ class ExceptionSerializer:
 
     @staticmethod
     def format_class_name_from_file(filename):
-        return os.path.splitext((os.path.split(filename)[1]))[0]
+        return os.path.splitext(os.path.split(filename)[1])[0]

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/__init__.py

@@ -0,0 +1,32 @@
+"""
+Javonet Python SDK
+===================
+
+Javonet Python SDK is a library that allows Python developers to integrate and use modules or packages written in various languages like Java, Kotlin, Groovy, Clojure, C#, VB.NET, Ruby, Perl, JavaScript, TypeScript as if they were created in Python.
+
+How to use the documentation
+----------------------------
+Documentation is available in two forms: docstrings provided
+with the code, and a loose standing reference guide, available from
+`the Javonet homepage <https://www.javonet.com>`_.
+
+Getting Started
+---------------
+To use Javonet Python SDK, you need to have the runtime of the technology you want to call installed on your system. You can download the Javonet Python SDK from the PyPI public repository or from My Javonet Portal. 
+
+To install the package, use the following command:
+
+```bash
+pip install javonet-python2-sdk
+```
+You also need a license key to activate Javonet. You can get this key from the register or log in page on the Javonet website.
+
+First Sample Application
+Here's a simple example of how to use Javonet Python SDK:
+
+In this example, we're using Javonet to access a static field from a .NET Core library. You can use the same approach to access modules or packages from other technologies.
+
+Javonet Python SDK also supports remote operation, allowing you to interact with runtime objects on any remote node, container, or service. This makes it easy to switch between monolithic and microservices architectures without having to implement a separate integration layer.
+
+For more information on how to use Javonet Python SDK, including more detailed use cases and software architecture scenarios, please refer to the official Javonet documentation. 
+"""

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/callback/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The callback package contains callback function implementation.
+"""

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

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+The callbackFunc module implements the callback function.
+"""
+
+
+def callbackFunc(message_byte_array, message_byte_array_len):
+    """
+    Callback function handling messages.
+
+    :param message_byte_array: Message byte array
+    :param message_byte_array_len: Length of the byte array
+    :return: Response as byte array
+    """
+    from javonet.core.receiver.Receiver import Receiver
+    python_receiver = Receiver()
+    if message_byte_array[10] == 11:
+        return python_receiver.handle_heartbeat(message_byte_array, message_byte_array_len)
+    else:
+        return python_receiver.send_command(message_byte_array, message_byte_array_len) 

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

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+The DelegatesCache module implements caching for delegates.
+"""
+
+import uuid
+import threading
+from javonet.utils.CommandType import CommandType
+
+
+class DelegatesCache(object):
+    """
+    Class implementing caching for delegates.
+    """
+    _instance = None
+    delegates_cache = dict()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        """
+        Creates a new singleton instance of DelegatesCache.
+
+        :return: DelegatesCache instance
+        :rtype: DelegatesCache
+        """
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(DelegatesCache, cls).__new__(cls)
+        return cls._instance
+
+    def cache_delegate(self, object_delegate):
+        """
+        Caches a delegate object.
+
+        :param object_delegate: Delegate to cache
+        :return: UUID of the cached delegate
+        :rtype: str
+        """
+        with self._lock:
+            uuid_ = str(uuid.uuid4())
+            self.delegates_cache[uuid_] = object_delegate
+            return uuid_
+
+    def resolve_delegate(self, command):
+        """
+        Resolves a delegate from the cache.
+
+        :param command: Command containing delegate reference
+        :return: Cached delegate
+        :raises: Exception if delegate not found
+        """
+        if command.command_type != CommandType.Reference:
+            raise Exception("Failed to find delegate")
+        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):
+        """
+        Deletes a delegate from the cache.
+
+        :param delegate_guid: UUID of the delegate to delete
+        :return: 0 if successful
+        :raises: Exception if delegate not found
+        """
+        with self._lock:
+            try:
+                del self.delegates_cache[delegate_guid]
+                return 0
+            except KeyError:
+                raise Exception("Object not found in delegates") 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/delegateCache/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The delegateCache package contains delegate caching implementation.
+"""

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/AbstractCommandHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The AbstractCommandHandler class is the base class for command handlers.
+"""
+
+from javonet.core.handler.AbstractHandler import AbstractHandler
+from javonet.core.handler.HandlerDictionary import handler_dict
+from javonet.utils.Command import Command
+
+
+class AbstractCommandHandler(AbstractHandler):
+    """
+    Base class for command handlers.
+    """
+    def process(self, command):
+        """
+        Process the command. This method should be overridden by subclasses.
+        
+        :param command: Command to process
+        :return: Result of processing
+        """
+        pass
+
+    def handle_command(self, command):
+        """
+        Handle the command by iterating through payload and processing it.
+        
+        :param command: Command to handle
+        :return: Result of processing
+        """
+        self.__iterate(command)
+        return self.process(command)
+
+    @staticmethod
+    def __iterate(command):
+        """
+        Iterate through command payload and process nested commands.
+        
+        :param command: Command with payload to iterate
+        """
+        for i in range(0, len(command.payload)):
+            if isinstance(command.payload[i], Command):
+                handler = handler_dict.get(command.payload[i].command_type)
+                if handler is not None:
+                    command.payload[i] = handler.handle_command(command.payload[i]) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/AbstractHandler.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""
+The AbstractHandler class is the base class for all handlers in Javonet.
+"""
+
+
+class AbstractHandler(object):
+    def handle_command(self, command):
+        raise NotImplementedError('subclasses must override HandleCommand()!')

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/ArrayGetItemHandler.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""
+The ArrayGetItemHandler class handles retrieving array elements.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class ArrayGetItemHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving array elements.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new array element retrieval handler.
+        """
+        self._required_parameters_count = 2
+
+
+    def process(self, command):
+        """
+        Process the command.
+        
+        :param command: Command to process
+        :return: Result of the command
+        """
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("ArrayGetItemHandler parameters mismatch!")
+
+            array = command.payload[0]
+            if isinstance(command.payload[1], list):
+                indexes = command.payload[1]
+            else:
+                indexes = command.payload[1:]
+
+            array_copy = array[:]  # W Pythonie 2 używamy slicingu zamiast copy()
+            for i in indexes:
+                array_copy = array_copy[i]
+            return array_copy
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in ArrayGetItemHandler: {0}\n{1}".format(str(e), tb_str))