javonet-nodejs-sdk 2.4.10 → 2.5.0

package/Binaries/Perl/MacOs/X64/lib/Javonet/Sdk/Internal/RuntimeFactory.pm

@@ -1,104 +0,0 @@
-package Javonet::Sdk::Internal::RuntimeFactory;
-use strict;
-use warnings FATAL => 'all';
-use Moose;
-use aliased 'Javonet::Sdk::Internal::RuntimeContext' => 'RuntimeContext';
-extends 'Javonet::Sdk::Internal::Abstract::AbstractRuntimeFactory';
-
-my $connection_type;
-my $tcp_address;
-my $path;
-
-#@override
-sub new {
-    my $class = shift;
-    my $self = {
-        connection_type => shift,
-        tcp_address     => shift,
-        path           => shift
-    };
-    $connection_type = $self->{connection_type};
-    $tcp_address = $self->{tcp_address};
-    $path = $self->{path};
-    if($connection_type eq Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp')){
-        if(not( defined $tcp_address || $tcp_address eq "" )){
-            die("Error: Tcp ip address must be specified");
-        }
-    }
-    bless $self, $class;
-    return $self;
-}
-
-#@override
-sub clr {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Clr'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-#@override
-sub jvm {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Jvm'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-#@override
-sub netcore {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Netcore'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-#@override
-sub perl {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-#@override
-sub ruby {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Ruby'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-#@override
-sub nodejs {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Nodejs'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-#@override
-sub python {
-    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
-        Javonet::Sdk::Core::RuntimeLib::get_runtime('Python'),
-        $connection_type,
-        $tcp_address,
-        $path
-    );
-}
-
-
-no Moose;
-1;

package/Binaries/Python/Linux/X64/javonet/core/transmitter/TransmitterWrapper.py

@@ -1,86 +0,0 @@
-import os
-import platform
-from ctypes import *
-
-from javonet.core.callback.callbackFunc import callbackFunc
-
-CMPFUNC = CFUNCTYPE(py_object, POINTER(c_ubyte), c_int)
-callbackFunction = CMPFUNC(callbackFunc)
-
-
-class TransmitterWrapper:
-    if platform.system() == 'Windows':
-        file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-        python_lib_path = file_path + '\\Binaries\\Native\\Windows\\X64\\JavonetPythonRuntimeNative.dll'
-    if platform.system() == 'Linux':
-        file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-        python_lib_path = file_path + '/Binaries/Native/Linux/X64/libJavonetPythonRuntimeNative.so'
-    if platform.system() == 'Darwin':
-        file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-        python_lib_path = file_path + '/Binaries/Native/MacOs/X64/libJavonetPythonRuntimeNative.dylib'
-
-    python_lib = cdll.LoadLibrary(python_lib_path)
-    python_lib.SetCallback(callbackFunction)
-
-    @staticmethod
-    def send_command(message):
-        message_array = bytearray(message)
-        message_ubyte_array = c_ubyte * len(message_array)
-        response_array_len = TransmitterWrapper.python_lib.SendCommand(
-            message_ubyte_array.from_buffer(message_array),
-            len(message_array))
-        if response_array_len > 0:
-            response = bytearray(response_array_len)
-            response_ubyte_array = c_ubyte * response_array_len
-            TransmitterWrapper.python_lib.ReadResponse(response_ubyte_array.from_buffer(response),
-                                                       response_array_len)
-            return response
-        elif response_array_len == 0:
-            error_message = "Response is empty"
-            raise RuntimeError(error_message)
-        else:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
-            get_native_error.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(license_key):
-        activate = TransmitterWrapper.python_lib.Activate
-        activate.restype = c_int
-        activate.argtypes = [c_char_p, c_char_p, c_char_p, c_char_p]
-
-        activation_result = activate(license_key.encode('ascii'),
-                                     "".encode('ascii'),
-                                     "".encode('ascii'),
-                                     "".encode('ascii'))
-
-        if activation_result < 0:
-            get_native_error = TransmitterWrapper.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
-        
-    @staticmethod
-    def set_config_source(sourcePath):
-        set_config_source = TransmitterWrapper.python_lib.SetConfigSource
-        set_config_source.restype = c_int
-        set_config_source.argtypes = [c_char_p]
-
-        set_config_result = set_config_source(sourcePath.encode('ascii'))
-
-        if set_config_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
-            get_native_error.restype = c_char_p
-            get_native_error.argtypes = []
-            error_message = get_native_error()
-            raise RuntimeError(
-                "Javonet set config source result: " + str(set_config_result) + ". Native error message: " + str(error_message))
-        else:
-            return set_config_result

package/Binaries/Python/MacOs/X64/javonet/core/callback/callbackFunc.py

@@ -1,5 +0,0 @@
-def callbackFunc(message_byte_array, message_byte_array_len):
-    from javonet.core.receiver.Receiver import Receiver
-    python_receiver = Receiver()
-    response = python_receiver.HeartBeat(message_byte_array, message_byte_array_len)
-    return response

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/AbstractGeneretatorHandler.py

@@ -1,8 +0,0 @@
-
-class AbstractGeneratorHandler:
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        raise NotImplementedError('subclasses must override generate_command()!')
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        raise NotImplementedError('subclasses must override generate_command()!')

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/CreateInstanceGeneratorHandler.py

@@ -1,44 +0,0 @@
-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.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 = 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))
-        create_instance_command = create_instance_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 create_instance_command, handlers))
-        parameter_types = []
-        parameter_names = list(inspect.getfullargspec(analyzed_object)[0])
-        parameters_dict = inspect.getfullargspec(analyzed_object)[6]
-        for parameter_name in parameter_names:
-            parameter_types.append(handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(
-                str(parameters_dict.get(parameter_name, "")),
-                create_instance_command,
-                handlers))
-
-        create_instance_command = create_instance_command.add_arg_to_payload(parameter_types[1:])
-        create_instance_command = create_instance_command.add_arg_to_payload(parameter_names[1:])
-        return create_instance_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-
-        existing_string_builder.append("    def __init__(self")
-        if len(used_object.get_payload()[3]) > 0:
-            existing_string_builder.append(", ")
-        CommonGenerator.process_method_arguments(existing_string_builder, common_command, used_object.get_payload()[2],
-                                                 used_object.get_payload()[3], handlers)
-        existing_string_builder.append("):")
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_BODY].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)
-
-        existing_string_builder.append("\n")

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GeneratorHandler.py

