javonet-ruby-sdk 2.5.13 → 2.5.15

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 

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

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""
+The Command class represents a command sent to the Javonet runtime environment.
+"""
+
+from javonet.utils.CommandType import CommandType
+
+
+class Command(object):
+
+    def __init__(self, runtime_name, command_type, payload):
+        """
+        Initializes a new command.
+
+        :param runtime_name: Runtime environment name
+        :param command_type: Command type
+        :param payload: Command payload
+        """
+        self.runtime_name = runtime_name
+        self.command_type = command_type
+        self.payload = payload
+
+    def get_payload(self):
+        """
+        Returns the command payload.
+
+        :return: Command payload
+        """
+        return self.payload
+
+    @staticmethod
+    def create_response(response, runtime_name):
+        """
+        Creates a response command.
+
+        :param response: Response
+        :param runtime_name: Runtime environment name
+        :return: New response command
+        """
+        return Command(runtime_name, CommandType.Value, [response])
+
+    @staticmethod
+    def create_reference(guid, runtime_name):
+        """
+        Creates a reference command.
+
+        :param guid: GUID identifier
+        :param runtime_name: Runtime environment name
+        :return: New reference command
+        """
+        return Command(runtime_name, CommandType.Reference, [guid])
+
+    @staticmethod
+    def create_array_response(array, runtime_name):
+        """
+        Creates an array response command.
+
+        :param array: Array
+        :param runtime_name: Runtime environment name
+        :return: New array response command
+        """
+        return Command(runtime_name, CommandType.Array, array)
+
+    def drop_first_payload_argument(self):
+        """
+        Removes the first argument from the payload.
+
+        :return: New command without the first argument
+        """
+        payload_args = []
+        payload_args.extend(self.payload)
+        if len(payload_args) != 0:
+            payload_args.pop(0)
+        return Command(self.runtime_name, self.command_type, payload_args)
+
+    def add_arg_to_payload(self, argument):
+        """
+        Adds an argument to the payload.
+
+        :param argument: Argument to add
+        :return: New command with the added argument
+        """
+        merged_payload = self.payload + [argument]
+        return Command(self.runtime_name, self.command_type, merged_payload)
+
+    def prepend_arg_to_payload(self, current_command):
+        """
+        Adds an argument to the beginning of the payload.
+
+        :param current_command: Current command
+        :return: New command with the argument added at the beginning
+        """
+        if current_command is None:
+            return Command(self.runtime_name, self.command_type, self.payload)
+        else:
+            return Command(self.runtime_name, self.command_type, [current_command] + self.payload)
+
+    def to_string(self):
+        """
+        Returns a text representation of the command.
+
+        :return: Text representation of the command
+        """
+        return 'Target runtime: ' + str(self.runtime_name) + ' Command type: ' + str(
+            self.command_type) + ' Payload: ' + str(self.payload)
+
+    def __eq__(self, other):
+        """
+        Compare this command with another element.
+        
+        :param other: Element to compare with
+        :return: True if equal, False otherwise
+        """
+        # Basic comparison
+        if not isinstance(other, self.__class__):
+            return False
+        
+        # Compare command_type and runtime_name as numeric values
+        if hasattr(self.command_type, 'value') and hasattr(other.command_type, 'value'):
+            if self.command_type.value != other.command_type.value:
+                return False
+        else:
+            # If they don't have value attribute, compare directly
+            if self.command_type != other.command_type:
+                return False
+            
+        if hasattr(self.runtime_name, 'value') and hasattr(other.runtime_name, 'value'):
+            if self.runtime_name.value != other.runtime_name.value:
+                return False
+        else:
+            if self.runtime_name != other.runtime_name:
+                return False
+        
+        # Compare payload length
+        if len(self.payload) != len(other.payload):
+            return False
+        
+        # Compare each payload item
+        for i in range(len(self.payload)):
+            # For simple types
+            if self.payload[i] != other.payload[i]:
+                return False
+                
+        return True
+
+    def __str__(self):
+        """
+        String representation of the command.
+        
+        :return: String representation
+        """
+        return "Command(type={0}, runtime={1}, payload_len={2})".format(
+            self.command_type, self.runtime_name, len(self.payload))
+        
+    def __repr__(self):
+        """
+        Detailed representation of the command.
+        
+        :return: Detailed representation
+        """
+        return self.__str__()
+
+    def __ne__(self, element):
+        """
+        Compare this command with another element for inequality.
+        
+        :param element: Element to compare with
+        :return: True if not equal, False otherwise
+        """
+        return not self.__eq__(element)

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/CommandType.py

@@ -0,0 +1,154 @@
+"""
+The CommandType class represents command types used in communication with Javonet.
+"""
+
+# Python 2 doesn't have an enum module, so we implement our own version
+class CommandType(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, CommandType):
+            return self.value == other.value
+        return False
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __str__(self):
+        return self._name_map.get(self.value, str(self.value))
+
+    def __repr__(self):
+        return "CommandType." + str(self)
+
+    Value = None  # These values will be set below
+    LoadLibrary = None
+    InvokeStaticMethod = None
+    GetStaticField = None
+    SetStaticField = None
+    CreateClassInstance = None
+    GetType = None
+    Reference = None
+    GetModule = None
+    InvokeInstanceMethod = None
+    Exception = None
+    HeartBeat = None
+    Cast = None
+    GetInstanceField = None
+    Optimize = None
+    GenerateLib = None
+    InvokeGlobalFunction = None
+    DestructReference = None
+    ArrayReference = None
+    ArrayGetItem = None
+    ArrayGetSize = None
+    ArrayGetRank = None
+    ArraySetItem = None
+    Array = None
+    RetrieveArray = None
+    SetInstanceField = None
+    InvokeGenericStaticMethod = None
+    InvokeGenericMethod = None
+    GetEnumItem = None
+    GetEnumName = None
+    GetEnumValue = None
+    AsRef = None
+    AsOut = None
+    GetRefValue = None
+    EnableNamespace = None
+    EnableType = None
+    CreateNull = None
+    GetStaticMethodAsDelegate = None
+    GetInstanceMethodAsDelegate = None
+    PassDelegate = None
+    InvokeDelegate = None
+    ConvertType = None
+
+    _name_map = {
+        0: 'Value',
+        1: 'LoadLibrary',
+        2: 'InvokeStaticMethod',
+        3: 'GetStaticField',
+        4: 'SetStaticField',
+        5: 'CreateClassInstance',
+        6: 'GetType',
+        7: 'Reference',
+        8: 'GetModule',
+        9: 'InvokeInstanceMethod',
+        10: 'Exception',
+        11: 'HeartBeat',
+        12: 'Cast',
+        13: 'GetInstanceField',
+        14: 'Optimize',
+        15: 'GenerateLib',
+        16: 'InvokeGlobalFunction',
+        17: 'DestructReference',
+        18: 'ArrayReference',
+        19: 'ArrayGetItem',
+        20: 'ArrayGetSize',
+        21: 'ArrayGetRank',
+        22: 'ArraySetItem',
+        23: 'Array',
+        24: 'RetrieveArray',
+        25: 'SetInstanceField',
+        26: 'InvokeGenericStaticMethod',
+        27: 'InvokeGenericMethod',
+        28: 'GetEnumItem',
+        29: 'GetEnumName',
+        30: 'GetEnumValue',
+        31: 'AsRef',
+        32: 'AsOut',
+        33: 'GetRefValue',
+        34: 'EnableNamespace',
+        35: 'EnableType',
+        36: 'CreateNull',
+        37: 'GetStaticMethodAsDelegate',
+        38: 'GetInstanceMethodAsDelegate',
+        39: 'PassDelegate',
+        40: 'InvokeDelegate',
+        41: 'ConvertType'
+    }
+
+# Initialize values
+CommandType.Value = CommandType(0)
+CommandType.LoadLibrary = CommandType(1)
+CommandType.InvokeStaticMethod = CommandType(2)
+CommandType.GetStaticField = CommandType(3)
+CommandType.SetStaticField = CommandType(4)
+CommandType.CreateClassInstance = CommandType(5)
+CommandType.GetType = CommandType(6)
+CommandType.Reference = CommandType(7)
+CommandType.GetModule = CommandType(8)
+CommandType.InvokeInstanceMethod = CommandType(9)
+CommandType.Exception = CommandType(10)
+CommandType.HeartBeat = CommandType(11)
+CommandType.Cast = CommandType(12)
+CommandType.GetInstanceField = CommandType(13)
+CommandType.Optimize = CommandType(14)
+CommandType.GenerateLib = CommandType(15)
+CommandType.InvokeGlobalFunction = CommandType(16)
+CommandType.DestructReference = CommandType(17)
+CommandType.ArrayReference = CommandType(18)
+CommandType.ArrayGetItem = CommandType(19)
+CommandType.ArrayGetSize = CommandType(20)
+CommandType.ArrayGetRank = CommandType(21)
+CommandType.ArraySetItem = CommandType(22)
+CommandType.Array = CommandType(23)
+CommandType.RetrieveArray = CommandType(24)
+CommandType.SetInstanceField = CommandType(25)
+CommandType.InvokeGenericStaticMethod = CommandType(26)
+CommandType.InvokeGenericMethod = CommandType(27)
+CommandType.GetEnumItem = CommandType(28)
+CommandType.GetEnumName = CommandType(29)
+CommandType.GetEnumValue = CommandType(30)
+CommandType.AsRef = CommandType(31)
+CommandType.AsOut = CommandType(32)
+CommandType.GetRefValue = CommandType(33)
+CommandType.EnableNamespace = CommandType(34)
+CommandType.EnableType = CommandType(35)
+CommandType.CreateNull = CommandType(36)
+CommandType.GetStaticMethodAsDelegate = CommandType(37)
+CommandType.GetInstanceMethodAsDelegate = CommandType(38)
+CommandType.PassDelegate = CommandType(39)
+CommandType.InvokeDelegate = CommandType(40)
+CommandType.ConvertType = CommandType(41) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/ConnectionType.py

@@ -0,0 +1,36 @@
+"""
+Connection type with the runtime.
+"""
+
+class ConnectionType(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, ConnectionType):
+            return self.value == other.value
+        return False
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __str__(self):
+        return self._name_map.get(self.value, str(self.value))
+
+    def __repr__(self):
+        return "ConnectionType." + str(self)
+
+    InMemory = None
+    Tcp = None
+    WebSocket = None
+
+    _name_map = {
+        0: 'InMemory',
+        1: 'Tcp',
+        2: 'WebSocket'
+    }
+
+# Initialize values
+ConnectionType.InMemory = ConnectionType(0)
+ConnectionType.Tcp = ConnectionType(1)
+ConnectionType.WebSocket = ConnectionType(2) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/ExceptionType.py

@@ -0,0 +1,95 @@
+"""
+The ExceptionType class represents exception types used in Javonet.
+"""
+
+class ExceptionType(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, ExceptionType):
+            return self.value == other.value
+        return False
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __str__(self):
+        return self._name_map.get(self.value, str(self.value))
+
+    def __repr__(self):
+        return "ExceptionType." + str(self)
+
+    Exception = None
+    IOException = None
+    FileNotFoundException = None
+    RuntimeException = None
+    ArithemticException = None
+    IllegalArgumentException = None
+    IndexOutOfBoundsException = None
+    NullPointerException = None
+    ZeroDivisionException = None
+
+    _name_map = {
+        0: 'Exception',
+        1: 'IOException',
+        2: 'FileNotFoundException',
+        3: 'RuntimeException',
+        4: 'ArithemticException',
+        5: 'IllegalArgumentException',
+        6: 'IndexOutOfBoundsException',
+        7: 'NullPointerException',
+        8: 'ZeroDivisionException'
+    }
+
+    @staticmethod
+    def to_enum(exception_name):
+        if exception_name == "Exception":
+            return ExceptionType.Exception.value
+        if exception_name == "IOError":
+            return ExceptionType.IOException.value
+        if exception_name == "IOError":  # In Python 2 FileNotFoundError is IOError
+            return ExceptionType.FileNotFoundException.value
+        if exception_name == "RuntimeError":
+            return ExceptionType.RuntimeException.value
+        if exception_name == "ArithmeticError":
+            return ExceptionType.ArithemticException.value
+        if exception_name == "IndexError":
+            return ExceptionType.IndexOutOfBoundsException.value
+        if exception_name == "AttributeError":
+            return ExceptionType.NullPointerException.value
+        if exception_name == "ZeroDivisionError":
+            return ExceptionType.ZeroDivisionException.value
+        else:
+            return ExceptionType.Exception.value
+
+    @staticmethod
+    def to_exception(exception_enum):
+        if exception_enum == ExceptionType.Exception.value:
+            return Exception
+        if exception_enum == ExceptionType.IOException.value:
+            return IOError
+        if exception_enum == ExceptionType.FileNotFoundException.value:
+            return IOError  # In Python 2 we use IOError instead of FileNotFoundError
+        if exception_enum == ExceptionType.RuntimeException.value:
+            return RuntimeError
+        if exception_enum == ExceptionType.ArithemticException.value:
+            return ArithmeticError
+        if exception_enum == ExceptionType.IndexOutOfBoundsException.value:
+            return IndexError
+        if exception_enum == ExceptionType.NullPointerException.value:
+            return AttributeError
+        if exception_enum == ExceptionType.ZeroDivisionException.value:
+            return ZeroDivisionError
+        else:
+            return Exception
+
+ExceptionType.Exception = ExceptionType(0)
+ExceptionType.IOException = ExceptionType(1)
+ExceptionType.FileNotFoundException = ExceptionType(2)
+ExceptionType.RuntimeException = ExceptionType(3)
+ExceptionType.ArithemticException = ExceptionType(4)
+ExceptionType.IllegalArgumentException = ExceptionType(5)
+ExceptionType.IndexOutOfBoundsException = ExceptionType(6)
+ExceptionType.NullPointerException = ExceptionType(7)
+ExceptionType.ZeroDivisionException = ExceptionType(8) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/PythonStringBuilder.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+The PythonStringBuilder class provides string building functionality similar to StringBuilder in other languages.
+"""
+
+from StringIO import StringIO
+
+
+class PythonStringBuilder(object):
+    """
+    Class for building strings efficiently in Python 2.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new string builder.
+        """
+        self._file_str = StringIO()
+
+    def append(self, string):
+        """
+        Appends a string to the builder.
+
+        :param string: String to append
+        :return: Self for method chaining
+        :rtype: PythonStringBuilder
+        """
+        self._file_str.write(unicode(string))
+        return self
+
+    def __str__(self):
+        """
+        Returns the built string.
+
+        :return: The complete string
+        :rtype: str
+        """
+        return self._file_str.getvalue() 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/utils/RuntimeLogger.py

