javonet-ruby-sdk 2.5.14 → 2.5.15

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]) 

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

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""
+The CommandSerializer module implements command serialization.
+"""
+
+from javonet.core.protocol.TypeSerializer import TypeSerializer
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class CommandSerializer(object):
+    """
+    Class responsible for command serialization.
+    """
+    buffer = []
+
+    def serialize(self, root_command, connection_data, runtime_version=0):
+        """
+        Serializes a command.
+
+        :param root_command: Command to serialize
+        :param connection_data: Connection data
+        :param runtime_version: Runtime version
+        :return: Serialized command
+        """
+        self.buffer = []  # Reset buffer for each serialization
+        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
+
+    def serialize_recursively(self, command):
+        """
+        Serializes a command recursively.
+
+        :param command: Command to serialize
+        """
+        for item in command.get_payload():
+            if isinstance(item, Command):
+                self.insert_into_buffer(TypeSerializer.serialize_command(item))
+                self.serialize_recursively(item)
+            else:
+                self.insert_into_buffer(TypeSerializer.serialize_primitive(item))
+
+        return
+
+    def insert_into_buffer(self, arguments):
+        """
+        Inserts arguments into the buffer.
+
+        :type arguments: list
+        """
+        self.buffer = self.buffer + arguments