@@ -1,65 +0,0 @@
-import importlib
-import importlib.util
-import inspect
-import os
-from os import listdir
-from os.path import isfile, join
-
-from javonet.core.generator.handler.Handlers import Handlers
-from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-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 = 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[CommandType.GetType].
-                                   generate_command(handlers.types_to_analyze.pop(0), structured_command_for_class,
-                                                    handlers))
-
-        return structured_command_for_class
-
-    def generate(self, command, file_path):
-        generator_handlers = Handlers()
-        for i in range(0, len(command.get_payload())):
-            existing_string_builder = PythonStringBuilder()
-            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]),
-                                         file_path)
-            else:
-                raise Exception(
-                    "GeneratorHandlerException: Argument is not type of PythonCommand GetTypeCommand: " + str(
-                        command.getPayload()[i]))
-
-    def generate_class_file(self, existing_string_builder, class_file_name, file_path):
-        if not os.path.exists(file_path):
-            os.makedirs(file_path)
-        f = open(os.path.join(file_path, class_file_name) + ".py", "w+")
-        f.write(str(existing_string_builder))
-        f.close()
-
-    def return_classes_from_package(self, package_path):
-
-        onlyfiles = [f for f in listdir(package_path) if
-                     isfile(join(package_path, f))]
-        classes = []
-
-        for x in onlyfiles:
-            spec = importlib.util.spec_from_file_location(x[:-3], os.path.join(package_path, x))
-            foo = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(foo)
-            for name, obj in inspect.getmembers(foo):
-                if inspect.isclass(obj):
-                    classes.append(obj)
-
-        return classes

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GetInstanceFieldGeneratorHandler.py

