javonet-ruby-sdk 2.0.4 → 2.1.0

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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]

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

@@ -0,0 +1,87 @@
+import traceback
+
+from javonet.core.handler.AbstractHandler import AbstractHandler
+from javonet.core.handler.CommandHandler.ValueHandler import ValueHandler
+from javonet.core.handler.CommandHandler.LoadLibraryHandler import LoadLibraryHandler
+from javonet.core.handler.CommandHandler.InvokeStaticMethodHandler import InvokeStaticMethodHandler
+from javonet.core.handler.CommandHandler.SetStaticFieldHandler import SetStaticFieldHandler
+from javonet.core.handler.CommandHandler.CreateClassInstanceHandler import CreateClassInstanceHandler
+from javonet.core.handler.CommandHandler.GetStaticFieldHandler import GetStaticFieldHandler
+from javonet.core.handler.CommandHandler.ResolveInstanceHandler import ResolveInstanceHandler
+from javonet.core.handler.CommandHandler.GetTypeHandler import GetTypeHandler
+from javonet.core.handler.CommandHandler.InvokeInstanceMethodHandler import InvokeInstanceMethodHandler
+from javonet.core.handler.CommandHandler.CastingHandler import CastingHandler
+from javonet.core.handler.CommandHandler.GetInstanceFieldHandler import GetInstanceFieldHandler
+from javonet.core.handler.CommandHandler.DestructReferenceHandler import DestructReferenceHandler
+from javonet.core.handler.CommandHandler.ArrayGetItemHandler import ArrayGetItemHandler
+from javonet.core.handler.CommandHandler.ArrayGetSizeHandler import ArrayGetSizeHandler
+from javonet.core.handler.CommandHandler.ArrayGetRankHandler import ArrayGetRankHandler
+from javonet.core.handler.CommandHandler.ArraySetItemHandler import ArraySetItemHandler
+
+from javonet.core.handler.HandlerDictionary import handler_dict
+from javonet.core.handler.ReferencesCache import ReferencesCache
+from javonet.core.exception.ExceptionSerializer import ExceptionSerializer
+from javonet.utils.CommandType import CommandType
+from javonet.utils.Command import Command
+
+
+class Handler(AbstractHandler):
+
+    def __init__(self):
+        value_handler = ValueHandler()
+        load_library_handler = LoadLibraryHandler()
+        invoke_static_method_handler = InvokeStaticMethodHandler()
+        set_static_field_handler = SetStaticFieldHandler()
+        create_class_instance_handler = CreateClassInstanceHandler()
+        get_static_field_handler = GetStaticFieldHandler()
+        resolve_instance_handler = ResolveInstanceHandler()
+        get_type_handler = GetTypeHandler()
+        invoke_instance_method_handler = InvokeInstanceMethodHandler()
+        casting_handler = CastingHandler()
+        get_instance_field_handler = GetInstanceFieldHandler()
+        destruct_reference_handler = DestructReferenceHandler()
+        array_get_item_handler = ArrayGetItemHandler()
+        array_get_size_handler = ArrayGetSizeHandler()
+        array_get_rank_handler = ArrayGetRankHandler()
+        array_set_item_handler = ArraySetItemHandler()
+
+        handler_dict[CommandType.Value] = value_handler
+        handler_dict[CommandType.LoadLibrary] = load_library_handler
+        handler_dict[CommandType.InvokeStaticMethod] = invoke_static_method_handler
+        handler_dict[CommandType.SetStaticField] = set_static_field_handler
+        handler_dict[CommandType.CreateClassInstance] = create_class_instance_handler
+        handler_dict[CommandType.GetStaticField] = get_static_field_handler
+        handler_dict[CommandType.Reference] = resolve_instance_handler
+        handler_dict[CommandType.GetType] = get_type_handler
+        handler_dict[CommandType.InvokeInstanceMethod] = invoke_instance_method_handler
+        handler_dict[CommandType.Cast] = casting_handler
+        handler_dict[CommandType.GetInstanceField] = get_instance_field_handler
+        handler_dict[CommandType.DestructReference] = destruct_reference_handler
+        handler_dict[CommandType.ArrayGetItem] = array_get_item_handler
+        handler_dict[CommandType.ArrayGetSize] = array_get_size_handler
+        handler_dict[CommandType.ArrayGetRank] = array_get_rank_handler
+        handler_dict[CommandType.ArraySetItem] = array_set_item_handler
+
+    def handle_command(self, command):
+        try:
+            response = handler_dict.get(command.command_type).handle_command(command)
+            return self.__parse_response(response, command.runtime_name)
+        except Exception as e:
+            stack_trace = traceback.extract_stack()
+            return ExceptionSerializer.serialize_exception(e, command, stack_trace)
+
+    def __parse_response(self, response, runtime_name):
+        if self.__is_response_simple_type(response):
+            return Command.create_response(response, runtime_name)
+        else:
+            reference_cache = ReferencesCache()
+            guid = reference_cache.cache_reference(response)
+            return Command.create_reference(guid, runtime_name)
+
+    @staticmethod
+    def __is_response_simple_type(response):
+        return isinstance(response, (int, float, bool, str))
+
+    @staticmethod
+    def __is_response_array(response):
+        return isinstance(response, list);

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/ReferencesCache.py

