javonet-ruby-sdk 2.5.14 → 2.5.15

data/lib/javonet-ruby-sdk/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()!')

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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))

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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.")

data/lib/javonet-ruby-sdk/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))

data/lib/javonet-ruby-sdk/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]) 

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/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)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/GetEnumValueHandler.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+The GetEnumValueHandler class handles retrieving enumeration element values.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class GetEnumValueHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving enumeration element values.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new enumeration value retrieval handler.
+        """
+        self._required_parameters_count = 1
+
+    def process(self, command):
+        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 'value' attribute
+            if hasattr(enum_object, 'value'):
+                return enum_object.value
+            else:
+                raise Exception("Argument is not enumerable or does not have a 'value' 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 GetEnumValueHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/GetInstanceFieldHandler.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+The GetInstanceFieldHandler class handles retrieving instance fields.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class GetInstanceFieldHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving instance fields.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance field retrieval handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("GetInstanceFieldHandler parameters mismatch!")
+            clazz = command.payload[0]
+            field = command.payload[1]
+            try:
+                return getattr(clazz, field)
+            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.__class__.__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 GetInstanceFieldHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/GetInstanceMethodAsDelegateHandler.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+The GetInstanceMethodAsDelegateHandler class handles retrieving instance methods as delegates.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class GetInstanceMethodAsDelegateHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving instance methods as delegates.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new instance method as delegate retrieval 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)
+
+            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 GetInstanceMethodAsDelegateHandler: {0}\n{1}".format(str(e), tb_str)) 

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/handler/GetStaticFieldHandler.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""
+The GetStaticFieldHandler class handles retrieving static fields.
+"""
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+import sys
+import traceback
+
+
+class GetStaticFieldHandler(AbstractCommandHandler):
+    """
+    Handler for retrieving static fields.
+    """
+
+    def __init__(self):
+        """
+        Initializes a new static field retrieval handler.
+        """
+        self._required_parameters_count = 2
+
+    def process(self, command):
+        try:
+            if len(command.payload) != self._required_parameters_count:
+                raise Exception("GetStaticFieldHandler parameters mismatch!")
+            clazz = command.payload[0]
+            field = command.payload[1]
+            try:
+                value = getattr(clazz, field)
+            except:
+                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 value
+        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 GetStaticFieldHandler: {0}\n{1}".format(str(e), tb_str))