@@ -1,36 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-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 = 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,
-                                                                                    handlers))
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(type(analyzed_object),
-                                                                             get_instance_field_command,
-                                                                             handlers))
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 get_instance_field_command, handlers))
-        return get_instance_field_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append(" ")
-        existing_string_builder.append("=")
-        existing_string_builder.append(" ")
-        handlers.SHARED_BODY_HANDLER[CommandType.GetInstanceField].generate_code(existing_string_builder,
-                                                                                 common_command,
-                                                                                 used_object,
-                                                                                 handlers)

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GetStaticFieldGeneratorHandler.py

@@ -1,39 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-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 = 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))
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(analyzed_object[1],
-                                                                             get_static_field_command,
-                                                                             handlers))
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object,
-                                                                                 get_static_field_command,
-                                                                                 handlers))
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_command(parent_command.get_payload()[0],
-                                                                                   get_static_field_command,
-                                                                                   handlers))
-        return get_static_field_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-
-        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[CommandType.GetStaticField].generate_code(existing_string_builder,
-                                                                               common_command,
-                                                                               used_object, handlers)

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/GetTypeGeneratorHandler.py

@@ -1,92 +0,0 @@
-import inspect
-
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-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 = 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__,
-                                                                                 get_type_command, handlers))
-        clazz_variables_names = [attr for attr in analyzed_object.__dict__ if
-                                 not callable(getattr(analyzed_object, attr)) and not attr.startswith("__")]
-        clazz_methods = inspect.getmembers(analyzed_object, predicate=inspect.isfunction)
-        clazz_constructor = getattr(analyzed_object, "__init__")
-
-        clazz_variables_dict = dict()
-        for method in clazz_methods:
-            method_type = self.inspect_type(analyzed_object, method[1])
-            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[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[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[CommandType.InvokeInstanceMethod].generate_command(
-                        method[1],
-                        get_type_command,
-                        handlers))
-
-        for clazz_variable_name in clazz_variables_names:
-            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[CommandType.GetStaticField].generate_command(
-                    dict_items,
-                    get_type_command,
-                    handlers))
-
-        return get_type_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("\n")
-        existing_string_builder.append("from javonet.sdk import Javonet")
-        existing_string_builder.append("\n")
-        existing_string_builder.append("class ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[1], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_code(existing_string_builder, common_command,
-                                                                            used_object.get_payload()[0], handlers)
-        existing_string_builder.append(":")
-        existing_string_builder.append("\n")
-        handlers.SHARED_HANDLER[SharedHandlerType.CLAZZ_INSTANCE].generate_code(existing_string_builder, common_command,
-                                                                                used_object, handlers)
-        existing_string_builder.append("\n")
-        for i in range(2, len(used_object.get_payload())):
-            handlers.GENERATOR_HANDLER[used_object.get_payload()[i].command_type].generate_code(existing_string_builder,
-                                                                                                common_command,
-                                                                                                used_object.get_payload()[
-                                                                                                    i], handlers)
-            existing_string_builder.append("\n")
-
-    def inspect_type(self, cls, func):
-        ftype = None
-        if func.__name__ == func.__qualname__:
-            return 'function'
-        elif '.<locals>' in func.__qualname__:
-            return 'function'
-        ftype = cls.__dict__.get(func.__name__)
-        if type(ftype) == staticmethod:
-            return 'staticmethod'
-        elif type(ftype) == classmethod:
-            return 'classmethod'
-        elif ftype.__class__.__name__ == 'function':
-            return 'instancemethod'
-        else:
-            raise TypeError('Unknown Type %s, Please check input is method or function' % func)

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/Handlers.py