@@ -0,0 +1,50 @@
+import platform
+import os
+import sys
+
+
+class RuntimeLogger(object):
+    """
+    Class for logging runtime environment information.
+    """
+    not_logged_yet = True
+
+    @staticmethod
+    def get_runtime_info():
+        """
+        Gets information about the runtime environment.
+
+        :return: Runtime environment information
+        :rtype: str
+        """
+        try:
+            return (
+                "Python Managed Runtime Info:\n"
+                "Python Version: {0}\n"
+                "Python executable path: {1}\n"
+                "Python Path: {2}\n"
+                "Python Implementation: {3}\n"
+                "OS Version: {4} {5}\n"
+                "Process Architecture: {6}\n"
+                "Current Working Directory: {7}\n"
+            ).format(
+                platform.python_version(),
+                sys.executable,
+                sys.path,
+                platform.python_implementation(),
+                platform.system(),
+                platform.version(),
+                platform.machine(),
+                os.getcwd()
+            )
+        except Exception as e:
+            return "Python Managed Runtime Info: Error while fetching runtime info"
+
+    @staticmethod
+    def display_runtime_info():
+        """
+        Displays information about the runtime environment (only once).
+        """
+        if RuntimeLogger.not_logged_yet:
+            print(RuntimeLogger.get_runtime_info())  # In Python 2 print is not a function
+            RuntimeLogger.not_logged_yet = False