javonet-ruby-sdk 2.0.4 → 2.1.1

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/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/MacOs/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/MacOs/X64/javonet/core/transmitter/PythonTransmitterWrapper.py

@@ -35,8 +35,16 @@ class PythonTransmitterWrapper:
             PythonTransmitterWrapper.python_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:
-            raise RuntimeError("Javonet native code error: " + str(response_array_len))
+            get_native_error = PythonTransmitterWrapper.python_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))
 
     @staticmethod
     def activate(email, licence_key, proxy_host, proxy_user_name, proxy_user_password):
@@ -44,8 +52,19 @@ class PythonTransmitterWrapper:
         activate.restype = c_int
         activate.argtypes = [c_char_p, c_char_p, c_char_p, c_char_p, c_char_p]
 
-        return activate(email.encode('ascii'),
-                        licence_key.encode('ascii'),
-                        proxy_host.encode('ascii'),
-                        proxy_user_name.encode('ascii'),
-                        proxy_user_password.encode('ascii'))
+        activation_result = activate(email.encode('ascii'),
+                                     licence_key.encode('ascii'),
+                                     proxy_host.encode('ascii'),
+                                     proxy_user_name.encode('ascii'),
+                                     proxy_user_password.encode('ascii'))
+
+        if activation_result < 0:
+            get_native_error = PythonTransmitterWrapper.python_lib.GetNativeError
+            get_native_error.restype = c_char_p
+            get_native_error.argtypes = []
+            error_message = get_native_error()
+            raise RuntimeError(
+                "Javonet activation result: " + str(activation_result) + ". Native error message: " + str(error_message))
+        else:
+            return activation_result
+        

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/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/{Windows/X64/javonet/sdk/core/PythonCommandType.py → MacOs/X64/javonet/utils/CommandType.py}

@@ -1,23 +1,27 @@
-from enum import Enum
-
-
-class PythonCommandType(Enum):
-    Response = 0
-    LoadLibrary = 1
-    InvokeStaticMethod = 2
-    GetStaticField = 3
-    SetStaticField = 4
-    CreateClassInstance = 5
-    GetType = 6
-    Reference = 7
-    GetModule = 8
-    InvokeInstanceMethod = 9
-    Exception = 10
-    HeartBeat = 11
-    Cast = 12
-    GetInstanceField = 13
-    Optimize = 14
-    GenerateLib = 15
-    InvokeGlobalMethod = 16
-    DestructReference = 17
-    Array = 18
+from enum import Enum
+
+
+class CommandType(Enum):
+    Value = 0
+    LoadLibrary = 1
+    InvokeStaticMethod = 2
+    GetStaticField = 3
+    SetStaticField = 4
+    CreateClassInstance = 5
+    GetType = 6
+    Reference = 7
+    GetModule = 8
+    InvokeInstanceMethod = 9
+    Exception = 10
+    HeartBeat = 11
+    Cast = 12
+    GetInstanceField = 13
+    Optimize = 14
+    GenerateLib = 15
+    InvokeGlobalMethod = 16
+    DestructReference = 17
+    Array = 18
+    ArrayGetItem = 19
+    ArrayGetSize = 20
+    ArrayGetRank = 21
+    ArraySetItem = 22

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/sdk/core → MacOs/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/{Linux/X64/javonet/sdk/core/RuntimeLib.py → MacOs/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/Windows/X64/javonet/core/{handler/utils → exception}/ExceptionSerializer.py

@@ -2,32 +2,37 @@ 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, [])
-        trace = traceback.format_exception(type(exception), exception, exception.__traceback__)
-        exception_message = exception.__cause__
+    def serialize_exception(exception, command):
+        exception_command = Command(command.runtime_name, CommandType.Exception, [])
+        tb = exception.__traceback__
+        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()
-        for frame_summary in stack:
-            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("|")
+
+        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("|")
 
         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 +50,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/Windows/X64/javonet/core/exception/ExceptionThrower.py

@@ -0,0 +1,45 @@
+import re
+import sys
+import traceback
+import types
+
+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(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_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])
+        traceback_str = ""
+
+        for i in range(len(stack_methods) - 1):
+            traceback_str += "File \"{}\", line {}, in {}\n".format(stack_files[i], stack_lines[i], stack_methods[i])
+            if stack_classes[i]:
+                traceback_str += "    {}\n".format(stack_classes[i])
+
+        ExceptionThrower.raise_exception(original_exception,exception_message,traceback_str)
+
+
+    @staticmethod
+    def raise_exception(original_exception, exception_message, traceback_str):
+        raise JavonetException(str(original_exception), exception_message, traceback_str)
+
+    @staticmethod
+    def get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
+        stack_classes = re.split("\\|", stack_trace_classes)
+        stack_methods = re.split("\\|", stack_trace_methods)
+        stack_lines = re.split("\\|", stack_trace_lines)
+        stack_files = re.split("\\|", stack_trace_files)
+
+        return [stack_classes, stack_methods, stack_lines, stack_files]

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

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