javonet-ruby-sdk 2.0.4 → 2.1.0

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/RuntimeContext.py

@@ -1,69 +0,0 @@
-from javonet.core.handler.PythonHandler import PythonHandler
-from javonet.core.interpreter.PythonInterpreter import PythonInterpreter
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-
-from javonet.sdk.core.RuntimeLib import RuntimeLib
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.internal.InvocationContext import InvocationContext
-from javonet.sdk.internal.abstract.AbstractTypeContext import AbstractTypeContext
-
-
-class RuntimeContext(AbstractTypeContext):
-    __python_interpreter = PythonInterpreter()
-    __python_handler = PythonHandler()
-    __memory_runtime_contexts = dict()
-    __network_runtime_contexts = dict()
-    current_command = None
-
-    @staticmethod
-    def get_instance(runtime_lib: RuntimeLib, connection_type: ConnectionType, tcp_address: str):
-        if connection_type == ConnectionType.Tcp and tcp_address is not None:
-            if tcp_address in RuntimeContext.__network_runtime_contexts:
-                runtime_ctx = RuntimeContext.__network_runtime_contexts.get(tcp_address)
-                runtime_ctx.current_command = None
-                return runtime_ctx
-            else:
-                runtime_ctx = RuntimeContext(runtime_lib, connection_type, tcp_address)
-                RuntimeContext.__network_runtime_contexts[tcp_address] = runtime_ctx
-                return runtime_ctx
-        else:
-            if runtime_lib in RuntimeContext.__memory_runtime_contexts:
-                runtime_ctx = RuntimeContext.__memory_runtime_contexts.get(runtime_lib)
-                runtime_ctx.current_command = None
-                return runtime_ctx
-            else:
-                runtime_ctx = RuntimeContext(runtime_lib, connection_type, None)
-                RuntimeContext.__memory_runtime_contexts[runtime_lib] = runtime_ctx
-                return runtime_ctx
-
-    def __init__(self, runtime_lib: RuntimeLib, connection_type: ConnectionType, tcp_address: str):
-        self.__isExecuted = False
-        self.__runtime_lib = runtime_lib
-        self.__connection_type = connection_type
-        self.__tcp_ip_address = tcp_address
-
-    def execute(self, command: PythonCommand):
-        if self.__runtime_lib is RuntimeLib.python:
-            RuntimeContext.__python_handler.HandleCommand(command)
-            self.__isExecuted = True
-        else:
-            RuntimeContext.__python_interpreter.execute(command, self.__connection_type, self.__tcp_ip_address)
-            self.__isExecuted = True
-
-    def load_library(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.LoadLibrary, [*args])
-        self.execute(local_command)
-        return self
-
-    def get_type(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.GetType, [*args])
-        self.build_command(local_command)
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.current_command)
-
-    def build_command(self, command):
-        if self.current_command is None:
-            self.current_command = command
-        else:
-            self.current_command = command.add_arg_to_payload_on_beginning(self.current_command)

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/RuntimeFactory.py

@@ -1,38 +0,0 @@
-from javonet.sdk.core.RuntimeLib import RuntimeLib
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.internal.RuntimeContext import RuntimeContext
-from javonet.sdk.internal.abstract.AbstractRuntimeFactory import AbstractRuntimeFactory
-
-
-class RuntimeFactory(AbstractRuntimeFactory):
-
-    def __init__(self, connection_type, tcp_address=None):
-        self.connection_type = connection_type
-        if connection_type is ConnectionType.Tcp:
-            if tcp_address is None:
-                raise Exception("Error tcp ip adress is not given!")
-        self.tcp_address = tcp_address
-
-    def clr(self):
-        return RuntimeContext.get_instance(RuntimeLib.clr, self.connection_type, self.tcp_address)
-
-    def go(self):
-        return RuntimeContext.get_instance(RuntimeLib.go, self.connection_type, self.tcp_address)
-
-    def jvm(self):
-        return RuntimeContext.get_instance(RuntimeLib.jvm, self.connection_type, self.tcp_address)
-
-    def netcore(self):
-        return RuntimeContext.get_instance(RuntimeLib.netcore, self.connection_type, self.tcp_address)
-
-    def perl(self):
-        return RuntimeContext.get_instance(RuntimeLib.perl, self.connection_type, self.tcp_address)
-
-    def ruby(self):
-        return RuntimeContext.get_instance(RuntimeLib.ruby, self.connection_type, self.tcp_address)
-
-    def nodejs(self):
-        return RuntimeContext.get_instance(RuntimeLib.nodejs, self.connection_type, self.tcp_address)
-
-    def python(self):
-        return RuntimeContext.get_instance(RuntimeLib.python, self.connection_type, self.tcp_address)

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/abstract/AbstractInstanceContext.py

