javonet-ruby-sdk 2.5.14 → 2.5.16

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

@@ -0,0 +1,47 @@
+"""
+The RuntimeNameHandler class handles Javonet runtime environment names.
+"""
+
+from javonet.utils.RuntimeName import RuntimeName
+
+
+class RuntimeNameHandler(object):
+    """
+    Class for handling runtime environment names.
+    """
+
+    @staticmethod
+    def get_name(runtime_name):
+        """
+        Returns the runtime environment name as a string.
+
+        :param runtime_name: RuntimeName object representing the runtime environment
+        :type runtime_name: RuntimeName
+        :return: Runtime environment name as a string
+        :rtype: str
+        :raises Exception: When the provided runtime name is invalid
+        """
+        if isinstance(runtime_name, RuntimeName):
+            if runtime_name == RuntimeName.clr:
+                return "clr"
+            elif runtime_name == RuntimeName.go:
+                return "go"
+            elif runtime_name == RuntimeName.jvm:
+                return "jvm"
+            elif runtime_name == RuntimeName.netcore:
+                return "netcore"
+            elif runtime_name == RuntimeName.perl:
+                return "perl"
+            elif runtime_name == RuntimeName.python:
+                return "python"
+            elif runtime_name == RuntimeName.ruby:
+                return "ruby"
+            elif runtime_name == RuntimeName.nodejs:
+                return "nodejs"
+            elif runtime_name == RuntimeName.cpp:
+                return "cpp"
+            elif runtime_name == RuntimeName.php:
+                return "php"
+            elif runtime_name == RuntimeName.python27:
+                return "python27"
+        raise Exception("Invalid runtime name.") 

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

@@ -0,0 +1,38 @@
+"""
+The StringEncodingMode class represents character encoding modes used in Javonet.
+"""
+
+class StringEncodingMode(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, StringEncodingMode):
+            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 "StringEncodingMode." + str(self)
+
+    ASCII = None
+    UTF8 = None
+    UTF16 = None
+    UTF32 = None
+
+    _name_map = {
+        0: 'ASCII',
+        1: 'UTF8',
+        2: 'UTF16',
+        3: 'UTF32'
+    }
+
+StringEncodingMode.ASCII = StringEncodingMode(0)
+StringEncodingMode.UTF8 = StringEncodingMode(1)
+StringEncodingMode.UTF16 = StringEncodingMode(2)
+StringEncodingMode.UTF32 = StringEncodingMode(3) 

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

@@ -0,0 +1,68 @@
+"""
+The Type class represents data types used in Javonet.
+"""
+
+
+class Type(object):
+    """
+    Class representing data types used in Javonet.
+    """
+
+
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, Type):
+            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 "Type." + str(self)
+
+    Command = None
+    JavonetString = None
+    JavonetInteger = None
+    JavonetBoolean = None
+    JavonetFloat = None
+    JavonetByte = None
+    JavonetChar = None
+    JavonetLongLong = None
+    JavonetDouble = None
+    JavonetUnsignedLongLong = None
+    JavonetUnsignedInteger = None
+    JavonetNoneType = None
+
+    _name_map = {
+        0: 'Command',
+        1: 'JavonetString',
+        2: 'JavonetInteger',
+        3: 'JavonetBoolean',
+        4: 'JavonetFloat',
+        5: 'JavonetByte',
+        6: 'JavonetChar',
+        7: 'JavonetLongLong',
+        8: 'JavonetDouble',
+        9: 'JavonetUnsignedLongLong',
+        10: 'JavonetUnsignedInteger',
+        11: 'JavonetNoneType'
+    }
+
+Type.Command = Type(0)
+Type.JavonetString = Type(1)
+Type.JavonetInteger = Type(2)
+Type.JavonetBoolean = Type(3)
+Type.JavonetFloat = Type(4)
+Type.JavonetByte = Type(5)
+Type.JavonetChar = Type(6)
+Type.JavonetLongLong = Type(7)
+Type.JavonetDouble = Type(8)
+Type.JavonetUnsignedLongLong = Type(9)
+Type.JavonetUnsignedInteger = Type(10)
+Type.JavonetNoneType = Type(11) 

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

