javonet-nodejs-sdk 2.5.14 → 2.5.15

package/Binaries/Python2/javonet/core/callback/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+The callback package contains callback function implementation.
+"""

package/Binaries/Python2/javonet/core/callback/callbackFunc.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+The callbackFunc module implements the callback function.
+"""
+
+
+def callbackFunc(message_byte_array, message_byte_array_len):
+    """
+    Callback function handling messages.
+
+    :param message_byte_array: Message byte array
+    :param message_byte_array_len: Length of the byte array
+    :return: Response as byte array
+    """
+    from javonet.core.receiver.Receiver import Receiver
+    python_receiver = Receiver()
+    if message_byte_array[10] == 11:
+        return python_receiver.handle_heartbeat(message_byte_array, message_byte_array_len)
+    else:
+        return python_receiver.send_command(message_byte_array, message_byte_array_len) 

package/Binaries/Python2/javonet/core/delegateCache/DelegatesCache.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+The DelegatesCache module implements caching for delegates.
+"""
+
+import uuid
+import threading
+from javonet.utils.CommandType import CommandType
+
+
+class DelegatesCache(object):
+    """
+    Class implementing caching for delegates.
+    """
+    _instance = None
+    delegates_cache = dict()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        """
+        Creates a new singleton instance of DelegatesCache.
+
+        :return: DelegatesCache instance
+        :rtype: DelegatesCache
+        """
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(DelegatesCache, cls).__new__(cls)
+        return cls._instance
+
+    def cache_delegate(self, object_delegate):
+        """
+        Caches a delegate object.
+
+        :param object_delegate: Delegate to cache
+        :return: UUID of the cached delegate
+        :rtype: str
+        """
+        with self._lock:
+            uuid_ = str(uuid.uuid4())
+            self.delegates_cache[uuid_] = object_delegate
+            return uuid_
+
+    def resolve_delegate(self, command):
+        """
+        Resolves a delegate from the cache.
+
+        :param command: Command containing delegate reference
+        :return: Cached delegate
+        :raises: Exception if delegate not found
+        """
+        if command.command_type != CommandType.Reference:
+            raise Exception("Failed to find delegate")
+        with self._lock:
+            try:
+                return self.delegates_cache[command.payload[0]]
+            except KeyError:
+                raise Exception("Object not found in delegates")
+
+    def delete_delegate(self, delegate_guid):
+        """
+        Deletes a delegate from the cache.
+
+        :param delegate_guid: UUID of the delegate to delete
+        :return: 0 if successful
+        :raises: Exception if delegate not found
+        """
+        with self._lock:
+            try:
+                del self.delegates_cache[delegate_guid]
+                return 0
+            except KeyError:
+                raise Exception("Object not found in delegates") 

package/Binaries/Python2/javonet/core/delegateCache/__init__.py

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

package/Binaries/Python2/javonet/core/handler/AbstractCommandHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The AbstractCommandHandler class is the base class for command handlers.
+"""
+
+from javonet.core.handler.AbstractHandler import AbstractHandler
+from javonet.core.handler.HandlerDictionary import handler_dict
+from javonet.utils.Command import Command
+
+
+class AbstractCommandHandler(AbstractHandler):
+    """
+    Base class for command handlers.
+    """
+    def process(self, command):
+        """
+        Process the command. This method should be overridden by subclasses.
+        
+        :param command: Command to process
+        :return: Result of processing
+        """
+        pass
+
+    def handle_command(self, command):
+        """
+        Handle the command by iterating through payload and processing it.
+        
+        :param command: Command to handle
+        :return: Result of processing
+        """
+        self.__iterate(command)
+        return self.process(command)
+
+    @staticmethod
+    def __iterate(command):
+        """
+        Iterate through command payload and process nested commands.
+        
+        :param command: Command with payload to iterate
+        """
+        for i in range(0, len(command.payload)):
+            if isinstance(command.payload[i], Command):
+                handler = handler_dict.get(command.payload[i].command_type)
+                if handler is not None:
+                    command.payload[i] = handler.handle_command(command.payload[i]) 