@@ -1,16 +0,0 @@
-import abc
-
-
-class AbstractInstanceContext(abc.ABC):
-
-    @abc.abstractmethod
-    def invoke_instance_method(self, string):
-        pass
-
-    @abc.abstractmethod
-    def get_instance_field(self, string: str):
-        pass
-
-    @abc.abstractmethod
-    def create_instance(self, class_name: str):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/abstract/AbstractInvocationContext.py

@@ -1,12 +0,0 @@
-import abc
-
-
-class AbstractInvocationContext(abc.ABC):
-
-    @abc.abstractmethod
-    def execute(self):
-        pass
-
-    @abc.abstractmethod
-    def get_value(self):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/abstract/AbstractMethodInvocationContext.py

@@ -1,16 +0,0 @@
-import abc
-
-
-class AbstractMethodInvocationContext(abc.ABC):
-
-    @abc.abstractmethod
-    def invoke_static_method(self, string):
-        pass
-
-    @abc.abstractmethod
-    def set_generic_type(self, string: str):
-        pass
-
-    @abc.abstractmethod
-    def get_static_field(self, static_field_name: str):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/abstract/AbstractRuntimeFactory.py

@@ -1,28 +0,0 @@
-import abc
-
-
-class AbstractRuntimeFactory(abc.ABC):
-
-    def clr(self):
-        pass
-
-    def go(self):
-        pass
-
-    def jvm(self):
-        pass
-
-    def netcore(self):
-        pass
-
-    def perl(self):
-        pass
-
-    def ruby(self):
-        pass
-
-    def nodejs(self):
-        pass
-
-    def python(self):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/sdk/internal/abstract/AbstractTypeContext.py

@@ -1,8 +0,0 @@
-import abc
-
-
-class AbstractTypeContext(abc.ABC):
-
-    @abc.abstractmethod
-    def get_type(self, string):
-        pass

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/handler/PythonHandler.py

@@ -1,68 +0,0 @@
-import traceback
-
-from javonet.core.handler.AbstractHandler import AbstractHandler
-from javonet.core.handler.CommandHandler.CastingHandler import CastingHandler
-from javonet.core.handler.CommandHandler.CreateClassInstanceHandler import CreateClassInstanceHandler
-from javonet.core.handler.CommandHandler.DestructReferenceHandler import DestructReferenceHandler
-from javonet.core.handler.CommandHandler.GetInstanceFieldHandler import GetInstanceFieldHandler
-from javonet.core.handler.CommandHandler.GetStaticFieldHandler import GetStaticFieldHandler
-from javonet.core.handler.CommandHandler.GetTypeHandler import GetTypeHandler
-from javonet.core.handler.CommandHandler.InvokeInstanceMethodHandler import InvokeInstanceMethodHandler
-from javonet.core.handler.CommandHandler.InvokeStaticMethodHandler import InvokeStaticMethodHandler
-from javonet.core.handler.CommandHandler.LoadLibraryHandler import LoadLibraryHandler
-from javonet.core.handler.CommandHandler.ResolveInstanceHandler import ResolveInstanceHandler
-from javonet.core.handler.CommandHandler.SetStaticFieldHandler import SetStaticFieldHandler
-from javonet.core.handler.HandlerDictionary import handler_dict
-from javonet.core.handler.ReferencesCache import ReferencesCache
-from javonet.core.handler.utils.ExceptionSerializer import ExceptionSerializer
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-
-
-class PythonHandler(AbstractHandler):
-
-    def __init__(self):
-        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()
-
-        handler_dict[PythonCommandType.LoadLibrary] = load_library_handler
-        handler_dict[PythonCommandType.InvokeStaticMethod] = invoke_static_method_handler
-        handler_dict[PythonCommandType.SetStaticField] = set_static_field_handler
-        handler_dict[PythonCommandType.CreateClassInstance] = create_class_instance_handler
-        handler_dict[PythonCommandType.GetStaticField] = get_static_field_handler
-        handler_dict[PythonCommandType.Reference] = resolve_instance_handler
-        handler_dict[PythonCommandType.GetType] = get_type_handler
-        handler_dict[PythonCommandType.InvokeInstanceMethod] = invoke_instance_method_handler
-        handler_dict[PythonCommandType.Cast] = casting_handler
-        handler_dict[PythonCommandType.GetInstanceField] = get_instance_field_handler
-        handler_dict[PythonCommandType.DestructReference] = destruct_reference_handler
-
-    def HandleCommand(self, python_command):
-        try:
-            response = handler_dict.get(python_command.command_type).HandleCommand(python_command)
-        except Exception as e:
-            stack_trace = traceback.extract_stack()
-            return ExceptionSerializer.serialize_exception(e, python_command, stack_trace)
-
-        if self.__is_response_simple_type(response):
-            return python_command.create_response(response)
-        elif self.__is_response_array(response):
-            return python_command.create_array_response(response)
-        else:
-            reference_cache = ReferencesCache()
-            guid = reference_cache.cache_reference(response)
-            return python_command.create_reference(guid)
-
-    def __is_response_simple_type(self, response):
-        return isinstance(response, (int, float, bool, str))
-
-    def __is_response_array(self, response):
-        return isinstance(response, list);

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/interpreter/PythonInterpreter.py