@@ -1,6 +1,6 @@
 import uuid
 
-from javonet.sdk.core.PythonCommandType import PythonCommandType
+from javonet.utils.CommandType import CommandType
 
 
 class ReferencesCache(object):
@@ -18,12 +18,12 @@ class ReferencesCache(object):
         self.references_cache[uuid_] = object_reference
         return uuid_
 
-    def resolve_reference(self, python_command):
-        if python_command.command_type != PythonCommandType.Reference:
+    def resolve_reference(self, command):
+        if command.command_type != CommandType.Reference:
             raise Exception(
-                "Trying to dereference Python command with command_type: " + str(python_command.command_type))
+                "Trying to dereference Python command with command_type: " + str(command.command_type))
         try:
-            return self.references_cache[python_command.payload[0]]
+            return self.references_cache[command.payload[0]]
         except KeyError:
             raise Exception("Object not found in references")
 

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

@@ -0,0 +1,31 @@
+from javonet.core.handler.Handler import Handler
+from javonet.core.protocol.CommandDeserializer import CommandDeserializer
+from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.RuntimeName import RuntimeName
+
+
+class Interpreter:
+
+    response = None
+
+    def execute(self, command, connection_type, tcp_address):
+        command_serializer = CommandSerializer()
+        serialized_command = command_serializer.encode(command, connection_type, tcp_address)
+        if command.runtime_name == RuntimeName.python:
+            from javonet.core.receiver.Receiver import Receiver
+            response = Receiver().SendCommand(serialized_command, len(serialized_command))
+        else:
+            from javonet.core.transmitter.PythonTransmitter import PythonTransmitter
+            response = PythonTransmitter.send_command(serialized_command)
+        command_deserializer = CommandDeserializer(response, len(response))
+
+        return command_deserializer.decode()
+
+    def process(self, byte_array, byte_array_len):
+        command_deserializer = CommandDeserializer(byte_array, byte_array_len)
+        received_command = command_deserializer.decode()
+        python_handler = Handler()
+        command_serializer = CommandSerializer()
+        response_command = python_handler.handle_command(received_command)
+        encoded_response = command_serializer.encode(response_command, 0, "0.0.0.0:0")
+        return encoded_response

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/CommandDeserializer.py

@@ -1,9 +1,9 @@
 from javonet.core.protocol.TypeDeserializer import TypeDeserializer
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
-from javonet.sdk.core.Type import Type
-from javonet.sdk.core.StringEncodingMode import StringEncodingMode
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class CommandDeserializer:
@@ -15,7 +15,7 @@ class CommandDeserializer:
     def __init__(self, buffer, buffer_len):
         self.buffer = buffer
         self.buffer_len = buffer_len
-        self.command = PythonCommand(RuntimeLib(buffer[0]), PythonCommandType(buffer[10]), [])
+        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
         self.position = 11
 
     def is_at_end(self):
@@ -57,7 +57,7 @@ class CommandDeserializer:
         command_type = self.buffer[p + 6]
 
         self.position += 7
