javonet-ruby-sdk 2.5.13 → 2.5.15

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/PerlCommandType.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::PerlCommandType;
 use strict;
 use warnings;
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_command_type);
 
 my %command_type = (
     'Value'                     => 0,

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/RuntimeLib.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::RuntimeLib;
 use warnings;
 use strict;
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_runtime);
 
 my %runtimes = (
     'Clr'       => 0,
@@ -12,7 +14,9 @@ my %runtimes = (
     'Python'    => 5,
     'Ruby'      => 6,
     'Nodejs'    => 7,
-    'Cpp'       => 8
+    'Cpp'       => 8,
+    'Php'       => 9,
+    'Python2'   => 10
 );
 
 sub get_runtime {

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/RuntimeLogger.pm

@@ -1,19 +1,22 @@
 package Javonet::Sdk::Core::RuntimeLogger;
 use strict;
 use warnings;
+use Exporter qw(import);
+our @EXPORT = qw(rl_get_runtime_info print_runtime_info);
+
 use Config qw(%Config);
 use Cwd;
 use Sys::Hostname;
 
-our $not_logged_yet = 1;
+my $not_logged_yet = 1;
 
-sub get_runtime_info {
+sub rl_get_runtime_info {
     my $info;
     eval {
         $info = "Perl Managed Runtime Info:\n" .
             "Perl Version: $]\n" .
             "Perl executable path: $^X\n" .
-            "Perl \@INC Path: @INC\n" .
+            "Perl \\@INC Path: @INC\n" .
             "OS Version: " . $Config{osname} . " " . $Config{osvers} . "\n" .
             "Process Architecture: " . $Config{archname} . "\n" .
             "Current Working Directory: " . getcwd() . "\n";

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/StringEncodingMode.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::StringEncodingMode;
 use strict;
 use warnings;
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_string_encoding_mode);
 
 my %string_encoding_mode = (
     'ASCII'             => 0,

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/Type.pm

@@ -2,6 +2,8 @@ package Javonet::Sdk::Core::Type;
 use strict;
 use warnings FATAL => 'all';
 use Moose;
+use Exporter qw(import);
+our @EXPORT = qw(get_type);
 
 my %my_type = (
     'Command' => 0,

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/Abstract/AbstractRuntimeFactory.pm

@@ -19,6 +19,8 @@ sub nodejs : Abstract;
 
 sub python : Abstract;
 
+sub python27 : Abstract;
+
 
 no Moose;
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/RuntimeContext.pm

@@ -9,7 +9,7 @@ use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter', qw(execute_);
 use aliased 'Javonet::Core::Exception::ExceptionThrower' => 'ExceptionThrower';
 
-extends 'Javonet::Sdk::Internal::Abstract::AbstractModuleContext',
+extends 'Javonet::Sdk::Internal::Abstract::AbstractRuntimeContext',
     'Javonet::Sdk::Internal::Abstract::AbstractTypeContext';
 
 my $perl_handler = Javonet::Core::Handler::PerlHandler->new();

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/RuntimeFactory.pm

@@ -99,6 +99,16 @@ sub python {
     );
 }
 
+#@override
+sub python27 {
+    return Javonet::Sdk::Internal::RuntimeContext::get_instance(
+        Javonet::Sdk::Core::RuntimeLib::get_runtime('Python27'),
+        $connection_type,
+        $tcp_address,
+        $path
+    );
+}
+
 
 no Moose;
 1;

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

@@ -45,7 +45,7 @@ class GetTypeHandler(AbstractCommandHandler):
             exc_type, exc_value = type(e), e
             sys_path = "\n".join(sys.path)
             available_types = "\n".join(self.get_all_available_types())
-            new_message = str(e) + "\nLoaded directories:\n" + sys_path  + "\nAvailable user types:\n" + available_types + "\n\n\n"
+            new_message = str(e) + "\nMake sure to install python packages in one of this directories:\n" + sys_path  + "\n\nAvailable user types:\n" + available_types + "\n\n"
             new_exc = exc_type(new_message).with_traceback(e.__traceback__)
             raise new_exc from None
 

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

@@ -1,9 +1,11 @@
-from javonet.core.handler.AbstractCommandHandler import *
-import sys
+import importlib.util
 import os
+import sys
+
+from javonet.core.handler.AbstractCommandHandler import *
 
-class LoadLibraryHandler(AbstractCommandHandler):
 
+class LoadLibraryHandler(AbstractCommandHandler):
     loaded_directories = []
 
     def __init__(self):
@@ -17,8 +19,15 @@ class LoadLibraryHandler(AbstractCommandHandler):
             if os.path.isdir(command.payload[0]):
                 sys.path.append(command.payload[0])
                 LoadLibraryHandler.loaded_directories.append(command.payload[0])
+            elif os.path.isfile(command.payload[0]) and command.payload[0].endswith(".py"):
+                module_name = os.path.splitext(os.path.basename(command.payload[0]))[0]
+                spec = importlib.util.spec_from_file_location(module_name, command.payload[0])
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                sys.modules[module_name] = module
+                LoadLibraryHandler.loaded_directories.append(os.path.dirname(command.payload[0]))
             else:
-                raise Exception(command.payload[0] + " is not a valid directory")
+                raise Exception(command.payload[0] + " is not a valid directory or .py file")
 
             return 0
         except Exception as e:
@@ -28,4 +37,4 @@ class LoadLibraryHandler(AbstractCommandHandler):
 
     @staticmethod
     def get_loaded_directories():
-        return LoadLibraryHandler.loaded_directories
+        return LoadLibraryHandler.loaded_directories

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

@@ -11,7 +11,6 @@ handler = Handler()
 
 
 class Interpreter:
-    # Debug mode flag similar to C# implementation
     debug_mode = os.environ.get("JAVONET_DEBUG") == "TRUE"
 
     def execute(self, command, connection_data: IConnectionData):
@@ -45,7 +44,7 @@ class Interpreter:
 
         if self.debug_mode:
             print("Received command: " + str(received_command))
-            MessageHelper.send_message_to_app_insights_sync("ReceivedCommand", str(received_command))
+            MessageHelper.send_message_to_app_insights("ReceivedCommand", str(received_command))
 
         response = handler.handle_command(received_command)
 

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

@@ -48,7 +48,10 @@ class CommandDeserializer:
             Type.JavonetUnsignedInteger: self.read_uint,
             Type.JavonetNoneType: self.read_none
         }
-        return switch.get(type_value, lambda: Exception("Type not supported"))()
+        func = switch.get(type_value)
+        if func is None:
+            raise Exception("Type not supported")
+        return func()
 
     def read_command(self):
         p = self.position
@@ -56,16 +59,30 @@ class CommandDeserializer:
         runtime = self.buffer[p + 5]
         command_type = self.buffer[p + 6]
         self.position += 7
-        return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
-        return self.read_command_recursively(number_of_elements_in_payload, return_command)
-
-    def read_command_recursively(self, number_of_elements_in_payload_left, cmd):
-        if number_of_elements_in_payload_left == 0:
-            return cmd
-        else:
-            p = self.position
-            cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
-            return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
+        
+        payload = [
+            self.read_object(self.buffer[self.position])
+            for _ in range(number_of_elements_in_payload)
+        ]
+        return Command(RuntimeName(runtime), CommandType(command_type), payload)
+
+    # old implementation
+    # def read_command(self):
+    #     p = self.position
+    #     number_of_elements_in_payload = TypeDeserializer.deserialize_int(self.buffer[p + 1: p + 5])
+    #     runtime = self.buffer[p + 5]
+    #     command_type = self.buffer[p + 6]
+    #     self.position += 7
+    #     return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
+    #     return self.read_command_recursively(number_of_elements_in_payload, return_command)
+    #
+    # def read_command_recursively(self, number_of_elements_in_payload_left, cmd):
+    #     if number_of_elements_in_payload_left == 0:
+    #         return cmd
+    #     else:
+    #         p = self.position
+    #         cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
+    #         return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
 
     def read_string(self):
         p = self.position

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

@@ -1,28 +1,29 @@
+import io
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
 from javonet.utils.RuntimeName import RuntimeName
 from javonet.utils.connectionData.IConnectionData import IConnectionData
 
-
 class CommandSerializer:
-    buffer = []
-
     def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
-        self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
-        self.insert_into_buffer(connection_data.serialize_connection_data())
-        self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
-        self.serialize_recursively(root_command)
-        return self.buffer
+        ms = io.BytesIO()
+
+        ms.write(bytes([root_command.runtime_name.value, runtime_version]))
+
+        if connection_data is not None:
+            ms.write(bytes(connection_data.serialize_connection_data()))
+        else:
+            ms.write(bytes([0, 0, 0, 0, 0, 0, 0]))
 
-    def serialize_recursively(self, command):
+        ms.write(bytes([RuntimeName.python.value, root_command.command_type.value]))
+
+        self.serialize_recursively(root_command, ms)
+        return ms.getvalue()
+
+    def serialize_recursively(self, command: Command, ms: io.BytesIO):
         for item in command.get_payload():
             if isinstance(item, Command):
-                self.insert_into_buffer(TypeSerializer.serialize_command(item))
-                self.serialize_recursively(item)
+                ms.write(bytes(TypeSerializer.serialize_command(item)))
+                self.serialize_recursively(item, ms)
             else:
-                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
-
-        return
-
-    def insert_into_buffer(self, arguments):
-        self.buffer = self.buffer + arguments
+                ms.write(bytes(TypeSerializer.serialize_primitive(item)))

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

@@ -22,6 +22,7 @@ class Receiver:
             exception_string = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
             # Send to App Insights
             MessageHelper.send_message_to_app_insights_sync("ReceiverUnhandledException", exception_string)
+            print(exception_string)
             # Call the original handler
             self.original_excepthook(exc_type, exc_value, exc_traceback)
 

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/transmitter/TransmitterWrapper.py

@@ -1,7 +1,6 @@
 import os
 import platform
 from ctypes import *
-
 from javonet.core.callback.callbackFunc import callbackFunc
 
 CMPFUNC = CFUNCTYPE(py_object, POINTER(c_ubyte), c_int)
@@ -9,61 +8,63 @@ callbackFunction = CMPFUNC(callbackFunc)
 
 
 class TransmitterWrapper:
-    file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-    machine = platform.machine().lower()
-    if '64' in machine:
-        arch = 'X64'
-    elif 'arm' in machine:
-        arch = 'ARM64' if '64' in machine else 'ARM'
-    else:
-        arch = 'X86'
-
-    if platform.system() == 'Windows':
-        python_lib_path = file_path + f'/Binaries/Native/Windows/{arch}/JavonetPythonRuntimeNative.dll'
-    elif platform.system() == 'Linux':
-        python_lib_path = file_path + f'/Binaries/Native/Linux/{arch}/libJavonetPythonRuntimeNative.so'
-    elif platform.system() == 'Darwin':
-        python_lib_path = file_path + f'/Binaries/Native/MacOs/{arch}/libJavonetPythonRuntimeNative.dylib'
-    else:
-        raise RuntimeError("Unsupported OS: " + platform.system())
+    _python_lib = None
 
-    python_lib = cdll.LoadLibrary(python_lib_path)
-    python_lib.SetCallback(callbackFunction)
+    @staticmethod
+    def get_native_lib():
+        if TransmitterWrapper._python_lib is None:
+            file_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            machine = platform.machine().lower()
+            if '64' in machine:
+                arch = 'X64'
+            elif 'arm' in machine:
+                arch = 'ARM64' if '64' in machine else 'ARM'
+            else:
+                arch = 'X86'
+
+            if platform.system() == 'Windows':
+                python_lib_path = file_path + f'/Binaries/Native/Windows/{arch}/JavonetPythonRuntimeNative.dll'
+            elif platform.system() == 'Linux':
+                python_lib_path = file_path + f'/Binaries/Native/Linux/{arch}/libJavonetPythonRuntimeNative.so'
+            elif platform.system() == 'Darwin':
+                python_lib_path = file_path + f'/Binaries/Native/MacOs/{arch}/libJavonetPythonRuntimeNative.dylib'
+            else:
+                raise RuntimeError("Unsupported OS: " + platform.system())
+            lib = cdll.LoadLibrary(python_lib_path)
+            lib.SetCallback(callbackFunction)
+            TransmitterWrapper._python_lib = lib
+        return TransmitterWrapper._python_lib
 
     @staticmethod
     def send_command(message):
+        lib = TransmitterWrapper.get_native_lib()
         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))
+        response_array_len = 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)
+            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 = 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))
+            raise RuntimeError("Javonet native error code: " + str(response_array_len) + ". " + str(error_message))
 
     @staticmethod
     def activate(license_key):