@@ -1,59 +0,0 @@
-from javonet.core.generator.handler.CreateInstanceGeneratorHandler import CreateInstanceGeneratorHandler
-from javonet.core.generator.handler.GetInstanceFieldGeneratorHandler import GetInstanceFieldGeneratorHandler
-from javonet.core.generator.handler.GetStaticFieldGeneratorHandler import GetStaticFieldGeneratorHandler
-from javonet.core.generator.handler.GetTypeGeneratorHandler import GetTypeGeneratorHandler
-from javonet.core.generator.handler.InvokeInstanceMethodGeneratorHandler import InvokeInstanceMethodGeneratorHandler
-from javonet.core.generator.handler.InvokeStaticMethodGeneratorHandler import InvokeStaticMethodGeneratorHandler
-from javonet.core.generator.handler.shared.body.SharedBodyHandler import SharedBodyHandler
-from javonet.core.generator.handler.shared.body.SharedCreateInstanceBodyHandler import SharedCreateInstanceBodyHandler
-from javonet.core.generator.handler.shared.body.SharedGetInstanceFieldBodyHandler import \
-    SharedGetInstanceFieldBodyHandler
-from javonet.core.generator.handler.shared.body.SharedGetStaticFieldBodyHandler import SharedGetStaticFieldBodyHandler
-from javonet.core.generator.handler.shared.body.SharedGetTypeBodyHandler import SharedGetTypeBodyHandler
-from javonet.core.generator.handler.shared.body.SharedInvokeInstanceMethodBodyHandler import \
-    SharedInvokeInstanceMethodBodyHandler
-from javonet.core.generator.handler.shared.body.SharedInvokeStaticMethodBodyHandler import \
-    SharedInvokeStaticMethodBodyHandler
-from javonet.utils.CommandType import CommandType
-
-from javonet.core.generator.handler.shared.SharedArgumentNameHandler import SharedArgumentNameHandler
-from javonet.core.generator.handler.shared.SharedClassInstanceHandler import SharedClassInstanceHandler
-from javonet.core.generator.handler.shared.SharedClassNameHandler import SharedClassNameHandler
-from javonet.core.generator.handler.shared.SharedMethodNameHandler import SharedMethodNameHandler
-from javonet.core.generator.handler.shared.SharedModifierHandler import SharedModifierHandler
-from javonet.core.generator.handler.shared.SharedReturnTypeHandler import SharedReturnTypeHandler
-from javonet.core.generator.handler.shared.SharedTypeHandler import SharedTypeHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-
-
-class Handlers:
-
-    types_to_analyze = []
-
-    GENERATOR_HANDLER = dict()
-    SHARED_HANDLER = dict()
-    SHARED_BODY_HANDLER = dict()
-
-    def __init__(self):
-        self.SHARED_HANDLER[SharedHandlerType.ARGUMENT_NAME] = SharedArgumentNameHandler()
-        self.SHARED_HANDLER[SharedHandlerType.METHOD_BODY] = SharedBodyHandler()
-        self.SHARED_HANDLER[SharedHandlerType.CLASS_NAME] = SharedClassNameHandler()
-        self.SHARED_HANDLER[SharedHandlerType.METHOD_NAME] = SharedMethodNameHandler()
-        self.SHARED_HANDLER[SharedHandlerType.MODIFIER] = SharedModifierHandler()
-        self.SHARED_HANDLER[SharedHandlerType.TYPE] = SharedTypeHandler()
-        self.SHARED_HANDLER[SharedHandlerType.CLAZZ_INSTANCE] = SharedClassInstanceHandler()
-        self.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE] = SharedReturnTypeHandler()
-
-        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()

package/Binaries/Python/MacOs/X64/javonet/core/generator/handler/InvokeInstanceMethodGeneratorHandler.py

@@ -1,53 +0,0 @@
-import inspect
-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.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 = 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
-            handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_command(
-                typing.get_type_hints(analyzed_object),
-                invoke_instance_method_command,
-                handlers))
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 invoke_instance_method_command,
-                                                                                 handlers))
-        parameter_types = []
-        parameter_names = list(inspect.getfullargspec(analyzed_object)[0])
-        parameters_dict = inspect.getfullargspec(analyzed_object)[6]
-        for parameter_name in parameter_names:
-            parameter_types.append(handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(
-                str(parameters_dict.get(parameter_name, "")),
-                invoke_instance_method_command,
-                handlers))
-
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(parameter_types[1:])
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(parameter_names[1:])
-        return invoke_instance_method_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    def ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append("(self")
-        if len(used_object.get_payload()[4]) > 0:
-            existing_string_builder.append(", ")
-        CommonGenerator.process_method_arguments(existing_string_builder, common_command, used_object.get_payload()[3],
-                                                 used_object.get_payload()[4], handlers)
-        existing_string_builder.append("):")
-        existing_string_builder.append("\n")
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_BODY].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)