-        return_command = PythonCommand(RuntimeLib(runtime), PythonCommandType(command_type), [])
+        return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
         return self.read_command_recursively(number_of_elements_in_payload, return_command)
 
     def read_command_recursively(self, number_of_elements_in_payload_left, cmd):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/CommandSerializer.py

@@ -3,25 +3,25 @@ from collections import deque
 from typing import Deque
 
 from javonet.core.protocol.TypeSerializer import TypeSerializer
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class CommandSerializer:
     byte_buffer = []
 
     def encode(self, root_command, connection_type, tcp_address=None, runtime_version=0):
-        queue: Deque[PythonCommand] = deque()
+        queue: Deque[Command] = deque()
         queue.append(root_command)
-        self.insert_into_buffer([root_command.target_runtime.value, runtime_version])
+        self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
         if connection_type == ConnectionType.Tcp.value:
             self.insert_into_buffer([ConnectionType.Tcp.value])
             self.insert_into_buffer(self.serialize_tcp(tcp_address))
         else:
             self.insert_into_buffer([ConnectionType.InMemory.value])
             self.insert_into_buffer(self.serialize_tcp("0.0.0.0:0"))
-        self.insert_into_buffer([RuntimeLib.python.value, root_command.command_type.value])
+        self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
         return self.serialize_recursively(queue)
 
     @staticmethod
@@ -64,7 +64,7 @@ class CommandSerializer:
         command = queue.pop()
         queue.append(command.drop_first_payload_argument())
         if len(command.get_payload()) > 0:
-            if isinstance(command.get_payload()[0], PythonCommand):
+            if isinstance(command.get_payload()[0], Command):
                 inner_command = command.get_payload()[0]
                 self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
                 queue.append(inner_command)

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/TypeDeserializer.py

@@ -1,9 +1,7 @@
 import struct
 
-from javonet.sdk.core import PythonCommand
-from javonet.sdk.core import PythonCommandType
-from javonet.sdk.core import RuntimeLib
-from javonet.sdk.core.StringEncodingMode import StringEncodingMode
+from javonet.utils import Command, CommandType, RuntimeName
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeDeserializer:
@@ -74,5 +72,5 @@ class TypeDeserializer:
 
     @staticmethod
     def deserialize_command(command_byte_array):
-        python_command = PythonCommand(RuntimeLib(command_byte_array[0]), PythonCommandType(command_byte_array[1]), [])
-        return python_command
+        command = Command(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
+        return command

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/TypeSerializer.py

@@ -1,7 +1,7 @@
 import struct
 
-from javonet.sdk.core.Type import Type
-from javonet.sdk.core.StringEncodingMode import StringEncodingMode
+from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeSerializer:
@@ -71,6 +71,6 @@ class TypeSerializer:
         return [Type.JavonetBytes.value, length] + encoded_bytes_list
 
     @staticmethod
-    def serialize_command(python_command):
-        length = list(bytearray(struct.pack("<i", len(python_command.payload))))
-        return [Type.Command.value] + length + [python_command.target_runtime.value, python_command.command_type.value]
+    def serialize_command(command):
+        length = list(bytearray(struct.pack("<i", len(command.payload))))
+        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]

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

@@ -1,10 +1,10 @@
-from javonet.core.interpreter.PythonInterpreter import PythonInterpreter
+from javonet.core.interpreter.Interpreter import Interpreter
 
 
 class Receiver:
 
     def __init__(self):
-        self.python_interpreter = PythonInterpreter()
+        self.python_interpreter = Interpreter()
 
     def SendCommand(self, messageByteArray, messageByteArrayLen):
         return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray)))

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/Command.py

