javonet-ruby-sdk 2.5.14 → 2.5.16

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

@@ -0,0 +1,187 @@
+"""
+The TypeSerializer module implements type serialization.
+"""
+
+import struct
+
+from javonet.utils.Type import Type
+from javonet.utils.StringEncodingMode import StringEncodingMode
+
+
+class TypeSerializer(object):
+    """
+    Class responsible for type serialization.
+    """
+
+    @staticmethod
+    def serialize_primitive(payload_item):
+        """
+        Serializes a primitive value.
+
+        :param payload_item: Value to serialize
+        :return: Serialized value
+        :raises: Exception if type is not supported
+        """
+        if payload_item is None:
+            return TypeSerializer.serialize_none()
+        if isinstance(payload_item, bool):
+            return TypeSerializer.serialize_bool(payload_item)
+        elif isinstance(payload_item, (int, long)):
+            # In Python 2.7, we need to avoid using range() for large numbers
+            if -2**31 <= payload_item < 2**31:
+                return TypeSerializer.serialize_int(payload_item)
+            elif -2**63 <= payload_item < 2**63:
+                return TypeSerializer.serialize_longlong(payload_item)
+            else:
+                return TypeSerializer.serialize_ullong(payload_item)
+        elif isinstance(payload_item, float):
+            return TypeSerializer.serialize_double(payload_item)
+        elif isinstance(payload_item, (str, unicode)):
+            return TypeSerializer.serialize_string(payload_item)
+        elif isinstance(payload_item, bytearray):
+            return TypeSerializer.serialize_byte(payload_item)
+        else:
+            raise Exception("Python: Type serialization not supported for type: " + str(payload_item))
+
+    @staticmethod
+    def serialize_command(command):
+        """
+        Serializes a command.
+
+        :param command: Command to serialize
+        :return: Serialized command
+        """
+        length = list(bytearray(struct.pack("<i", len(command.payload))))
+        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]
+
+    @staticmethod
+    def serialize_string(string_value):
+        """
+        Serializes a string.
+
+        :param string_value: String to serialize
+        :return: Serialized string
+        """
+        if isinstance(string_value, unicode):
+            encoded_string_list = list(bytearray(string_value.encode('utf-8')))
+        else:
+            encoded_string_list = list(bytearray(string_value))
+        length = list(bytearray(struct.pack("<i", len(encoded_string_list))))
+        return [Type.JavonetString.value] + [StringEncodingMode.UTF8.value] + length + encoded_string_list
+
+    @staticmethod
+    def serialize_int(int_value):
+        """
+        Serializes an integer.
+
+        :param int_value: Integer to serialize
+        :return: Serialized integer
+        """
+        encoded_int_list = list(bytearray(struct.pack("<i", int_value)))
+        length = len(encoded_int_list)
+        return [Type.JavonetInteger.value, length] + encoded_int_list
+
+    @staticmethod
+    def serialize_bool(bool_value):
+        """
+        Serializes a boolean.
+
+        :param bool_value: Boolean to serialize
+        :return: Serialized boolean
+        """
+        encoded_bool_list = list(bytearray(struct.pack("?", bool_value)))
+        length = len(encoded_bool_list)
+        return [Type.JavonetBoolean.value, length] + encoded_bool_list
+
+    @staticmethod
+    def serialize_float(float_value):
+        """
+        Serializes a float.
+
+        :param float_value: Float to serialize
+        :return: Serialized float
+        """
+        encoded_float_list = list(bytearray(struct.pack("<f", float_value)))
+        length = len(encoded_float_list)
+        return [Type.JavonetFloat.value, length] + encoded_float_list
+
+    @staticmethod
+    def serialize_byte(bytes_value):
+        """
+        Serializes a byte.
+
+        :param bytes_value: Byte to serialize
+        :return: Serialized byte
+        """
+        encoded_byte_list = list(bytearray(struct.pack("<B", bytes_value)))
+        length = len(encoded_byte_list)
+        return [Type.JavonetByte.value, length] + encoded_byte_list
+
+    @staticmethod
+    def serialize_char(char_value):
+        """
+        Serializes a character.
+
+        :param char_value: Character to serialize
+        :return: Serialized character
+        """
+        encoded_char_list = list(bytearray(struct.pack("<b", char_value)))
+        length = len(encoded_char_list)
+        return [Type.JavonetChar.value, length] + encoded_char_list
+
+    @staticmethod
+    def serialize_longlong(longlong_value):
+        """
+        Serializes a long long.
+
+        :param longlong_value: Long long to serialize
+        :return: Serialized long long
+        """
+        encoded_longlong_list = list(bytearray(struct.pack("<q", longlong_value)))
+        length = len(encoded_longlong_list)
+        return [Type.JavonetLongLong.value, length] + encoded_longlong_list
+
+    @staticmethod
+    def serialize_double(double_value):
+        """
+        Serializes a double.
+
+        :param double_value: Double to serialize
+        :return: Serialized double
+        """
+        encoded_double_list = list(bytearray(struct.pack("<d", double_value)))
+        length = len(encoded_double_list)
+        return [Type.JavonetDouble.value, length] + encoded_double_list
+
+    @staticmethod
+    def serialize_ullong(unsigned_longlong_value):
+        """
+        Serializes an unsigned long long.
+
+        :param unsigned_longlong_value: Unsigned long long to serialize
+        :return: Serialized unsigned long long
+        """
+        encoded_unsignedlonglong_list = list(bytearray(struct.pack("<Q", unsigned_longlong_value)))
+        length = len(encoded_unsignedlonglong_list)
+        return [Type.JavonetUnsignedLongLong.value, length] + encoded_unsignedlonglong_list
+
+    @staticmethod
+    def serialize_uint(unsigned_int_value):
+        """
+        Serializes an unsigned integer.
+
+        :param unsigned_int_value: Unsigned integer to serialize
+        :return: Serialized unsigned integer
+        """
+        encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
+        length = len(encoded_unsigned_int_list)
+        return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list
+
+    @staticmethod
+    def serialize_none():
+        """
+        Serializes a None value.
+
+        :return: Serialized None value
+        """
+        return [Type.JavonetNoneType.value, 1, 0] 

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