-        activate = TransmitterWrapper.python_lib.Activate
+        lib = TransmitterWrapper.get_native_lib()
+        activate = lib.Activate
         activate.restype = c_int
         activate.argtypes = [c_char_p]
-
         activation_result = activate(license_key.encode('ascii'))
-
         if activation_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
@@ -74,15 +75,14 @@ class TransmitterWrapper:
             return activation_result
 
     @staticmethod
-    def set_config_source(sourcePath):
-        set_config_source = TransmitterWrapper.python_lib.SetConfigSource
+    def set_config_source(source_path):
+        lib = TransmitterWrapper.get_native_lib()
+        set_config_source = lib.SetConfigSource
         set_config_source.restype = c_int
         set_config_source.argtypes = [c_char_p]
-
-        set_config_result = set_config_source(sourcePath.encode('utf-8'))
-
+        set_config_result = set_config_source(source_path.encode('utf-8'))
         if set_config_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
@@ -94,19 +94,17 @@ class TransmitterWrapper:
 
     @staticmethod
     def set_javonet_working_directory(path):
-        set_working_directory = TransmitterWrapper.python_lib.SetWorkingDirectory
+        lib = TransmitterWrapper.get_native_lib()
+        set_working_directory = lib.SetWorkingDirectory
         set_working_directory.restype = c_int
         set_working_directory.argtypes = [c_char_p]