@@ -1,23 +0,0 @@
-from javonet.core.handler.PythonHandler import PythonHandler
-from javonet.core.protocol.CommandDeserializer import CommandDeserializer
-from javonet.core.protocol.CommandSerializer import CommandSerializer
-
-
-class PythonInterpreter:
-
-    def execute(self, python_command, connection_type, tcp_address):
-        from javonet.core.transmitter.PythonTransmitter import PythonTransmitter
-        command_serializer = CommandSerializer()
-        serialized_command = command_serializer.encode(python_command, connection_type, tcp_address)
-        serialized_response = PythonTransmitter.send_command(serialized_command)
-        command_deserializer = CommandDeserializer(serialized_response, len(serialized_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 = PythonHandler()
-        command_serializer = CommandSerializer()
-        response_command = python_handler.HandleCommand(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/Windows/X64/javonet/core/protocol/PythonProtocol.py

@@ -1,52 +0,0 @@
-from javonet.sdk.core import PythonCommand
-from javonet.sdk.core import PythonCommandType
-from javonet.sdk.core import RuntimeLib
-
-
-class PythonProtocol:
-
-    @staticmethod
-    def serialize(python_command):
-        ARGUMENT_SEPARATOR = bytearray(3)
-        byte_array_runtime = bytearray([python_command.target_runtime.value])
-        byte_array_command = bytearray([python_command.command_type.value])
-
-        payload_array = PythonProtocol.convertToBytes(python_command.payload)
-
-        byte_array = byte_array_runtime + ARGUMENT_SEPARATOR + byte_array_command + ARGUMENT_SEPARATOR + payload_array
-        return list(byte_array)
-
-    @staticmethod
-    def deserialize(byte_array_list):
-        byte_array = bytearray(byte_array_list)
-        ARGUMENT_SEPARATOR = bytearray(3)
-        byte_array_payload = list()
-
-        x = byte_array.split(ARGUMENT_SEPARATOR)
-        byte_array_runtime = RuntimeLib(int.from_bytes(x[0], 'big'))
-        byte_array_command = PythonCommandType(int.from_bytes(x[1], 'big'))
-        for i in range(2, len(x)):
-            byte_array_payload.append(x[i].decode('ascii'))
-
-        return PythonCommand(byte_array_runtime, byte_array_command, byte_array_payload)
-
-    @staticmethod
-    def convertToBytes(strings):
-        payload_array = bytearray()
-        ARGUMENT_SEPARATOR = bytearray(3)
-        for i in range(0, len(strings)):
-            payload_array += bytearray(strings[i], 'ascii')
-            if i != len(strings) - 1:
-                payload_array += ARGUMENT_SEPARATOR
-        return payload_array
-
-    @staticmethod
-    def byteArray2dSize(byteArray):
-        ARGUMENT_SEPARATOR = bytearray(3)
-        byteArray2dSize = 0
-        for i in range(0, len(byteArray)):
-            if i != len(byteArray) - 1:
-                byteArray2dSize += len(byteArray[i]) + ARGUMENT_SEPARATOR.__sizeof__()
-            else:
-                byteArray2dSize += len(byteArray[i])
-        return byteArray2dSize

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/sdk/Javonet.py

@@ -1,28 +0,0 @@
-from javonet.core.transmitter.PythonTransmitter import PythonTransmitter
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.internal.RuntimeFactory import RuntimeFactory
-
-PythonTransmitter.activate_with_licence_file()
-
-
-def in_memory():
-    connection_type = ConnectionType.InMemory
-    return RuntimeFactory(connection_type)
-
-
-def tcp(address):
-    connection_type = ConnectionType.Tcp
-    return RuntimeFactory(connection_type, address)
-
-
-def activate(email, licence_key, proxy_host=None, proxy_user_name=None, proxy_user_password=None):
-    if proxy_host is None:
-        return PythonTransmitter.activate_with_credentials(email, licence_key)
-    else:
-        if proxy_user_name is None:
-            proxy_user_name = ""
-        if proxy_user_password is None:
-            proxy_user_password = ""
-
-        return PythonTransmitter.activate_with_credentials_and_proxy(email, licence_key,
-                                                                     proxy_user_name, proxy_user_password)

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/sdk/core/ExplicitCast.py

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

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/sdk/core/PythonCommand.py

@@ -1,65 +0,0 @@
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-
-
-class PythonCommand:
-    target_runtime = None
-    command_type = None
-    payload = []
-
-    def __init__(self, targetRuntime, commandType, payload):
-        self.target_runtime = targetRuntime
-        self.command_type = commandType
-        self.payload = payload
-
-    def to_string(self):
-        return 'Target runtime: ' + str(self.target_runtime) + ' Command type: ' + str(
-            self.command_type) + ' Payload: ' + str(self.payload)
-
-    def get_payload(self):
-        return 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.target_runtime is element.target_runtime:
-            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
-
-    def create_response(self, response):
-        return PythonCommand(self.target_runtime, PythonCommandType.Response, [response])
-
-    def create_reference(self, guid):
-        return PythonCommand(self.target_runtime, PythonCommandType.Reference, [guid])
-
-    def create_array_response(self, array):
-        return PythonCommand(self.target_runtime, PythonCommandType.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 PythonCommand(self.target_runtime, self.command_type, payload_args)
-
-    def add_arg_to_payload(self, argument):
-        merged_payload = self.payload + [argument]
-        return PythonCommand(self.target_runtime, self.command_type, merged_payload)
-
-    def add_arg_to_payload_on_beginning(self, argument):
-        merged_payload = [argument] + self.payload
-        return PythonCommand(self.target_runtime, self.command_type, merged_payload)

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/sdk/internal/InvocationContext.py

@@ -1,96 +0,0 @@
-from javonet.core.handler.PythonHandler import PythonHandler
-from javonet.core.handler.utils.ExceptionThrower import ExceptionThrower
-from javonet.core.interpreter.PythonInterpreter import PythonInterpreter
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.internal.abstract.AbstractInstanceContext import AbstractInstanceContext
-from javonet.sdk.internal.abstract.AbstractInvocationContext import AbstractInvocationContext
-from javonet.sdk.internal.abstract.AbstractMethodInvocationContext import AbstractMethodInvocationContext
-
-
-class InvocationContext(AbstractInvocationContext, AbstractMethodInvocationContext, AbstractInstanceContext):
-
-    def __init__(self, runtime_lib: RuntimeLib, connection_type: ConnectionType, tcp_ip_address,
-                 current_command: PythonCommand, is_executed=False):
-        self.__is_executed = is_executed
-        self.__runtime_lib = runtime_lib
-        self.__connection_type = connection_type
-        self.__tcp_ip_address = tcp_ip_address
-        self.__current_command = current_command
-        self.__response_command = None
-        self.__python_interpreter = PythonInterpreter()
-        self.__python_handler = None
-
-    def __del__(self):
-        if self.__current_command.command_type == PythonCommandType.Reference and self.__is_executed is True:
-            self.__current_command = PythonCommand(self.__runtime_lib, PythonCommandType.DestructReference,
-                                                   self.__current_command.payload)
-            self.execute()
-
-    def execute(self):
-        if self.__runtime_lib is RuntimeLib.python:
-            self.__python_handler = PythonHandler()
-            self.__response_command = self.__python_handler.HandleCommand(self.__current_command)
-        else:
-            self.__response_command = self.__python_interpreter.execute(self.__current_command,
-                                                                        self.__connection_type,
-                                                                        self.__tcp_ip_address)
-
-        if self.__response_command.command_type == PythonCommandType.Exception:
-            ExceptionThrower.throw_exception(self.__response_command)
-
-        if self.__current_command.command_type == PythonCommandType.CreateClassInstance:
-            self.__current_command = self.__response_command
-            self.__is_executed = True
-            return self
-
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__response_command, True)
-
-    def invoke_static_method(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.InvokeStaticMethod, [*args])
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__build_command(local_command))
-
-    def invoke_instance_method(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.InvokeInstanceMethod, [*args])
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__build_command(local_command))
-
-    def get_static_field(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.GetStaticField, [*args])
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__build_command(local_command))
-
-    def set_static_field(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.SetStaticField, [*args])
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__build_command(local_command))
-
-    def create_instance(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.CreateClassInstance, [*args])
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__build_command(local_command))
-
-    def set_generic_type(self, string: str):
-        return self
-
-    def get_instance_field(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.GetInstanceField, [*args])
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.__build_command(local_command))
-
-    def get_value(self):
-        return self.__current_command.payload[0]
-
-    def __build_command(self, command):
-        for i in range(len(command.payload)):
-            if isinstance(command.payload[i], InvocationContext):
-                command.payload[i] = command.payload[i].__current_command
-
-        if self.__current_command is None:
-            return command
-        else:
-            return command.add_arg_to_payload_on_beginning(self.__current_command)

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/sdk/internal/RuntimeContext.py