@@ -0,0 +1,35 @@
+"""
+The Receiver module implements the message receiver.
+"""
+
+from javonet.core.interpreter.Interpreter import Interpreter
+from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.RuntimeLogger import RuntimeLogger
+from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
+from javonet.core.protocol.CommandDeserializer import CommandDeserializer
+
+
+class Receiver(object):
+    """
+    Class implementing the message receiver.
+    """
+
+    def __init__(self):
+        self.connection_data = InMemoryConnectionData()
+
+    def SendCommand(self, message_byte_array_as_string, messageByteArrayLen):
+        message_byte_array = bytearray(message_byte_array_as_string)
+        response_command = Interpreter().process(message_byte_array)
+        serialized_response = CommandSerializer().serialize(response_command, self.connection_data)
+        response_byte_array = bytearray(serialized_response)
+        return response_byte_array
+
+    def HeartBeat(self, message_byte_array_as_string, messageByteArrayLen):
+        message_byte_array = bytearray(message_byte_array_as_string)
+        response_byte_array = bytearray(2)
+        response_byte_array[0] = message_byte_array[11]
+        response_byte_array[1] = message_byte_array[12] - 2
+        return response_byte_array
+
+    def GetRuntimeInfo(self):
+        return RuntimeLogger().get_runtime_info()

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