package/Binaries/Python2/javonet/core/handler/AbstractHandler.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""
+The AbstractHandler class is the base class for all handlers in Javonet.
+"""
+
+
+class AbstractHandler(object):
+    def handle_command(self, command):
+        raise NotImplementedError('subclasses must override HandleCommand()!')

package/Binaries/Python2/javonet/core/handler/ArrayGetItemHandler.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""
+The ArrayGetItemHandler class handles retrieving array elements.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class ArrayGetItemHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving array elements.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new array element retrieval handler.
+        """
+        self._required_parameters_count = 2
+
+
+    def process(self, command):
+        """
+        Process the command.
+        
+        :param command: Command to process
+        :return: Result of the command
+        """
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("ArrayGetItemHandler parameters mismatch!")
+
+            array = command.payload[0]
+            if isinstance(command.payload[1], list):
+                indexes = command.payload[1]
+            else:
+                indexes = command.payload[1:]
+
+            array_copy = array[:]  # W Pythonie 2 używamy slicingu zamiast copy()
+            for i in indexes:
+                array_copy = array_copy[i]
+            return array_copy
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in ArrayGetItemHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/ArrayGetRankHandler.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""
+The ArrayGetRankHandler class handles retrieving array rank.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class ArrayGetRankHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving array rank.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new array rank retrieval handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ArrayGetRankHandler parameters mismatch!")
+
+            array = command.payload[0]
+            rank = 0
+            while(isinstance(array, list)):
+                rank = rank + 1
+                array = array[0]
+
+            return rank
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in ArrayGetRankHandler: {0}\n{1}".format(str(e), tb_str))

package/Binaries/Python2/javonet/core/handler/ArrayGetSizeHandler.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The ArrayGetSizeHandler class handles retrieving array size.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class ArrayGetSizeHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving array size.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new array size retrieval handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Handles the array size retrieval command.
+
+        :param command: Command to handle
+        :return: Command execution result
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ArrayGetSizeHandler parameters mismatch!")
+
+            array = command.payload[0]
+            size = 1
+            while(isinstance(array, list)):
+                size = size * len(array)
+                array = array[0]
+
+            return size
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in ArrayGetSizeHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/ArrayHandler.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""
+The ArrayHandler class is the base class for array operation handlers.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class ArrayHandler(AbstractCommandHandler):
+    """
+    Base class for array operation handlers.
+    """
+
+    def process(self, command):
+        try:
+            processedArray = command.payload
+            return processedArray
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in ArrayHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/ArraySetItemHandler.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+"""
+The ArraySetItemHandler class handles setting array elements.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class ArraySetItemHandler(AbstractCommandHandler):
+    """
+    Handler for setting array elements.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new array element setting handler.
+        """
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        """
+        Handles the array element setting command.
+
+        :param command: Command to handle
+        :return: Command execution result
+        """
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("ArraySetItemHandler parameters mismatch!")
+
+            array = command.payload[0]
+
+            value = command.payload[2]
+            if isinstance(command.payload[1], list):
+                indexes = command.payload[1]
+            else:
+                indexes = [command.payload[1]]
+
+            if isinstance(command.payload[0], dict):
+                array[indexes[0]] = value
+
+            # one-dimensional array
+            if len(indexes) == 1:
+                array[indexes[0]] = value
+            # multi-dimensional array
+            else:
+                for i in range((len(indexes)-1)):
+                    array = array[indexes[i]]
+
+                array[indexes[-1]] = value
+
+            return 0
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in ArraySetItemHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/CastingHandler.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""
+The CastingHandler class is the base class for type casting operation handlers.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class CastingHandler(AbstractCommandHandler):
+    def process(self, command):
+        raise Exception("Explicit cast is forbidden in dynamically typed languages - python.")

package/Binaries/Python2/javonet/core/handler/CreateClassInstanceHandler.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+import inspect
+import sys
+import traceback
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class CreateClassInstanceHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the CreateClassInstance command.
+        
+        :param command: Command to process
+        :type command: Command
+        :return: Created class instance
+        :raises: Exception if parameters mismatch or class instantiation fails
+        """
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("CreateClassInstanceHandler parameters mismatch!")
+            
+            clazz = command.payload[0]
+            
+            if len(command.payload) > 1:
+                method_arguments = command.payload[1:]
+                return clazz(*method_arguments)
+            
+            return clazz()
+            
+        except Exception as e:
+            # W Python 2.7 nie ma with_traceback i from None
+            # Zamiast tego po prostu rzucamy wyjątek
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error creating class instance: {0}\n{1}".format(str(e), tb_str))

