javonet-ruby-sdk 2.0.4 → 2.1.0

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GetInstanceFieldGeneratorHandler.py

@@ -1,13 +1,13 @@
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class GetInstanceFieldGeneratorHandler(AbstractGeneratorHandler):
     def generate_command(self, analyzed_object, parent_command, handlers):
-        get_instance_field_command = PythonCommand(RuntimeLib.python, PythonCommandType.GetInstanceField, [])
+        get_instance_field_command = Command(RuntimeName.python, CommandType.GetInstanceField, [])
         get_instance_field_command = get_instance_field_command.add_arg_to_payload(
             handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_command(analyzed_object.__name__,
                                                                                     get_instance_field_command,
@@ -30,7 +30,7 @@ class GetInstanceFieldGeneratorHandler(AbstractGeneratorHandler):
         existing_string_builder.append(" ")
         existing_string_builder.append("=")
         existing_string_builder.append(" ")
-        handlers.SHARED_BODY_HANDLER[PythonCommandType.GetInstanceField].generate_code(existing_string_builder,
-                                                                                       common_command,
-                                                                                       used_object,
-                                                                                       handlers)
+        handlers.SHARED_BODY_HANDLER[CommandType.GetInstanceField].generate_code(existing_string_builder,
+                                                                                 common_command,
+                                                                                 used_object,
+                                                                                 handlers)

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GetStaticFieldGeneratorHandler.py

@@ -1,14 +1,14 @@
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class GetStaticFieldGeneratorHandler(AbstractGeneratorHandler):
 
     def generate_command(self, analyzed_object, parent_command, handlers):
-        get_static_field_command = PythonCommand(RuntimeLib.python, PythonCommandType.GetStaticField, [])
+        get_static_field_command = Command(RuntimeName.python, CommandType.GetStaticField, [])
         get_static_field_command = get_static_field_command.add_arg_to_payload(
             handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_command(analyzed_object[0],
                                                                                     get_static_field_command, handlers))
@@ -34,6 +34,6 @@ class GetStaticFieldGeneratorHandler(AbstractGeneratorHandler):
         handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
                                                                              used_object.get_payload()[0], handlers)
         existing_string_builder.append(" = ")
-        handlers.SHARED_BODY_HANDLER[PythonCommandType.GetStaticField].generate_code(existing_string_builder,
-                                                                                     common_command,
-                                                                                     used_object, handlers)
+        handlers.SHARED_BODY_HANDLER[CommandType.GetStaticField].generate_code(existing_string_builder,
+                                                                               common_command,
+                                                                               used_object, handlers)

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GetTypeGeneratorHandler.py

@@ -2,14 +2,14 @@ import inspect
 
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class GetTypeGeneratorHandler(AbstractGeneratorHandler):
     def generate_command(self, analyzed_object, parent_command, handlers):
-        get_type_command = PythonCommand(RuntimeLib.python, PythonCommandType.GetType, [])
+        get_type_command = Command(RuntimeName.python, CommandType.GetType, [])
         get_type_command = get_type_command.add_arg_to_payload(analyzed_object.__name__)
         get_type_command = get_type_command.add_arg_to_payload(
             handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
@@ -25,20 +25,20 @@ class GetTypeGeneratorHandler(AbstractGeneratorHandler):
             if (method_type == 'classmethod' or method_type == 'function' or method_type == 'instancemethod') and (
                     method[0] == "__init__"):
                 get_type_command = get_type_command.add_arg_to_payload(
-                    handlers.GENERATOR_HANDLER[PythonCommandType.CreateClassInstance].generate_command(
+                    handlers.GENERATOR_HANDLER[CommandType.CreateClassInstance].generate_command(
                         clazz_constructor,
                         get_type_command,
                         handlers))
             if method_type == 'staticmethod':
                 get_type_command = get_type_command.add_arg_to_payload(
-                    handlers.GENERATOR_HANDLER[PythonCommandType.InvokeStaticMethod].generate_command(
+                    handlers.GENERATOR_HANDLER[CommandType.InvokeStaticMethod].generate_command(
                         method[1],
                         get_type_command,
                         handlers))
             if (method_type == 'classmethod' or method_type == 'function' or method_type == 'instancemethod') and (
                     method[0] != "__init__"):
                 get_type_command = get_type_command.add_arg_to_payload(
-                    handlers.GENERATOR_HANDLER[PythonCommandType.InvokeInstanceMethod].generate_command(
+                    handlers.GENERATOR_HANDLER[CommandType.InvokeInstanceMethod].generate_command(
                         method[1],
                         get_type_command,
                         handlers))
@@ -47,7 +47,7 @@ class GetTypeGeneratorHandler(AbstractGeneratorHandler):
             clazz_variables_dict[clazz_variable_name] = getattr(analyzed_object, clazz_variable_name)
         for dict_items in clazz_variables_dict.items():
             get_type_command = get_type_command.add_arg_to_payload(
-                handlers.GENERATOR_HANDLER[PythonCommandType.GetStaticField].generate_command(
+                handlers.GENERATOR_HANDLER[CommandType.GetStaticField].generate_command(
                     dict_items,
                     get_type_command,
                     handlers))

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/Handlers.py

@@ -14,7 +14,7 @@ from javonet.core.generator.handler.shared.body.SharedInvokeInstanceMethodBodyHa
     SharedInvokeInstanceMethodBodyHandler
 from javonet.core.generator.handler.shared.body.SharedInvokeStaticMethodBodyHandler import \
     SharedInvokeStaticMethodBodyHandler
-from javonet.sdk.core.PythonCommandType import PythonCommandType
+from javonet.utils.CommandType import CommandType
 
 from javonet.core.generator.handler.shared.SharedArgumentNameHandler import SharedArgumentNameHandler
 from javonet.core.generator.handler.shared.SharedClassInstanceHandler import SharedClassInstanceHandler
@@ -44,16 +44,16 @@ class Handlers:
         self.SHARED_HANDLER[SharedHandlerType.CLAZZ_INSTANCE] = SharedClassInstanceHandler()
         self.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE] = SharedReturnTypeHandler()
 
-        self.SHARED_BODY_HANDLER[PythonCommandType.CreateClassInstance] = SharedCreateInstanceBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.GetType] = SharedGetTypeBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.InvokeInstanceMethod] = SharedInvokeInstanceMethodBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.InvokeStaticMethod] = SharedInvokeStaticMethodBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.GetStaticField] = SharedGetStaticFieldBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.GetInstanceField] = SharedGetInstanceFieldBodyHandler()
-
-        self.GENERATOR_HANDLER[PythonCommandType.CreateClassInstance] = CreateInstanceGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.GetType] = GetTypeGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.InvokeInstanceMethod] = InvokeInstanceMethodGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.InvokeStaticMethod] = InvokeStaticMethodGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.GetStaticField] = GetStaticFieldGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.GetInstanceField] = GetInstanceFieldGeneratorHandler()
+        self.SHARED_BODY_HANDLER[CommandType.CreateClassInstance] = SharedCreateInstanceBodyHandler()
+        self.SHARED_BODY_HANDLER[CommandType.GetType] = SharedGetTypeBodyHandler()
+        self.SHARED_BODY_HANDLER[CommandType.InvokeInstanceMethod] = SharedInvokeInstanceMethodBodyHandler()
+        self.SHARED_BODY_HANDLER[CommandType.InvokeStaticMethod] = SharedInvokeStaticMethodBodyHandler()
+        self.SHARED_BODY_HANDLER[CommandType.GetStaticField] = SharedGetStaticFieldBodyHandler()
+        self.SHARED_BODY_HANDLER[CommandType.GetInstanceField] = SharedGetInstanceFieldBodyHandler()
+
+        self.GENERATOR_HANDLER[CommandType.CreateClassInstance] = CreateInstanceGeneratorHandler()
+        self.GENERATOR_HANDLER[CommandType.GetType] = GetTypeGeneratorHandler()
+        self.GENERATOR_HANDLER[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodGeneratorHandler()
+        self.GENERATOR_HANDLER[CommandType.InvokeStaticMethod] = InvokeStaticMethodGeneratorHandler()
+        self.GENERATOR_HANDLER[CommandType.GetStaticField] = GetStaticFieldGeneratorHandler()
+        self.GENERATOR_HANDLER[CommandType.GetInstanceField] = GetInstanceFieldGeneratorHandler()

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/InvokeInstanceMethodGeneratorHandler.py

@@ -4,14 +4,14 @@ import typing
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.CommonGenerator import CommonGenerator
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class InvokeInstanceMethodGeneratorHandler(AbstractGeneratorHandler):
     def generate_command(self, analyzed_object, parent_command, handlers):
-        invoke_instance_method_command = PythonCommand(RuntimeLib.python, PythonCommandType.InvokeInstanceMethod, [])
+        invoke_instance_method_command = Command(RuntimeName.python, CommandType.InvokeInstanceMethod, [])
         invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(analyzed_object.__name__)
         invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(
             # TODO: what to do with dynamic language with unknown type

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/InvokeStaticMethodGeneratorHandler.py

@@ -3,14 +3,14 @@ import inspect
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.CommonGenerator import CommonGenerator
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class InvokeStaticMethodGeneratorHandler(AbstractGeneratorHandler):
     def generate_command(self, analyzed_object, parent_command, handlers):
-        invoke_static_method_command = PythonCommand(RuntimeLib.python, PythonCommandType.InvokeStaticMethod, [])
+        invoke_static_method_command = Command(RuntimeName.python, CommandType.InvokeStaticMethod, [])
         invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(analyzed_object.__name__)
         invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(
             handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_command(type(analyzed_object),

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/shared/SharedTypeHandler.py

@@ -1,5 +1,5 @@
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.sdk.core.Type import Type
+from javonet.utils.Type import Type
 
 
 class SharedTypeHandler(AbstractGeneratorHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/shared/body/SharedCreateInstanceBodyHandler.py

@@ -9,7 +9,7 @@ class SharedCreateInstanceBodyHandler(AbstractGeneratorHandler):
     def generate_code(self, existing_string_builder, common_command, used_object, handlers):
         existing_string_builder.append("\n")
         existing_string_builder.append("        self.instance = Javonet.inMemory().")
-        existing_string_builder.append(str(common_command.target_runtime.name))
+        existing_string_builder.append(str(common_command.runtime_name.name))
         existing_string_builder.append("().")
         existing_string_builder.append("get_type(\"")
         existing_string_builder.append(used_object.get_payload()[0])

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/shared/body/SharedGetStaticFieldBodyHandler.py

@@ -10,7 +10,7 @@ class SharedGetStaticFieldBodyHandler(AbstractGeneratorHandler):
         handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_code(existing_string_builder, common_command,
                                                                       used_object.get_payload()[1], handlers)
         existing_string_builder.append("(Javonet.inMemory().")
-        existing_string_builder.append(str(common_command.target_runtime.name))
+        existing_string_builder.append(str(common_command.runtime_name.name))
         existing_string_builder.append("().")
         existing_string_builder.append("get_type(\"")
         existing_string_builder.append(used_object.get_payload()[3])

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/shared/body/SharedGetTypeBodyHandler.py

@@ -7,7 +7,7 @@ class SharedGetTypeBodyHandler(AbstractGeneratorHandler):
 
     def generate_code(self, existing_string_builder, common_command, used_object, handlers):
         existing_string_builder.append("return Javonet.inMemory().")
-        existing_string_builder.append(str(common_command.target_runtime))
+        existing_string_builder.append(str(common_command.runtime_name))
         existing_string_builder.append("().")
         existing_string_builder.append("get_type(\"")
         existing_string_builder.append(used_object.get_payload()[0])

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/shared/body/SharedInvokeStaticMethodBodyHandler.py

@@ -12,7 +12,7 @@ class SharedInvokeStaticMethodBodyHandler(AbstractGeneratorHandler):
             existing_string_builder.append("        ")
             existing_string_builder.append("result = ")
             existing_string_builder.append("Javonet.inMemory().")
-            existing_string_builder.append(str(common_command.target_runtime.name))
+            existing_string_builder.append(str(common_command.runtime_name.name))
             existing_string_builder.append("().")
             existing_string_builder.append("get_type(\"")
             existing_string_builder.append(used_object.get_payload()[3])
@@ -40,7 +40,7 @@ class SharedInvokeStaticMethodBodyHandler(AbstractGeneratorHandler):
                                                                                 used_object.get_payload()[1],
                                                                                 handlers)
             existing_string_builder.append("(Javonet.inMemory().")
-            existing_string_builder.append(str(common_command.target_runtime.name))
+            existing_string_builder.append(str(common_command.runtime_name.name))
             existing_string_builder.append("().")
             existing_string_builder.append("get_type(\"")
             existing_string_builder.append(used_object.get_payload()[3])

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/AbstractHandler.py

@@ -1,3 +1,3 @@
 class AbstractHandler:
-    def HandleCommand(self, python_command):
+    def handle_command(self, command):
         raise NotImplementedError('subclasses must override HandleCommand()!')

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/AbstractCommandHandler.py

@@ -1,25 +1,26 @@
 from javonet.core.handler.HandlerDictionary import handler_dict
-from javonet.sdk.core.PythonCommand import PythonCommand
+from javonet.utils.Command import Command
 
 
 class AbstractCommandHandler:
-    pass
     _required_parameters_count = 0
 
-    def HandleCommand(self, python_command):
+    def process(self, command):
+        pass
+
+    def handle_command(self, command):
         try:
-            self.iterate(python_command)
-            return self.process(python_command)
+            self.__iterate(command)
+            return self.process(command)
         except Exception as e:
             raise e
 
-    def iterate(self, command):
+    @staticmethod
+    def __iterate(command):
         for i in range(0, len(command.payload)):
-            if isinstance(command.payload[i], PythonCommand):
+            if isinstance(command.payload[i], Command):
                 try:
-                    command.payload[i] = handler_dict.get(command.payload[i].command_type).HandleCommand(command.payload[i])
+                    command.payload[i] = handler_dict.get(command.payload[i].command_type).handle_command(
+                        command.payload[i])
                 except Exception as e:
                     raise e
-
-    def process(self, python_command):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ArrayGetItemHandler.py

@@ -0,0 +1,24 @@
+from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class ArrayGetItemHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("ArrayGetItemHandler parameters mismatch!")
+
+            array = command.payload[0]
+            indexes = command.payload[1:]
+            if len(indexes) == 1:
+                return array[indexes[0]]
+            else:
+                array_copy = array.copy()
+                for i in indexes:
+                    array_copy = array_copy[i]
+                return array_copy
+
+        except Exception as e:
+            raise Exception(e) from e

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ArrayGetRankHandler.py

@@ -0,0 +1,20 @@
+from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+#import numpy as np
+
+
+class ArrayGetRankHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ArrayGetRankHandler parameters mismatch!")
+            raise Exception("ArrayGetRankHandler not implemented")
+            #array = command.payload[0]
+
+            #np_array = np.array(array)
+            #return np_array.ndim
+
+        except Exception as e:
+            raise Exception(e) from e

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ArrayGetSizeHandler.py

@@ -0,0 +1,18 @@
+from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+
+class ArrayGetSizeHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ArrayGetSizeHandler parameters mismatch!")
+
+            array = command.payload[0]
+            return len(array)
+            #np_array = np.array(array)
+            #return np_array.size
+
+        except Exception as e:
+            raise Exception(e) from e

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ArraySetItemHandler.py

@@ -0,0 +1,21 @@
+from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class ArraySetItemHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("ArraySetItemHandler parameters mismatch!")
+
+            array = command.payload[0]
+            value = command.payload[1]
+            indexes = command.payload[2:]
+            if len(indexes) == 1:
+                array[indexes[0]] = value
+                return 0
+
+        except Exception as e:
+            raise Exception(e) from e

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/CastingHandler.py

@@ -2,5 +2,5 @@ from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractC
 
 
 class CastingHandler(AbstractCommandHandler):
-    def process(self, python_command):
+    def process(self, command):
         raise Exception("Explicit cast is forbidden in dynamically typed languages")

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

@@ -7,14 +7,14 @@ class CreateClassInstanceHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 1
 
-    def process(self, python_command):
+    def process(self, command):
         try:
 
-            if len(python_command.payload) < self._required_parameters_count:
+            if len(command.payload) < self._required_parameters_count:
                 raise Exception("CreateClassInstanceHandler parameters mismatch!")
-            clazz = python_command.payload[0]
-            if len(python_command.payload) > 1:
-                method_arguments = python_command.payload[1:]
+            clazz = command.payload[0]
+            if len(command.payload) > 1:
+                method_arguments = command.payload[1:]
                 sig = signature(clazz)
                 if len(sig.parameters) != len(method_arguments):
                     raise Exception("Number of arguments for create class instance are not matching!")

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/DestructReferenceHandler.py

@@ -7,7 +7,7 @@ class DestructReferenceHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 1
 
-    def process(self, python_command):
+    def process(self, command):
         reference_cache = ReferencesCache()
-        return reference_cache.delete_reference(python_command.payload[0])
+        return reference_cache.delete_reference(command.payload[0])
 

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

@@ -6,12 +6,12 @@ class GetInstanceFieldHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 2
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) != self._required_parameters_count:
+            if len(command.payload) != self._required_parameters_count:
                 raise Exception("GetInstanceFieldHandler parameters mismatch!")
-            clazz = python_command.payload[0]
-            value = getattr(clazz, python_command.payload[1])
+            clazz = command.payload[0]
+            value = getattr(clazz, command.payload[1])
             return value
         except Exception as e:
             raise Exception(e) from e

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

@@ -6,12 +6,12 @@ class GetStaticFieldHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 2
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) != self._required_parameters_count:
+            if len(command.payload) != self._required_parameters_count:
                 raise Exception("GetStaticFieldHandler parameters mismatch!")
-            clazz = python_command.payload[0]
-            value = getattr(clazz, python_command.payload[1])
+            clazz = command.payload[0]
+            value = getattr(clazz, command.payload[1])
             return value
         except Exception as e:
             raise Exception(e) from e

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

@@ -7,18 +7,18 @@ class GetTypeHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 1
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) < self._required_parameters_count:
+            if len(command.payload) < self._required_parameters_count:
                 raise Exception("GetTypeHandler parameters mismatch!")
-            if len(python_command.payload) == 1:
-                type_name = python_command.payload[0].split(".")
+            if len(command.payload) == 1:
+                type_name = command.payload[0].split(".")
                 if len(type_name) == 1:
                     return import_module(type_name[0])
                 else:
                     loaded_module = import_module(".".join(type_name[:-1]))
                     return getattr(loaded_module, type_name[-1])
             else:
-                return import_module(".".join(python_command.payload[:]))
+                return import_module(".".join(command.payload[:]))
         except Exception as e:
             raise Exception(e) from e

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

@@ -6,16 +6,16 @@ class InvokeInstanceMethodHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 2
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) < self._required_parameters_count:
+            if len(command.payload) < self._required_parameters_count:
                 raise Exception("InvokeInstanceMethod Parameters mismatch!")
 