-
         set_working_directory_result = set_working_directory(path.encode('utf-8'))
-
         if set_working_directory_result < 0:
-            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error = lib.GetNativeError
             get_native_error.restype = c_char_p
             get_native_error.argtypes = []
             error_message = get_native_error()
-            raise RuntimeError(
-                "Javonet set working directory result: " + str(set_working_directory_result) + ". Native error message: " + str(
-                    error_message))
+            raise RuntimeError("Javonet set working directory result: " + str(
+                set_working_directory_result) + ". Native error message: " + str(error_message))
         else:
-            return set_working_directory_result
+            return set_working_directory_result

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

@@ -69,7 +69,7 @@ class Command:
     def __str__(self):
         try:
             result = "RuntimeName "
-            result += str(self.runtime_name)
+            result += str(self.runtime_name).capitalize()
             result += " "
             result += "CommandType "
             result += str(self.command_type)

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/RuntimeName.py

@@ -11,6 +11,8 @@ class RuntimeName(Enum):
     ruby = 6
     nodejs = 7
     cpp = 8
+    php = 9
+    python27 = 10
 
     def __str__(self):
         return self.name

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/RuntimeNameHandler.py

@@ -22,5 +22,9 @@ class RuntimeNameHandler:
                 return "ruby"
             elif runtime_name == RuntimeName.nodejs:
                 return "nodejs"
