javonet-nodejs-sdk 2.5.13 → 2.5.15

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

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""
+The HandlerDictionary class stores a dictionary of command handlers.
+"""
+
+# Global dictionary for handlers
+handler_dict = {}
+
+
+class HandlerDictionary(object):
+    """
+    Class for managing command handlers dictionary.
+    """
+
+    @staticmethod
+    def add_handler_to_dict(command_type, handler):
+        """
+        Add a handler to the dictionary.
+        
+        :param command_type: Type of command
+        :param handler: Handler for the command
+        """
+        handler_dict[command_type] = handler 

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

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeDelegateHandler class handles delegate invocations.
+"""
+
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class InvokeDelegateHandler(AbstractCommandHandler):
+    """
+    Handler for invoking delegates.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new delegate invocation handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            delegates_cache = DelegatesCache()
+            method = delegates_cache.resolve_delegate(command)
+            if len(command.payload) > 1:
+                method_arguments = command.payload[1:]
+                return method(*method_arguments)
+            else:
+                return method()
+        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 InvokeDelegateHandler: {0}\n{1}".format(str(e), tb_str))
+
+    def handle(self, command):
+        """
+        Handles the delegate invocation command.
+
+        :param command: Command to handle
+        :return: Command with operation result
+        """
+        delegate_id = command.get_payload()[0]
+        args = command.get_payload()[1:]
+        result = Command(command.runtime_name, CommandType.Value, [])
+        result = result.add_arg_to_payload(delegate_id)
+        for arg in args:
+            result = result.add_arg_to_payload(arg)
+        return result 

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

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeGlobalFunctionHandler class handles global function invocations.
+"""
+
+import importlib
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class InvokeGlobalFunctionHandler(AbstractCommandHandler):
+    """
+    Handler for invoking global functions.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new global function invocation handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeGlobalFunction Parameters mismatch! "
+                                "Expected at least a fully qualified function name (module.function).")
+
+            # The first payload parameter must be the fully qualified function name,
+            # e.g. "my_module.my_function".
+            full_function_name = command.payload[0]
+            if '.' not in full_function_name:
+                raise Exception("Invalid function name format. "
+                                "Expected a fully qualified name like 'module_name.function_name'.")
+
+            module_name, function_name = full_function_name.rsplit('.', 1)
+
+            try:
+                module = importlib.import_module(module_name)
+            except ImportError as e:
+                raise ImportError("Could not import module '{}'.".format(module_name))
+
+            try:
+                function = getattr(module, function_name)
+            except AttributeError as e:
+                available = [attr for attr in dir(module) if callable(getattr(module, attr))]
+                message = ("Function '{}' not found in module '{}'. "
+                           "Available functions:\n".format(function_name, module_name) + "\n".join(available))
+                raise AttributeError(message)
+
+            if not callable(function):
+                raise Exception("Attribute '{}' in module '{}' is not callable.".format(function_name, module_name))
+
+            function_args = command.payload[1:]
+            return function(*function_args)
+
+        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 InvokeGlobalFunctionHandler: {0}\n{1}".format(str(e), tb_str))
+
+    def handle(self, command):
+        """
+        Handles the global function invocation command.
+
+        :param command: Command to handle
+        :return: Command with operation result
+        """
+        function_name = command.get_payload()[0]
+        args = command.get_payload()[1:]
+        result = Command(command.runtime_name, CommandType.Value, [])
+        result = result.add_arg_to_payload(function_name)
+        for arg in args:
+            result = result.add_arg_to_payload(arg)
+        return result 

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

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeInstanceMethodHandler class handles instance method invocations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class InvokeInstanceMethodHandler(AbstractCommandHandler):
+    """
+    Handler for invoking instance methods.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance method invocation handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeInstanceMethod Parameters mismatch!")
+
+            class_instance = command.payload[0]
+            try:
+                method = getattr(class_instance, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(class_instance) if callable(getattr(class_instance, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], class_instance.__class__.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+            
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
+                return method(*method_arguments)
+            return method()
+        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 InvokeInstanceMethodHandler: {0}\n{1}".format(str(e), tb_str)) 

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

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+"""
+The InvokeStaticMethodHandler class handles static method invocations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class InvokeStaticMethodHandler(AbstractCommandHandler):
+    """
+    Handler for invoking static methods.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new static method invocation handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("InvokeStaticMethod Parameters mismatch!")
+
+            clazz = command.payload[0]
+            try:
+                method = getattr(clazz, command.payload[1])
+            except AttributeError:
+                methods = [method for method in dir(clazz) if callable(getattr(clazz, method))]
+                message = "Method {} not found in class {}. Available methods:\n".format(command.payload[1], clazz.__name__)
+                for method in methods:
+                    message += "{}\n".format(method)
+                raise AttributeError(message)
+            
+            if len(command.payload) > 2:
+                method_arguments = command.payload[2:]
+                return method(*method_arguments)
+            return method()
+        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 InvokeStaticMethodHandler: {0}\n{1}".format(str(e), tb_str)) 

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

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+"""
+The LoadLibraryHandler class handles library loading.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import os
+import traceback
+
+
+class LoadLibraryHandler(AbstractCommandHandler):
+    """
+    Handler for loading libraries.
+    """
+
+    # Class variable to store loaded directories
+    loaded_directories = []
+
+    def __init__(self):
+        """
+        Initializes a new library loading handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the LoadLibrary command.
+        
+        :param command: Command to process
+        :return: 0 on success
+        :raises: Exception if parameters mismatch or directory is invalid
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("LoadLibrary payload parameters mismatch")
+
+            # Check if path is a directory and add to sys.path
+            if os.path.isdir(command.payload[0]):
+                sys.path.append(command.payload[0])
+                LoadLibraryHandler.loaded_directories.append(command.payload[0])
+            else:
+                raise Exception(command.payload[0] + " is not a valid directory")
+
+            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 loading library: {0}\n{1}".format(str(e), tb_str))
+
+    @staticmethod
+    def get_loaded_directories():
+        """
+        Get list of loaded directories.
+        
+        :return: List of loaded directory paths
+        """
+        return LoadLibraryHandler.loaded_directories

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

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+The PassDelegateHandler class handles delegate passing.
+"""
+
+from javonet.core.delegateCache.DelegatesCache import DelegatesCache
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+import sys
+import traceback
+
+
+class PassDelegateHandler(AbstractCommandHandler):
+    """
+    Handler for passing delegates.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new delegate passing handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            # TO BE IMPLEMENTED
+            return None
+        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 PassDelegateHandler: {0}\n{1}".format(str(e), tb_str)) 

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

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+import sys
+import traceback
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+
+
+class ResolveInstanceHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        """
+        Process the ResolveInstance command.
+        
+        :param command: Command to process
+        :type command: Command
+        :return: Resolved instance
+        :raises: Exception if parameters mismatch or reference resolution fails
+        """
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("ResolveInstanceHandler parameters mismatch!")
+
+            references_cache = ReferencesCache()
+            return references_cache.resolve_reference(command)
+            
+        except Exception as e:
+            # W Python 2.7 nie ma with_traceback i from None
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            tb_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+            raise Exception("Error resolving instance: {0}\n{1}".format(str(e), tb_str))

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

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+The SetInstanceFieldHandler class handles setting instance fields.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class SetInstanceFieldHandler(AbstractCommandHandler):
+    """
+    Handler for setting instance fields.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance field setting handler.
+        """
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception("SetInstanceFieldHandler parameters mismatch!")
+            instance = command.payload[0]
+            field = command.payload[1]
+            new_value = command.payload[2]
+            try:
+                setattr(instance, field, new_value)
+            except AttributeError:
+                fields = [field for field in dir(instance) if not callable(getattr(instance, field))]
+                message = "Field {} not found in class {}. Available fields:\n".format(field, instance.__class__.__name__)
+                for field in fields:
+                    message += "{}\n".format(field)
+                raise AttributeError(message)
+            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 SetInstanceFieldHandler: {0}\n{1}".format(str(e), tb_str)) 

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

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+The SetStaticFieldHandler class handles setting static fields.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class SetStaticFieldHandler(AbstractCommandHandler):
+    """
+    Handler for setting static fields.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new static field setting handler.
+        """
+        self._required_parameters_count = 3
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("SetStaticFieldHandler parameters mismatch!")
+
+            clazz = command.payload[0]
+            field = command.payload[1]
+            new_value = command.payload[2]
+            try:
+                setattr(clazz, field, new_value)
+            except AttributeError:
+                fields = [field for field in dir(clazz) if not callable(getattr(clazz, field))]
+                message = "Field {} not found in class {}. Available fields:\n".format(field, clazz.__name__)
+                for field in fields:
+                    message += "{}\n".format(field)
+                raise AttributeError(message)
+            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 SetStaticFieldHandler: {0}\n{1}".format(str(e), tb_str)) 

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

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+"""
+The ValueHandler class handles value operations.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+
+
+class ValueHandler(AbstractCommandHandler):
+    """
+    Handler for value operations.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new value operations handler.
+        """
+        pass
+
+    def process(self, command):
+        """
+        Handles a value operation command.
+
+        :param command: Command to handle
+        :return: Command value
+        """
+        return command.payload[0] 

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

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*- 

package/Binaries/Python2/javonet/core/interpreter/Interpreter.py

@@ -0,0 +1,36 @@
+"""
+The Interpreter module implements the Javonet command interpreter.
+"""
+
+from javonet.core.handler.Handler import Handler
+from javonet.core.protocol.CommandDeserializer import CommandDeserializer
+from javonet.core.protocol.CommandSerializer import CommandSerializer
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.RuntimeName import RuntimeName
+
+handler = Handler()
+
+
+class Interpreter(object):
+    """
+    Class responsible for interpreting and executing Javonet commands.
+    """
+
+    def execute(self, command, connection_data):
+        message_byte_array = CommandSerializer().serialize(command, connection_data)
+        if connection_data.connection_type == ConnectionType.WebSocket:
+            from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
+            response_byte_array = WebSocketClient().send_message(connection_data, message_byte_array)
+        elif (command.runtime_name == RuntimeName.python27) & (
+                connection_data.connection_type == ConnectionType.InMemory):
+            from javonet.core.receiver.Receiver import Receiver
+            response_byte_array = Receiver().SendCommand(message_byte_array, len(message_byte_array))
+        else:
+            from javonet.core.transmitter.Transmitter import Transmitter
+            response_byte_array = Transmitter.send_command(message_byte_array)
+
+        return CommandDeserializer(response_byte_array).deserialize()
+
+    def process(self, message_byte_array):
+        received_command = CommandDeserializer(message_byte_array).deserialize()
+        return handler.handle_command(received_command)

package/Binaries/Python2/javonet/core/namespaceCache/NamespaceCache.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import re
+import types
+import threading
+
+
+class NamespaceCache(object):
+    _instance = None
+    namespace_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(NamespaceCache, cls).__new__(cls)
+            finally:
+                cls._lock.release()
+        return cls._instance
+
+    def cache_namespace(self, namespace):
+        """
+        Cache a namespace.
+        
+        :param namespace: Namespace to cache
+        """
+        with self._lock:
+            # Handle Python 2.7 vs Python 3 module name differences
+            if namespace.startswith("builtins"):
+                namespace = namespace.replace("builtins", "__builtin__", 1)
+            
+            self.namespace_cache.append(namespace)
+
+    def is_namespace_cache_empty(self):
+        self._lock.acquire()
+        try:
+            return len(self.namespace_cache) == 0
+        finally:
+            self._lock.release()
+
+    def is_type_allowed(self, type_to_check):
+        self._lock.acquire()
+        try:
+            for pattern in self.namespace_cache:
+                if isinstance(type_to_check, types.ModuleType):
+                    if re.match(pattern, type_to_check.__name__):
+                        return True
+                else:
+                    if re.match(pattern, type_to_check.__module__):
+                        return True
+            return False
+        finally:
+            self._lock.release()
+
+    def get_cached_namespaces(self):
+        self._lock.acquire()
+        try:
+            return self.namespace_cache[:]
+        finally:
+            self._lock.release()
+
+    def clear_cache(self):
+        self._lock.acquire()
+        try:
+            del self.namespace_cache[:]
+            return 0
+        finally:
+            self._lock.release()

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

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