-            clazz = python_command.payload[0]
-            method = getattr(clazz, python_command.payload[1])
+            clazz = command.payload[0]
+            method = getattr(clazz, command.payload[1])
 
-            if len(python_command.payload) > 2:
-                method_arguments = python_command.payload[2:]
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
                 return method(*method_arguments)
             return method()
         except Exception as e:

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

@@ -6,16 +6,16 @@ class InvokeStaticMethodHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 2
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) < self._required_parameters_count:
+            if len(command.payload) < self._required_parameters_count:
                 raise Exception("InvokeStaticMethod Parameters mismatch!")
 
-            clazz = python_command.payload[0]
-            method = getattr(clazz, python_command.payload[1])
+            clazz = command.payload[0]
+            method = getattr(clazz, command.payload[1])
 
-            if len(python_command.payload) > 2:
-                method_arguments = python_command.payload[2:]
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
                 return method(*method_arguments)
             return method()
         except Exception as e:

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

@@ -8,12 +8,12 @@ class LoadLibraryHandler(AbstractCommandHandler):
     def __init__(self):
         pass
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) != 1:
+            if len(command.payload) != 1:
                 raise Exception("LoadLibrary payload parameters mismatch")
 
-            sys.path.append(python_command.payload[0])
+            sys.path.append(command.payload[0])
 
             return 0
         except Exception as e:

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ResolveInstanceHandler.py