+            elif runtime_name == RuntimeName.php:
+                return "php"
+            elif runtime_name == RuntimeName.python27:
+                return "python27"
         else:
             raise Exception("Invalid runtime name.")

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/exception/ExceptionSerializer.py

@@ -1,9 +1,7 @@
 import os
 import traceback
 
-from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
 from javonet.utils.ExceptionType import ExceptionType
-
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 
@@ -17,28 +15,36 @@ class ExceptionSerializer:
         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()
+
+        # Use lists to collect strings, then join using the pipe separator.
+        stack_classes = []
+        stack_methods = []
+        stack_lines = []
+        stack_files = []
 
         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("|")
+                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename))
+                stack_methods.append(frame_summary.name)
+                stack_lines.append(str(frame_summary.lineno))
+                stack_files.append(frame_summary.filename)
+
+        # Join list items with '|' and add a trailing '|' if needed.
+        stack_classes_str = "|".join(stack_classes) + "|" if stack_classes else ""
+        stack_methods_str = "|".join(stack_methods) + "|" if stack_methods else ""
+        stack_lines_str = "|".join(stack_lines) + "|" if stack_lines else ""
+        stack_files_str = "|".join(stack_files) + "|" if stack_files else ""
 
         exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
         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__())
-        exception_command = exception_command.add_arg_to_payload(stack_methods.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_lines.__str__())
-        exception_command = exception_command.add_arg_to_payload(stack_files.__str__())
+        exception_command = exception_command.add_arg_to_payload(stack_classes_str)
+        exception_command = exception_command.add_arg_to_payload(stack_methods_str)
+        exception_command = exception_command.add_arg_to_payload(stack_lines_str)
+        exception_command = exception_command.add_arg_to_payload(stack_files_str)
 
         return exception_command
 