@@ -0,0 +1,38 @@
+import os
+
+class UtilsConst:
+    _javonet_working_directory = os.path.abspath(os.getcwd()) + "/"
+    _config_source = ""
+    _license_key = "License key not set"
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        path = path.replace("\\", "/")
+        if not path.endswith("/"):
+            path = path + "/"
+        if not os.path.exists(path):
+            os.makedirs(path)
+            os.chmod(path, 0o700)
+        UtilsConst._javonet_working_directory = path
+
+    @staticmethod
+    def get_javonet_working_directory():
+        return UtilsConst._javonet_working_directory
+
+    @staticmethod
+    def set_config_source(value):
+        UtilsConst._config_source = value
+
+    @staticmethod
+    def get_config_source():
+        return UtilsConst._config_source
+
+    @staticmethod
+    def set_license_key(value):
+        if not value or value == "" or value == "your-license-key":
+            return
+        UtilsConst._license_key = value
+
+    @staticmethod
+    def get_license_key():
+        return UtilsConst._license_key

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

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The utils module contains helper tools and types used in the Javonet SDK
+""" 

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

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The IConnectionData interface defines a contract for classes handling connection data.
+"""
+
+from abc import ABCMeta, abstractmethod
+
+from javonet.utils.ConnectionType import ConnectionType
+
+
+class IConnectionData(object):
+    """
+    Interface for classes handling connection data.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def connection_type(self):
+        """
+        Returns the connection type.
+
+        :return: Connection type
+        :rtype: ConnectionType
+        """
+        pass
+
+    @abstractmethod
+    def hostname(self):
+        """
+        Returns the host name.
+
+        :return: Host name
+        :rtype: str
+        """
+        pass
+
+    @abstractmethod
+    def serialize_connection_data(self):
+        """
+        Serializes the connection data.
+
+        :return: Serialized connection data
+        :rtype: str
+        """
+        pass 

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

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class InMemoryConnectionData(IConnectionData):
+
+
+    @property
+    def connection_type(self):
+
+        return ConnectionType.InMemory
+
+    @property
+    def hostname(self):
+
+        return ""
+
+    def serialize_connection_data(self):
+
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+
+        return isinstance(other, InMemoryConnectionData)
+
+    def __hash__(self):
+
+        hash_code = 593727026
+        hash_code = hash_code * -1521134295 + hash(self.connection_type)
+        return hash_code 

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

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""
+The TcpConnectionData class represents TCP connection data.
+"""
+
+import hashlib
+import socket
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class TcpConnectionData(IConnectionData):
+    """
+    Class representing TCP connection data.
+    """
+
+    def __init__(self, hostname, port):
+        """
+        Initializes a new TCP connection.
+
+        :param hostname: Host name
+        :param port: Port number
+        """
+        self._hostname = hostname
+        self._port = port
+        self._ip_address = ""
+        if self._hostname == "localhost":
+            self._ip_address = "127.0.0.1"
+        else:
+            try:
+                self._ip_address = socket.gethostbyname(self._hostname)
+            except socket.gaierror:
+                self._ip_address = ""
+
+    @property
+    def connection_type(self):
+        """
+        Returns the connection type.
+
+        :return: Connection type (ConnectionType.Tcp)
+        """
+        return ConnectionType.Tcp
+
+    @property
+    def hostname(self):
+        """
+        Returns the host name.
+
+        :return: Host name
+        """
+        return self._hostname
+
+    @hostname.setter
+    def hostname(self, value):
+        """
+        Sets the host name.
+
+        :param value: New host name
+        """
+        self._hostname = value
+
+    @property
+    def ip_address(self):
+        """
+        Returns the IP address.
+
+        :return: IP address
+        """
+        return self._ip_address
+
+    @ip_address.setter
+    def ip_address(self, value):
+        """
+        Sets the IP address.
+
+        :param value: New IP address
+        """
+        self._ip_address = value
+
+    @property
+    def port(self):
+        """
+        Returns the port number.
+
+        :return: Port number
+        """
+        return self._port
+
+    @port.setter
+    def port(self, value):
+        """
+        Sets the port number.
+
+        :param value: New port number
+        """
+        self._port = value
+
+    def serialize_connection_data(self):
+        """
+        Serializes connection data to a list of values.
+
+        :return: List containing connection configuration values
+        """
+        address_bytes = self.__get_address_bytes()
+        port_bytes = self.__get_port_bytes()
+        return [self.connection_type.value] + address_bytes + port_bytes
+
+    def __get_address_bytes(self):
+        """
+        Converts IP address to a list of bytes.
+
+        :return: List of bytes representing the IP address
+        """
+        return [int(x) for x in self._ip_address.split(".")]
+
+    def __get_port_bytes(self):
+        """
+        Converts port number to a list of bytes.
+
+        :return: List of bytes representing the port number
+        """
+        return [self._port & 0xFF, self._port >> 8]
+
+    def __eq__(self, other):
+        """
+        Compares two TcpConnectionData objects.
+
+        :param other: Object to compare
+        :return: True if objects are equal, False otherwise
+        """
+        if isinstance(other, TcpConnectionData):
+            return self._ip_address == other.ip_address and self._port == other.port
+        return False
+
+    def __hash__(self):
+        """
+        Calculates hash value for the object.
+
+        :return: Hash value
+        """
+        return int(hashlib.sha1("{0}{1}".format(self._ip_address, self._port).encode()).hexdigest(), 16) 

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

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""
+The WsConnectionData class represents WebSocket connection data.
+"""
+
+import hashlib
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class WsConnectionData(IConnectionData):
+    """
+    Class representing WebSocket connection data.
+    """
+
+    def __init__(self, hostname):
+        """
+        Initializes a new WebSocket connection.
+
+        :param hostname: Host name
+        """
+        self._hostname = hostname
+
+    @property
+    def connection_type(self):
+        """
+        Returns the connection type.
+
+        :return: Connection type (ConnectionType.WebSocket)
+        """
+        return ConnectionType.WebSocket
+
+    @property
+    def hostname(self):
+        """
+        Returns the host name.
+
+        :return: Host name
+        """
+        return self._hostname
+
+    @hostname.setter
+    def hostname(self, value):
+        """
+        Sets the host name.
+
+        :param value: New host name
+        """
+        self._hostname = value
+
+    def serialize_connection_data(self):
+        """
+        Serializes connection data to a list of values.
+
+        :return: List containing connection configuration values
+        """
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        """
+        Compares two WsConnectionData objects.
+
+        :param other: Object to compare
+        :return: True if objects are equal, False otherwise
+        """
+        return isinstance(other, WsConnectionData) and self._hostname == other.hostname
+
+    def __hash__(self):
+        """
+        Calculates hash value for the object.
+
+        :return: Hash value
+        """
+        return int(hashlib.sha1(str(self.hostname).encode('utf-8')).hexdigest(), 16) 

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

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The connectionData package contains classes for handling different types of connections in Javonet.
+"""

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

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+"""
+The ExceptionSerializer class is used for serializing exceptions in Javonet.
+"""
+
+import os
+import sys
+import traceback
+
+from javonet.utils.PythonStringBuilder import PythonStringBuilder
+from javonet.utils.ExceptionType import ExceptionType
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+
+
+class ExceptionSerializer(object):
+    """
+    Class for serializing exceptions in Javonet.
+    """
+
+    Exception = 0
+    IOException = 1
+    FileNotFoundException = 2
+    RuntimeException = 3
+    ArithmeticException = 4
+    IllegalArgumentException = 5
+    IndexOutOfBoundsException = 6
+    NullPointerException = 7
+
+    @staticmethod
+    def serialize_exception(exception, command):
+        """
+        Serializes an exception to Javonet command format.
+
+        :param exception: Exception to serialize
+        :param command: Command that caused the exception
+        :return: Command containing the serialized exception
+        """
+        exception_command = Command(command.runtime_name, CommandType.Exception, [])
+        
+        # In Python 2 there's no __traceback__, we use sys.exc_info()
+        _, _, tb = sys.exc_info()
+        trace = traceback.extract_tb(tb)
+        exception_message = str(exception)
+        
+        # In Python 2 there's no __cause__, we use the exception type directly
+        exception_name = exception.__class__.__name__
+        
+        stack_classes = PythonStringBuilder()
+        stack_methods = PythonStringBuilder()
+        stack_lines = PythonStringBuilder()
+        stack_files = PythonStringBuilder()
+
+        is_debug = False
+
+        for frame in trace:
+            # In Python 2 extract_tb returns tuples (filename, line number, function name, text)
+            filename, lineno, name, _ = frame
+            if "javonet" not in filename or is_debug:
+                stack_classes.append(ExceptionSerializer.format_class_name_from_file(filename)).append("|")
+                stack_methods.append(name).append("|")
+                stack_lines.append(str(lineno)).append("|")
+                stack_files.append(filename).append("|")
+
+        exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
+        exception_command = exception_command.add_arg_to_payload(str(command))
+        exception_command = exception_command.add_arg_to_payload(exception_name)
+        exception_command = exception_command.add_arg_to_payload(str(exception_message))
+        exception_command = exception_command.add_arg_to_payload(stack_classes.__str__())
+        exception_command = exception_command.add_arg_to_payload(stack_methods.__str__())
+        exception_command = exception_command.add_arg_to_payload(stack_lines.__str__())
+        exception_command = exception_command.add_arg_to_payload(stack_files.__str__())
+
+        return exception_command
+
+    @staticmethod
+    def get_exception_code(exception_name):
+        """
+        Returns the exception code based on its name.
+
+        :param exception_name: Exception name
+        :return: Exception code
+        """
+        return ExceptionType.to_enum(exception_name)
+
+    @staticmethod
+    def format_class_name_from_file(filename):
+        """
+        Formats the class name based on the file name.
+
+        :param filename: File name
+        :return: Class name
+        """
+        return os.path.splitext((os.path.split(filename)[1]))[0] 

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

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""
+The ExceptionThrower class is used for throwing exceptions in Javonet.
+"""
+
+from javonet.utils.exception.JavonetException import JavonetException
+from javonet.utils.ExceptionType import ExceptionType
+
+
+class ExceptionThrower(object):
+    """
+    Class for throwing exceptions in Javonet.
+    """
+
+    @staticmethod
+    def throw_exception(command_exception):
+        """
+        Throws an exception based on the exception command.
+
+        :param command_exception: Exception command
+        :return: Javonet exception
+        """
+        exception_code = command_exception.payload[0]
+        command = command_exception.payload[1]
+        exception_name = command_exception.payload[2]
+        exception_message = command_exception.payload[3]
+        stack_trace_classes = command_exception.payload[4]
+        stack_trace_methods = command_exception.payload[5]
+        stack_trace_lines = command_exception.payload[6]
+        stack_trace_files = command_exception.payload[7]
+
+        stack_trace_elements = ExceptionThrower.process_stack_trace(
+            stack_trace_classes,
+            stack_trace_methods,
+            stack_trace_lines,
+            stack_trace_files
+        )
+
+        traceback_str = ""
+        for element in stack_trace_elements:
+            traceback_str += "  File \"{0}\", line {1}, in {2}\n".format(
+                element[3], element[2], element[1])
+
+        original_exception = ExceptionType.to_exception(exception_code)
+
+        return ExceptionThrower.create_javonet_exception(
+            original_exception,
+            exception_message,
+            traceback_str
+        )
+
+    @staticmethod
+    def create_javonet_exception(original_exception, exception_message, traceback_str):
+        """
+        Creates and returns a Javonet exception.
+
+        :param original_exception: Original exception
+        :param exception_message: Exception message
+        :param traceback_str: Stack trace
+        :return: Javonet exception
+        """
+        return JavonetException(original_exception.__name__, exception_message, traceback_str)
+
+    @staticmethod
+    def process_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
+        """
+        Processes stack trace into lists of elements.
+
+        :param stack_trace_classes: Classes in stack trace
+        :param stack_trace_methods: Methods in stack trace
+        :param stack_trace_lines: Line numbers in stack trace
+        :param stack_trace_files: Files in stack trace
+        :return: List of stack trace element lists
+        """
+        stack_trace_elements = []
+        if stack_trace_classes:
+            classes = stack_trace_classes.split("|")
+            methods = stack_trace_methods.split("|")
+            lines = stack_trace_lines.split("|")
+            files = stack_trace_files.split("|")
+
+            for i in range(len(classes) - 1):
+                stack_trace_elements.append([classes[i], methods[i], lines[i], files[i]])
+
+        return stack_trace_elements