@@ -1,69 +0,0 @@
-from javonet.core.handler.PythonHandler import PythonHandler
-from javonet.core.interpreter.PythonInterpreter import PythonInterpreter
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-
-from javonet.sdk.core.RuntimeLib import RuntimeLib
-from javonet.sdk.internal.ConnectionType import ConnectionType
-from javonet.sdk.internal.InvocationContext import InvocationContext
-from javonet.sdk.internal.abstract.AbstractTypeContext import AbstractTypeContext
-
-
-class RuntimeContext(AbstractTypeContext):
-    __python_interpreter = PythonInterpreter()
-    __python_handler = PythonHandler()
-    __memory_runtime_contexts = dict()
-    __network_runtime_contexts = dict()
-    current_command = None
-
-    @staticmethod
-    def get_instance(runtime_lib: RuntimeLib, connection_type: ConnectionType, tcp_address: str):
-        if connection_type == ConnectionType.Tcp and tcp_address is not None:
-            if tcp_address in RuntimeContext.__network_runtime_contexts:
-                runtime_ctx = RuntimeContext.__network_runtime_contexts.get(tcp_address)
-                runtime_ctx.current_command = None
-                return runtime_ctx
-            else:
-                runtime_ctx = RuntimeContext(runtime_lib, connection_type, tcp_address)
-                RuntimeContext.__network_runtime_contexts[tcp_address] = runtime_ctx
-                return runtime_ctx
-        else:
-            if runtime_lib in RuntimeContext.__memory_runtime_contexts:
-                runtime_ctx = RuntimeContext.__memory_runtime_contexts.get(runtime_lib)
-                runtime_ctx.current_command = None
-                return runtime_ctx
-            else:
-                runtime_ctx = RuntimeContext(runtime_lib, connection_type, None)
-                RuntimeContext.__memory_runtime_contexts[runtime_lib] = runtime_ctx
-                return runtime_ctx
-
-    def __init__(self, runtime_lib: RuntimeLib, connection_type: ConnectionType, tcp_address: str):
-        self.__isExecuted = False
-        self.__runtime_lib = runtime_lib
-        self.__connection_type = connection_type
-        self.__tcp_ip_address = tcp_address
-
-    def execute(self, command: PythonCommand):
-        if self.__runtime_lib is RuntimeLib.python:
-            RuntimeContext.__python_handler.HandleCommand(command)
-            self.__isExecuted = True
-        else:
-            RuntimeContext.__python_interpreter.execute(command, self.__connection_type, self.__tcp_ip_address)
-            self.__isExecuted = True
-
-    def load_library(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.LoadLibrary, [*args])
-        self.execute(local_command)
-        return self
-
-    def get_type(self, *args):
-        local_command = PythonCommand(self.__runtime_lib, PythonCommandType.GetType, [*args])
-        self.build_command(local_command)
-        return InvocationContext(self.__runtime_lib, self.__connection_type, self.__tcp_ip_address,
-                                 self.current_command)
-
-    def build_command(self, command):
-        if self.current_command is None:
-            self.current_command = command
-        else:
-            self.current_command = command.add_arg_to_payload_on_beginning(self.current_command)