@@ -0,0 +1 @@
+from .Receiver import Receiver

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/referenceCache/ReferencesCache.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+import uuid
+import threading
+from javonet.utils.CommandType import CommandType
+
+
+class ReferencesCache(object):
+    _instance = None
+    references_cache = dict()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        cls._lock.acquire()
+        try:
+            if cls._instance is None:
+                cls._instance = super(ReferencesCache, cls).__new__(cls)
+        finally:
+            cls._lock.release()
+        return cls._instance
+
+    def cache_reference(self, object_reference):
+        self._lock.acquire()
+        try:
+            uuid_ = str(uuid.uuid4())
+            self.references_cache[uuid_] = object_reference
+            return uuid_
+        finally:
+            self._lock.release()
+
+    def resolve_reference(self, command):
+        try:
+            command_val = command.command_type.value
+            ref_val = CommandType.Reference.value
+        except AttributeError:
+            command_val = command.command_type
+            ref_val = CommandType.Reference
+        if command_val != ref_val:
+            raise Exception("Trying to dereference Python command with command_type: " + str(command.command_type))
+        self._lock.acquire()
+        try:
+            try:
+                return self.references_cache[command.payload[0]]
+            except KeyError:
+                raise Exception("Object not found in references")
+        finally:
+            self._lock.release()
+
+    def delete_reference(self, reference_guid):
+        self._lock.acquire()
+        try:
+            try:
+                del self.references_cache[reference_guid]
+                return 0
+            except KeyError:
+                raise Exception("Object not found in references")
+        finally:
+            self._lock.release()

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/transmitter/Transmitter.py

@@ -0,0 +1,59 @@
+"""
+The Transmitter class serves as a facade for TransmitterWrapper.
+"""
+
+from javonet.core.transmitter.TransmitterWrapper import TransmitterWrapper
+
+
+class Transmitter(object):
+    """
+    Class serving as a facade for TransmitterWrapper.
+    """
+
+    @staticmethod
+    def send_command(message):
+        """
+        Sends a command to the native library.
+
+        :param message: Message to send
+        :return: Response from the native library
+        """
+        return TransmitterWrapper().send_command(message)
+
+    @staticmethod
+    def activate(license_key):
+        """
+        Activates Javonet with the provided license key.
+
+        :param license_key: License key
+        :return: Activation status code
+        """
+        return TransmitterWrapper.activate(license_key)
+
+    @staticmethod
+    def set_config_source(source_path):
+        """
+        Sets the configuration source.
+
+        :param source_path: Path to the configuration source
+        """
+        TransmitterWrapper().set_config_source(source_path)
+
+    @staticmethod
+    def set_working_directory(path):
+        """
+        Sets the working directory.
+
+        :param path: Path to the working directory
+        """
+        TransmitterWrapper().set_working_directory(path)
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        """
+        Sets the Javonet working directory.
+
+        :param path: Path to the working directory
+        :return: Operation status code
+        """
+        return TransmitterWrapper.set_javonet_working_directory(path) 

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