package/Binaries/Python2/javonet/core/handler/DestructReferenceHandler.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""
+The DestructReferenceHandler class handles object reference destruction.
+"""
+
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+
+
+class DestructReferenceHandler(AbstractCommandHandler):
+    """
+    Handler for object reference destruction.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new reference destruction handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        reference_cache = ReferencesCache()
+        return reference_cache.delete_reference(command.payload[0]) 

package/Binaries/Python2/javonet/core/handler/EnableNamespaceHandler.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+The EnableNamespaceHandler class handles namespace enabling.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
+import sys
+import traceback
+
+
+class EnableNamespaceHandler(AbstractCommandHandler):
+    """
+    Handler for enabling namespaces.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new namespace enabling handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(self.__class__.__name__ + " parameters mismatch!")
+
+            namespace_cache = NamespaceCache()
+
+            for payload in command.payload:
+                if isinstance(payload, str):
+                    namespace_cache.cache_namespace(payload)
+                if isinstance(payload, list):
+                    for namespace_to_enable in payload:
+                        namespace_cache.cache_namespace(namespace_to_enable)
+
+            return 0
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in EnableNamespaceHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/EnableTypeHandler.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+The EnableTypeHandler class handles type enabling.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.typeCache.TypeCache import TypeCache
+import sys
+import traceback
+
+
+class EnableTypeHandler(AbstractCommandHandler):
+    """
+    Handler for enabling types.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new type enabling handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(self.__class__.__name__ + " parameters mismatch!")
+
+            type_cache = TypeCache()
+
+            for payload in command.payload:
+                if isinstance(payload, str):
+                    type_cache.cache_type(payload)
+                if isinstance(payload, list):
+                    for type_to_enable in payload:
+                        type_cache.cache_type(type_to_enable)
+
+            return 0
+
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in EnableTypeHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/GetEnumItemHandler.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+The GetEnumItemHandler class handles retrieving enumeration items.
+"""
+
+from importlib import import_module
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class GetEnumItemHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving enumeration items.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new enumeration item retrieval handler.
+        """
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        """
+        Handles the enumeration item retrieval command.
+
+        :param command: Command to handle
+        :return: Command execution result
+        """
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("CreateEnumHandler parameters mismatch!")
+            clazz = command.payload[0]
+            enum_name = command.payload[1]
+            enum_value = command.payload[2]
+            try:
+                enum_type = getattr(clazz, enum_name)
+                # In Python 2.7, we need to check if the enum_type is a dictionary-like object
+                if hasattr(enum_type, '__getitem__'):
+                    return enum_type[enum_value]
+                else:
+                    raise Exception("Enum type does not support item access")
+            except AttributeError:
+                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
+                message = "Enum {} not found in class {}. Available enums:\n".format(enum_name, clazz.__name__)
+                for field in fields:
+                    message += "{}\n".format(field)
+                raise AttributeError(message)
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in GetEnumItemHandler: {0}\n{1}".format(str(e), tb_str)) 

package/Binaries/Python2/javonet/core/handler/GetEnumNameHandler.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+"""
+The GetEnumNameHandler class handles retrieving enumeration names.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class GetEnumNameHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving enumeration names.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new enumeration name retrieval handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Handles the enumeration name retrieval command.
+
+        :param command: Command to handle
+        :return: Command execution result
+        """
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("CreateEnumHandler parameters mismatch!")
+            enum_object = command.payload[0]
+            # In Python 2.7 we check if the object has a 'name' attribute
+            if hasattr(enum_object, 'name'):
+                return enum_object.name
+            else:
+                raise Exception("Argument is not enumerable or does not have a 'name' attribute")
+        except Exception as e:
+            # Python 2.7 exception handling
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error in GetEnumNameHandler: {0}\n{1}".format(str(e), tb_str))