javonet-ruby-sdk 2.5.14 → 2.5.16

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 

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

@@ -0,0 +1,120 @@
+"""
+The RuntimeName class represents available runtime environments in Javonet.
+"""
+
+# -*- coding: utf-8 -*-
+
+# RuntimeName enumeration with the same values as in Python 3 version
+class RuntimeName(object):
+    """
+    Enumeration of runtime names.
+    """
+    # Keep the exact same values as in the original
+    clr = 0
+    go = 1
+    jvm = 2
+    netcore = 3
+    perl = 4
+    python = 5
+    ruby = 6
+    nodejs = 7
+    cpp = 8
+    php = 9
+    python27 = 10
+    
+    # Static instances to mimic Enum behavior
+    CLR = 0
+    GO = 1
+    JVM = 2
+    NETCORE = 3
+    PERL = 4
+    PYTHON = 5
+    RUBY = 6
+    NODEJS = 7
+    CPP = 8
+    PHP = 9
+    PYTHON27 = 10
+
+    def __init__(self, value=None):
+        """
+        Initialize with a value.
+        
+        :param value: Runtime value
+        """
+        self.value = value
+    
+    # Map of names to values
+    _name_map = {
+        'clr': 0,
+        'go': 1,
+        'jvm': 2,
+        'netcore': 3,
+        'perl': 4,
+        'python': 5,
+        'ruby': 6,
+        'nodejs': 7,
+        'cpp': 8,
+        'php': 9,
+        'python27': 10
+    }
+    
+    # Map of values to names
+    _value_map = {
+        0: 'clr',
+        1: 'go',
+        2: 'jvm',
+        3: 'netcore',
+        4: 'perl',
+        5: 'python',
+        6: 'ruby',
+        7: 'nodejs',
+        8: 'cpp',
+        9: 'php',
+        10: 'python27'
+    }
+    
+    @classmethod
+    def from_name(cls, name):
+        """
+        Get runtime by name.
+        
+        :param name: Runtime name
+        :return: Runtime value
+        """
+        return cls._name_map.get(name.lower())
+    
+    @classmethod
+    def to_name(cls, value):
+        """
+        Get name by runtime value.
+        
+        :param value: Runtime value
+        :return: Runtime name
+        """
+        return cls._value_map.get(value)
+
+    def __eq__(self, other):
+        if isinstance(other, RuntimeName):
+            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 "RuntimeName." + str(self)
+
+RuntimeName.clr = RuntimeName(0)
+RuntimeName.go = RuntimeName(1)
+RuntimeName.jvm = RuntimeName(2)
+RuntimeName.netcore = RuntimeName(3)
+RuntimeName.perl = RuntimeName(4)
+RuntimeName.python = RuntimeName(5)
+RuntimeName.ruby = RuntimeName(6)
+RuntimeName.nodejs = RuntimeName(7)
+RuntimeName.cpp = RuntimeName(8)
+RuntimeName.php = RuntimeName(9)
+RuntimeName.python27 = RuntimeName(10)