javonet-nodejs-sdk 2.5.13 → 2.5.15

package/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) 

package/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() 

package/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 

package/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)

package/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.") 

package/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) 

package/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) 

package/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

package/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
+""" 

package/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 

package/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