@@ -0,0 +1,102 @@
+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:
+    _python_lib = None
+
+    @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'
+
+            system_name = platform.system()
+            if system_name == 'Windows':
+                python_lib_path = file_path + '/Binaries/Native/Windows/{0}/JavonetPython2RuntimeNative.dll'.format(arch)
+            elif system_name == 'Linux':
+                python_lib_path = file_path + '/Binaries/Native/Linux/{0}/libJavonetPython2RuntimeNative.so'.format(arch)
+            elif system_name == 'Darwin':
+                python_lib_path = file_path + '/Binaries/Native/MacOs/{0}/libJavonetPython2RuntimeNative.dylib'.format(arch)
+            else:
+                raise RuntimeError("Unsupported OS: " + system_name)
+            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 = 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)
+            lib.ReadResponse(response_ubyte_array.from_buffer(response), response_array_len)
+            return response
+        elif response_array_len == 0:
+            raise RuntimeError("Response is empty")
+        else:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet native error code: {0}. {1}".format(response_array_len, error_message))
+
+    @staticmethod
+    def activate(license_key):
+        lib = TransmitterWrapper.get_native_lib()
+        activate_func = lib.Activate
+        activate_func.restype = c_int
+        activate_func.argtypes = [c_char_p]
+        # In Python 2, you can still use encode() to ensure a byte string.
+        activation_result = activate_func(license_key.encode('ascii'))
+        if activation_result < 0:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet activation result: {0}. Native error message: {1}".format(activation_result, error_message))
+        else:
+            return activation_result
+
+    @staticmethod
+    def set_config_source(source_path):
+        lib = TransmitterWrapper.get_native_lib()
+        set_config_source_func = lib.SetConfigSource
+        set_config_source_func.restype = c_int
+        set_config_source_func.argtypes = [c_char_p]
+        set_config_result = set_config_source_func(source_path.encode('utf-8'))
+        if set_config_result < 0:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet set config source result: {0}. Native error message: {1}".format(set_config_result, error_message))
+        else:
+            return set_config_result
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        lib = TransmitterWrapper.get_native_lib()
+        set_working_directory_func = lib.SetWorkingDirectory
+        set_working_directory_func.restype = c_int
+        set_working_directory_func.argtypes = [c_char_p]
+        set_working_directory_result = set_working_directory_func(path.encode('utf-8'))
+        if set_working_directory_result < 0:
+            lib.GetNativeError.restype = c_char_p
+            lib.GetNativeError.argtypes = []
+            error_message = lib.GetNativeError()
+            raise RuntimeError("Javonet set working directory result: {0}. Native error message: {1}".format(set_working_directory_result, error_message))
+        else:
+            return set_working_directory_result

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/typeCache/TypeCache.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import re
+import types
+import threading
+
+
+class TypeCache(object):
+    _instance = None
+    type_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(TypeCache, cls).__new__(cls)
+            finally:
+                cls._lock.release()
+        return cls._instance
+
+    def cache_type(self, type_name):
+        """
+        Cache a type.
+        
+        :param type_name: Type name to cache
+        """
+        with self._lock:
+            # Handle Python 2.7 vs Python 3 module name differences
+            if type_name.startswith("builtins"):
+                type_name = type_name.replace("builtins", "__builtin__", 1)
+            
+            self.type_cache.append(type_name)
+
+    def is_type_cache_empty(self):
+        self._lock.acquire()
+        try:
+            return len(self.type_cache) == 0
+        finally:
+            self._lock.release()
+
+    def is_type_allowed(self, type_to_check):
+        self._lock.acquire()
+        try:
+            if isinstance(type_to_check, types.ModuleType):
+                name_to_check = type_to_check.__name__
+            else:
+                name_to_check = ".".join([type_to_check.__module__, type_to_check.__name__])
+            for pattern in self.type_cache:
+                if re.match(pattern, name_to_check):
+                    return True
+            return False
+        finally:
+            self._lock.release()
+
+    def get_cached_types(self):
+        self._lock.acquire()
+        try:
+            return self.type_cache[:]
+        finally:
+            self._lock.release()
+
+    def clear_cache(self):
+        self._lock.acquire()
+        try:
+            del self.type_cache[:]
+            return 0
+        finally:
+            self._lock.release()

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

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

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/webSocketClient/WebSocketClient.py

@@ -0,0 +1,39 @@
+"""
+The WebSocketClient module implements a WebSocket client.
+"""
+
+import struct
+from websockets.sync.client import connect
+
+from javonet.utils.connectionData.WsConnectionData import WsConnectionData
+
+
+class WebSocketClient(object):
+    """
+    Class implementing a WebSocket client.
+    """
+
+    def send_message(self, connection_data, serialized_command):
+        """
+        Sends a message through WebSocket.
+
+        :param connection_data: Connection data
+        :param serialized_command: Serialized command
+        :return: Server response
+        """
+        byte_array = struct.pack("B" * len(serialized_command), *serialized_command)
+        return self.send(connection_data, byte_array)
+
+    def send(self, connection_data, byte_array):
+        """
+        Sends data through WebSocket.
+
+        :param connection_data: Connection data
+        :param byte_array: Byte array to send
+        :return: Server response
+        """
+        websocket = connect(connection_data.hostname)
+        websocket.send(byte_array)
+        response = websocket.recv()
+        websocket.close()
+        return response