javonet-ruby-sdk 2.5.13 → 2.5.15

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/InvokeInstanceMethodHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeInstanceMethodHandler class handles instance method invocations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class InvokeInstanceMethodHandler(AbstractCommandHandler):
+    """
+    Handler for invoking instance methods.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance method invocation handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeInstanceMethod Parameters mismatch!")
+
+            class_instance = command.payload[0]
+            try:
+                method = getattr(class_instance, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(class_instance) if callable(getattr(class_instance, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], class_instance.__class__.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+            
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
+                return method(*method_arguments)
+            return method()
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in InvokeInstanceMethodHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/InvokeStaticMethodHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeStaticMethodHandler class handles static method invocations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class InvokeStaticMethodHandler(AbstractCommandHandler):
+    """
+    Handler for invoking static methods.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new static method invocation handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeStaticMethod Parameters mismatch!")
+
+            clazz = command.payload[0]
+            try:
+                method = getattr(clazz, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(clazz) if callable(getattr(clazz, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], clazz.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+            
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
+                return method(*method_arguments)
+            return method()
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in InvokeStaticMethodHandler: {0}\n{1}".format(str(e), tb_str)) 

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

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+"""
+The LoadLibraryHandler class handles library loading.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import os
+import traceback
+
+
+class LoadLibraryHandler(AbstractCommandHandler):
+    """
+    Handler for loading libraries.
+    """
+
+    # Class variable to store loaded directories
+    loaded_directories = []
+
+    def __init__(self):
+        """
+        Initializes a new library loading handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the LoadLibrary command.
+        
+        :param command: Command to process
+        :return: 0 on success
+        :raises: Exception if parameters mismatch or directory is invalid
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("LoadLibrary payload parameters mismatch")
+
+            # Check if path is a directory and add to sys.path
+            if os.path.isdir(command.payload[0]):
+                sys.path.append(command.payload[0])
+                LoadLibraryHandler.loaded_directories.append(command.payload[0])
+            else:
+                raise Exception(command.payload[0] + " is not a valid directory")
+
+            return 0
+            
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error loading library: {0}\n{1}".format(str(e), tb_str))
+
+    @staticmethod
+    def get_loaded_directories():
+        """
+        Get list of loaded directories.
+        
+        :return: List of loaded directory paths
+        """
+        return LoadLibraryHandler.loaded_directories

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/PassDelegateHandler.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+The PassDelegateHandler class handles delegate passing.
+"""
+
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class PassDelegateHandler(AbstractCommandHandler):
+    """
+    Handler for passing delegates.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new delegate passing handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            # TO BE IMPLEMENTED
+            return None
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in PassDelegateHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/ResolveInstanceHandler.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+import sys
+import traceback
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+
+
+class ResolveInstanceHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the ResolveInstance command.
+        
+        :param command: Command to process
+        :type command: Command
+        :return: Resolved instance
+        :raises: Exception if parameters mismatch or reference resolution fails
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            references_cache = ReferencesCache()
+            return references_cache.resolve_reference(command)
+            
+        except Exception as e:
+            # W Python 2.7 nie ma with_traceback i from None
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error resolving instance: {0}\n{1}".format(str(e), tb_str))

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/SetInstanceFieldHandler.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+The SetInstanceFieldHandler class handles setting instance fields.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class SetInstanceFieldHandler(AbstractCommandHandler):
+    """
+    Handler for setting instance fields.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance field setting handler.
+        """
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("SetInstanceFieldHandler parameters mismatch!")
+            instance = command.payload[0]
+            field = command.payload[1]
+            new_value = command.payload[2]
+            try:
+                setattr(instance, field, new_value)
+            except AttributeError:
+                fields = [field for field in dir(instance) if not callable(getattr(instance, field))]
+                message = "Field {} not found in class {}. Available fields:\n".format(field, instance.__class__.__name__)
+                for field in fields:
+                    message += "{}\n".format(field)
+                raise AttributeError(message)
+            return 0
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in SetInstanceFieldHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/SetStaticFieldHandler.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+The SetStaticFieldHandler class handles setting static fields.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class SetStaticFieldHandler(AbstractCommandHandler):
+    """
+    Handler for setting static fields.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new static field setting handler.
+        """
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("SetStaticFieldHandler parameters mismatch!")
+
+            clazz = command.payload[0]
+            field = command.payload[1]
+            new_value = command.payload[2]
+            try:
+                setattr(clazz, field, new_value)
+            except AttributeError:
+                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
+                message = "Field {} not found in class {}. Available fields:\n".format(field, clazz.__name__)
+                for field in fields:
+                    message += "{}\n".format(field)
+                raise AttributeError(message)
+            return 0
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in SetStaticFieldHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/ValueHandler.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+"""
+The ValueHandler class handles value operations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class ValueHandler(AbstractCommandHandler):
+    """
+    Handler for value operations.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new value operations handler.
+        """
+        pass
+
+    def process(self, command):
+        """
+        Handles a value operation command.
+
+        :param command: Command to handle
+        :return: Command value
+        """
+        return command.payload[0] 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*- 

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

@@ -0,0 +1,36 @@
+"""
+The Interpreter module implements the Javonet command interpreter.
+"""
+
+from javonet.core.handler.Handler import Handler
+from javonet.core.protocol.CommandDeserializer import CommandDeserializer
+from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.RuntimeName import RuntimeName
+
+handler = Handler()
+
+
+class Interpreter(object):
+    """
+    Class responsible for interpreting and executing Javonet commands.
+    """
+
+    def execute(self, command, connection_data):
+        message_byte_array = CommandSerializer().serialize(command, connection_data)
+        if connection_data.connection_type == ConnectionType.WebSocket:
+            from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
+            response_byte_array = WebSocketClient().send_message(connection_data, message_byte_array)
+        elif (command.runtime_name == RuntimeName.python27) & (
+                connection_data.connection_type == ConnectionType.InMemory):
+            from javonet.core.receiver.Receiver import Receiver
+            response_byte_array = Receiver().SendCommand(message_byte_array, len(message_byte_array))
+        else:
+            from javonet.core.transmitter.Transmitter import Transmitter
+            response_byte_array = Transmitter.send_command(message_byte_array)
+
+        return CommandDeserializer(response_byte_array).deserialize()
+
+    def process(self, message_byte_array):
+        received_command = CommandDeserializer(message_byte_array).deserialize()
+        return handler.handle_command(received_command)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/namespaceCache/NamespaceCache.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import re
+import types
+import threading
+
+
+class NamespaceCache(object):
+    _instance = None
+    namespace_cache = list()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._lock.acquire()
+            try:
+                if cls._instance is None:
+                    cls._instance = super(NamespaceCache, cls).__new__(cls)
+            finally:
+                cls._lock.release()
+        return cls._instance
+
+    def cache_namespace(self, namespace):
+        """
+        Cache a namespace.
+        
+        :param namespace: Namespace to cache
+        """
+        with self._lock:
+            # Handle Python 2.7 vs Python 3 module name differences
+            if namespace.startswith("builtins"):
+                namespace = namespace.replace("builtins", "__builtin__", 1)
+            
+            self.namespace_cache.append(namespace)
+
+    def is_namespace_cache_empty(self):
+        self._lock.acquire()
+        try:
+            return len(self.namespace_cache) == 0
+        finally:
+            self._lock.release()
+
+    def is_type_allowed(self, type_to_check):
+        self._lock.acquire()
+        try:
+            for pattern in self.namespace_cache:
+                if isinstance(type_to_check, types.ModuleType):
+                    if re.match(pattern, type_to_check.__name__):
+                        return True
+                else:
+                    if re.match(pattern, type_to_check.__module__):
+                        return True
+            return False
+        finally:
+            self._lock.release()
+
+    def get_cached_namespaces(self):
+        self._lock.acquire()
+        try:
+            return self.namespace_cache[:]
+        finally:
+            self._lock.release()
+
+    def clear_cache(self):
+        self._lock.acquire()
+        try:
+            del self.namespace_cache[:]
+            return 0
+        finally:
+            self._lock.release()

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/namespaceCache/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The namespaceCache package contains namespace caching implementation.
+"""

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

@@ -0,0 +1,237 @@
+# -*- coding: utf-8 -*-
+"""
+The CommandDeserializer module implements command deserialization.
+"""
+
+from javonet.core.protocol.TypeDeserializer import TypeDeserializer
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
+
+
+class CommandDeserializer(object):
+    """
+    Class responsible for command deserialization.
+    """
+    position = 0
+    buffer = []
+    command = 0
+    buffer_len = 0
+
+    def __init__(self, buffer):
+        """
+        Initializes a new command deserializer.
+
+        :param buffer: Buffer with data to deserialize
+        """
+        self.buffer = buffer
+        self.buffer_len = len(buffer)
+        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
+        self.position = 11
+
+    def is_at_end(self):
+        """
+        Checks if the end of buffer has been reached.
+
+        :return: True if end of buffer is reached, False otherwise
+        """
+        return self.position == self.buffer_len
+
+    def deserialize(self):
+        """
+        Deserializes a command.
+
+        :return: Deserialized command
+        """
+        while not self.is_at_end():
+            self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
+        return self.command
+
+    def read_object(self, type_num):
+        """
+        Reads an object from the buffer based on its type.
+
+        :param type_num: Type number
+        :return: Read object
+        """
+        type_value = Type(type_num)
+        switch = {
+            Type.Command: self.read_command,
+            Type.JavonetString: self.read_string,
+            Type.JavonetInteger: self.read_int,
+            Type.JavonetBoolean: self.read_bool,
+            Type.JavonetFloat: self.read_float,
+            Type.JavonetByte: self.read_byte,
+            Type.JavonetChar: self.read_char,
+            Type.JavonetLongLong: self.read_longlong,
+            Type.JavonetDouble: self.read_double,
+            Type.JavonetUnsignedLongLong: self.read_ullong,
+            Type.JavonetUnsignedInteger: self.read_uint,
+            Type.JavonetNoneType: self.read_none
+        }
+        return switch.get(type_value, lambda: Exception("Type not supported"))()
+
+    def read_command(self):
+        """
+        Reads a command from the buffer.
+
+        :return: Read command
+        """
+        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):
+        """
+        Recursively reads a command from the buffer.
+
+        :param number_of_elements_in_payload_left: Number of elements left to read
+        :param cmd: Command to populate
+        :return: Populated command
+        """
+        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):
+        """
+        Reads a string from the buffer.
+
+        :return: Read string
+        """
+        p = self.position
+        string_encoding_mode = StringEncodingMode(self.buffer[p + 1])
+        size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
+        self.position += 6
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
+
+    def read_int(self):
+        """
+        Reads an integer from the buffer.
+
+        :return: Read integer
+        """
+        size = 4
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
+
+    def read_bool(self):
+        """
+        Reads a boolean from the buffer.
+
+        :return: Read boolean
+        """
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_bool(self.buffer[p:p + size])
+
+    def read_float(self):
+        """
+        Reads a float from the buffer.
+
+        :return: Read float
+        """
+        size = 4
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
+
+    def read_byte(self):
+        """
+        Reads a byte from the buffer.
+
+        :return: Read byte
+        """
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_byte(self.buffer[p:p + size])
+
+    def read_char(self):
+        """
+        Reads a character from the buffer.
+
+        :return: Read character
+        """
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_char(self.buffer[p:p + size])
+
+    def read_longlong(self):
+        """
+        Reads a long long from the buffer.
+
+        :return: Read long long
+        """
+        size = 8
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
+
+    def read_double(self):
+        """
+        Reads a double from the buffer.
+
+        :return: Read double
+        """
+        size = 8
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
+
+    def read_ullong(self):
+        """
+        Reads an unsigned long long from the buffer.
+
+        :return: Read unsigned long long
+        """
+        size = 8
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
+
+    def read_uint(self):
+        """
+        Reads an unsigned integer from the buffer.
+
+        :return: Read unsigned integer
+        """
+        size = 4
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
+
+    def read_none(self):
+        """
+        Reads a None value from the buffer.
+
+        :return: Read None value
+        """
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])