@@ -0,0 +1,67 @@
+from javonet.utils.CommandType import CommandType
+
+
+class Command:
+
+    def __init__(self, runtime_name, command_type, payload):
+        self.runtime_name = runtime_name
+        self.command_type = command_type
+        self.payload = payload
+
+    def get_payload(self):
+        return self.payload
+
+    @staticmethod
+    def create_response(response, runtime_name):
+        return Command(runtime_name, CommandType.Value, [response])
+
+    @staticmethod
+    def create_reference(guid, runtime_name):
+        return Command(runtime_name, CommandType.Reference, [guid])
+
+    @staticmethod
+    def create_array_response(array, runtime_name):
+        return Command(runtime_name, CommandType.Array, [array])
+
+    def drop_first_payload_argument(self):
+        payload_args = []
+        payload_args.extend(self.payload)
+        if len(payload_args) != 0:
+            payload_args.pop(0)
+        return Command(self.runtime_name, self.command_type, payload_args)
+
+    def add_arg_to_payload(self, argument):
+        merged_payload = self.payload + [argument]
+        return Command(self.runtime_name, self.command_type, merged_payload)
+
+    def append_arg_to_payload(self, current_command):
+        if current_command is None:
+            return Command(self.runtime_name, self.command_type, self.payload)
+        else:
+            return Command(self.runtime_name, self.command_type, [current_command] + self.payload)
+
+    def to_string(self):
+        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
+            self.command_type) + ' Payload: ' + str(self.payload)
+
+    def __eq__(self, element):
+        self.is_equal = False
+        if self is element:
+            self.is_equal = True
+        if element is None or self.__class__ != element.__class__:
+            self.is_equal = False
+        if self.command_type is element.command_type and self.runtime_name is element.runtime_name:
+            self.is_equal = True
+        if len(self.payload) == len(element.payload):
+            i = 0
+            array_item_equal = False
+            for payload_item in self.payload:
+                if payload_item.__eq__(element.payload[i]):
+                    array_item_equal = True
+                else:
+                    array_item_equal = False
+                i += 1
+            self.is_equal = array_item_equal
+        else:
+            self.is_equal = False
+        return self.is_equal

data/lib/javonet-ruby-sdk/Binaries/Python/{MacOs/X64/javonet/sdk/core/PythonCommandType.py → Linux/X64/javonet/utils/CommandType.py}

@@ -1,8 +1,8 @@
 from enum import Enum
 
 
-class PythonCommandType(Enum):
-    Response = 0
+class CommandType(Enum):
+    Value = 0
     LoadLibrary = 1
     InvokeStaticMethod = 2
     GetStaticField = 3
@@ -21,3 +21,7 @@ class PythonCommandType(Enum):
     InvokeGlobalMethod = 16
     DestructReference = 17
     Array = 18
+    ArrayGetItem = 19
+    ArrayGetSize = 20
+    ArrayGetRank = 21
+    ArraySetItem = 22

data/lib/javonet-ruby-sdk/Binaries/Python/{MacOs/X64/javonet/sdk/core → Linux/X64/javonet/utils}/ExplicitCast.py

@@ -1,18 +1,18 @@
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
 
 
 class ExplicitCast:
     @staticmethod
     def cast(value, target_type):
