javonet-ruby-sdk 2.5.13 → 2.5.15

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

@@ -0,0 +1,32 @@
+"""
+Javonet Python SDK
+===================
+
+Javonet Python SDK is a library that allows Python developers to integrate and use modules or packages written in various languages like Java, Kotlin, Groovy, Clojure, C#, VB.NET, Ruby, Perl, JavaScript, TypeScript as if they were created in Python.
+
+How to use the documentation
+----------------------------
+Documentation is available in two forms: docstrings provided
+with the code, and a loose standing reference guide, available from
+`the Javonet homepage <https://www.javonet.com>`_.
+
+Getting Started
+---------------
+To use Javonet Python SDK, you need to have the runtime of the technology you want to call installed on your system. You can download the Javonet Python SDK from the PyPI public repository or from My Javonet Portal. 
+
+To install the package, use the following command:
+
+```bash
+pip install javonet-python2-sdk
+```
+You also need a license key to activate Javonet. You can get this key from the register or log in page on the Javonet website.
+
+First Sample Application
+Here's a simple example of how to use Javonet Python SDK:
+
+In this example, we're using Javonet to access a static field from a .NET Core library. You can use the same approach to access modules or packages from other technologies.
+
+Javonet Python SDK also supports remote operation, allowing you to interact with runtime objects on any remote node, container, or service. This makes it easy to switch between monolithic and microservices architectures without having to implement a separate integration layer.
+
+For more information on how to use Javonet Python SDK, including more detailed use cases and software architecture scenarios, please refer to the official Javonet documentation. 
+"""

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

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

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

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

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

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

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

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

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

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