@@ -57,4 +63,4 @@ class ExceptionSerializer:
 
     @staticmethod
     def format_class_name_from_file(filename):
-        return os.path.splitext((os.path.split(filename)[1]))[0]
+        return os.path.splitext(os.path.split(filename)[1])[0]

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/exception/ExceptionThrower.py

@@ -9,45 +9,49 @@ class ExceptionThrower:
 
     @staticmethod
     def throw_exception(command_exception: Command):
-        stack_classes, stack_methods, stack_lines, stack_files = "", "", "", ""
-        exception_message = "Python Exception with empty message"
-        exception_name = "Python exception"
-        javonet_stack_command = ""
-        traceback_str = ""
-
-        exception_payload_len = len(command_exception.payload)
-        if exception_payload_len >=8:
-            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])
-
-        if exception_payload_len >= 4:
-            exception_message = command_exception.get_payload()[3]
-
-        if exception_payload_len >= 3:
-            exception_name = command_exception.get_payload()[2]
-
-        if exception_payload_len >= 2:
-            javonet_stack_command = command_exception.get_payload()[1]
-
-        if exception_payload_len >= 1:
-            original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
-
-
-        for i in range(len(stack_classes)):
-            if i < len(stack_files) and stack_files[i]:
-                traceback_str += "File \"{}\"".format(stack_files[i])
-            if i < len(stack_lines) and stack_lines[i]:
-                traceback_str += ", line {}".format(stack_lines[i])
-            if i < len(stack_methods) and stack_methods[i]:
-                traceback_str += ", in {}".format(stack_methods[i])
-            traceback_str += "\n"
-            if i < len(stack_classes) and stack_classes[i]:
-                traceback_str += "    {}\n".format(stack_classes[i])
-
-        return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
+        try:
+            stack_classes, stack_methods, stack_lines, stack_files = "", "", "", ""
+            exception_message = "Python Exception with empty message"
+            exception_name = "Python exception"
+            javonet_stack_command = ""
+            traceback_str = ""
+            original_exception = ""
+
+            exception_payload_len = len(command_exception.payload)
+            if exception_payload_len >=8:
+                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])
+
+            if exception_payload_len >= 4:
+                exception_message = command_exception.get_payload()[3]
+
+            if exception_payload_len >= 3:
+                exception_name = command_exception.get_payload()[2]
+
+            if exception_payload_len >= 2:
+                javonet_stack_command = command_exception.get_payload()[1]
+
+            if exception_payload_len >= 1:
+                original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
+
+
+            for i in range(len(stack_classes)):
+                if i < len(stack_files) and stack_files[i]:
+                    traceback_str += "File \"{}\"".format(stack_files[i])
+                if i < len(stack_lines) and stack_lines[i]:
+                    traceback_str += ", line {}".format(stack_lines[i])
+                if i < len(stack_methods) and stack_methods[i]:
+                    traceback_str += ", in {}".format(stack_methods[i])
+                traceback_str += "\n"
+                if i < len(stack_classes) and stack_classes[i]:
+                    traceback_str += "    {}\n".format(stack_classes[i])
+
+            return ExceptionThrower.raise_exception(original_exception, exception_message, traceback_str)
+        except Exception as e:
+            return JavonetException(str(e), "Error while processing exception: " + str(command_exception), "")
 
     @staticmethod
     def raise_exception(original_exception, exception_message, traceback_str):