-        return PythonCommand(
+        return Command(
             100,
-            PythonCommandType.Cast,
+            CommandType.Cast,
             [
                 value,
-                PythonCommand(
+                Command(
                     100,
-                    PythonCommandType.GetType,
+                    CommandType.GetType,
                     [
                         target_type
                     ]

data/lib/javonet-ruby-sdk/Binaries/Python/{MacOs/X64/javonet/sdk/core/RuntimeLib.py → Linux/X64/javonet/utils/RuntimeName.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class RuntimeLib(Enum):
+class RuntimeName(Enum):
     clr = 0
     go = 1
     jvm = 2

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/utils → MacOs/X64/javonet/core/exception}/ExceptionSerializer.py

@@ -2,17 +2,17 @@ import os
 import traceback
 
 from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.sdk.core.ExceptionType import ExceptionType
+from javonet.utils.ExceptionType import ExceptionType
 
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
 
 
 class ExceptionSerializer:
 
     @staticmethod
-    def serialize_exception(exception, python_command, stack):
-        exception_command = PythonCommand(python_command.target_runtime, PythonCommandType.Exception, [])
+    def serialize_exception(exception, command, stack):
+        exception_command = Command(command.runtime_name, CommandType.Exception, [])
         trace = traceback.format_exception(type(exception), exception, exception.__traceback__)
         exception_message = exception.__cause__
         exception_name = exception.__cause__.__class__.__name__
@@ -27,7 +27,7 @@ class ExceptionSerializer:
             stack_files.append(frame_summary.filename).append("|")
 
         exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(python_command))
+        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__())
@@ -45,7 +45,7 @@ class ExceptionSerializer:
     IOException = 1
     FileNotFoundException = 2
     RuntimeException = 3
-    ArithemticException = 4
+    ArithmeticException = 4
     IllegalArgumentException = 5
     IndexOutOfBoundsException = 6
     NullPointerException = 7

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/{handler/utils → exception}/ExceptionThrower.py

@@ -1,27 +1,26 @@
 import re
-import sys
 import traceback
 
-from javonet.core.handler.utils.JavonetException import JavonetException
-from javonet.sdk.core.ExceptionType import ExceptionType
-from javonet.sdk.core.PythonCommand import PythonCommand
+from javonet.core.exception.JavonetException import JavonetException
+from javonet.utils.ExceptionType import ExceptionType
+from javonet.utils.Command import Command
 
 
 class ExceptionThrower:
 
     @staticmethod
-    def throw_exception(python_command_exception: PythonCommand):
-        original_exception = ExceptionType.to_exception(python_command_exception.get_payload()[0])
-        javonet_stack_command = python_command_exception.get_payload()[1]
-        exception_name = python_command_exception.get_payload()[2]
-        exception_message = python_command_exception.get_payload()[3]
+    def throw_exception(command_exception: Command):
+        original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
+        javonet_stack_command = command_exception.get_payload()[1]
+        exception_name = command_exception.get_payload()[2]
+        exception_message = command_exception.get_payload()[3]
 
         stack_trace = []
-        if len(python_command_exception.get_payload()) > 7:
-            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(python_command_exception.get_payload()[4],
-                                                python_command_exception.get_payload()[5],
-                                                python_command_exception.get_payload()[6],
-                                                python_command_exception.get_payload()[7])
+        if len(command_exception.get_payload()) > 7:
+            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(command_exception.get_payload()[4],
+                                                command_exception.get_payload()[5],
+                                                command_exception.get_payload()[6],
+                                                command_exception.get_payload()[7])
         else:
             stack_trace = []
         traceback_str = ""

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/generator/handler/CreateInstanceGeneratorHandler.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 CreateInstanceGeneratorHandler(AbstractGeneratorHandler):
     def generate_command(self, analyzed_object, parent_command, handlers):
-        create_instance_command = PythonCommand(RuntimeLib.python, PythonCommandType.CreateClassInstance, [])
+        create_instance_command = Command(RuntimeName.python, CommandType.CreateClassInstance, [])
         create_instance_command = create_instance_command.add_arg_to_payload(
             handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_command(parent_command.get_payload()[0],
                                                                                    create_instance_command, handlers))

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

@@ -7,9 +7,9 @@ from os.path import isfile, join
 
 from javonet.core.generator.handler.Handlers import Handlers
 from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-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 GeneratorHandler:
@@ -17,11 +17,11 @@ class GeneratorHandler:
     def analyze(self, package_path):
         handlers = Handlers()
         handlers.types_to_analyze.extend(self.return_classes_from_package(package_path))
-        structured_command_for_class = PythonCommand(RuntimeLib.python, PythonCommandType.GenerateLib, [])
+        structured_command_for_class = Command(RuntimeName.python, CommandType.GenerateLib, [])
 
         while len(handlers.types_to_analyze) > 0:
             structured_command_for_class = structured_command_for_class. \
-                add_arg_to_payload(handlers.GENERATOR_HANDLER[PythonCommandType.GetType].
+                add_arg_to_payload(handlers.GENERATOR_HANDLER[CommandType.GetType].
                                    generate_command(handlers.types_to_analyze.pop(0), structured_command_for_class,
                                                     handlers))
 
@@ -31,7 +31,7 @@ class GeneratorHandler:
         generator_handlers = Handlers()
         for i in range(0, len(command.get_payload())):
             existing_string_builder = PythonStringBuilder()
-            if isinstance(command.get_payload()[i], PythonCommand):
+            if isinstance(command.get_payload()[i], Command):
                 generator_handlers.GENERATOR_HANDLER[command.get_payload()[i].command_type].generate_code(
                     existing_string_builder, command, command.get_payload()[i], generator_handlers)
                 self.generate_class_file(existing_string_builder, str(command.get_payload()[i].get_payload()[0]),