@@ -6,12 +6,12 @@ class ResolveInstanceHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 1
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) != self._required_parameters_count:
+            if len(command.payload) != self._required_parameters_count:
                 raise Exception("ResolveInstanceHandler parameters mismatch!")
 
             references_cache = ReferencesCache()
-            return references_cache.resolve_reference(python_command)
+            return references_cache.resolve_reference(command)
         except Exception as e:
             raise Exception(e) from e

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

@@ -6,13 +6,13 @@ class SetStaticFieldHandler(AbstractCommandHandler):
     def __init__(self):
         self._required_parameters_count = 3
 
-    def process(self, python_command):
+    def process(self, command):
         try:
-            if len(python_command.payload) != self._required_parameters_count:
+            if len(command.payload) != self._required_parameters_count:
                 raise Exception("SetStaticFieldHandler parameters mismatch!")
 
-            clazz = python_command.payload[0]
-            setattr(clazz, python_command.payload[1], python_command.payload[2])
+            clazz = command.payload[0]
+            setattr(clazz, command.payload[1], command.payload[2])
             return "SetStaticFieldHandler - success"
         except Exception as e:
             raise Exception(e) from e

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ValueHandler.py

@@ -0,0 +1,6 @@
+from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class ValueHandler(AbstractCommandHandler):
+    def process(self, command):
+        return command.payload[0]