javonet-ruby-sdk 2.4.5 → 2.4.7

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/{CommandHandler/GetStaticFieldHandler.py → GetStaticFieldHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class GetStaticFieldHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/GetTypeHandler.py

@@ -0,0 +1,56 @@
+from importlib import import_module
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
+from javonet.core.typeCache.TypeCache import TypeCache
+
+
+class GetTypeHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+        self.namespace_cache = NamespaceCache()
+        self.type_cache = TypeCache()
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(self.__class__.__name__ + " parameters mismatch!")
+
+            type_to_return = self._get_type_from_payload(command)
+
+            if type_to_return is None:
+                raise Exception(f"Type {command.payload[0]} not found")
+
+            if ((
+                    self.namespace_cache.is_namespace_cache_empty() and self.type_cache.is_type_cache_empty()) or  # both caches are empty
+                    self.namespace_cache.is_type_allowed(type_to_return) or  # namespace is allowed
+                    self.type_cache.is_type_allowed(type_to_return)  # type is allowed
+            ):
+                pass  # continue - type is allowed
+            else:
+                allowed_namespaces = ", ".join(self.namespace_cache.get_cached_namespaces())
+                allowed_types = ", ".join(self.type_cache.get_cached_types())
+                raise Exception(
+                    f"Type {type_to_return.__name__} not allowed. \nAllowed namespaces: {allowed_namespaces}\nAllowed types: {allowed_types}")
+
+            return type_to_return
+
+        except Exception as e:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None
+
+    def _get_type_from_payload(self, command):
+        if len(command.payload) == 1:
+            type_name = command.payload[0].split(".")
+            if len(type_name) == 1:
+                return import_module(type_name[0])
+            else:
+                return self._get_type_from_nested_payload(type_name)
+        else:
+            return self._get_type_from_nested_payload(command.payload)
+
+    def _get_type_from_nested_payload(self, payload):
+        for i in range(len(payload) - 1):
+            loaded_module = import_module(".".join(payload[:i + 1]))
+        return getattr(loaded_module, payload[-1])

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/Handler.py

@@ -1,28 +1,30 @@
 from javonet.core.handler.AbstractHandler import AbstractHandler
-from javonet.core.handler.CommandHandler.ValueHandler import ValueHandler
-from javonet.core.handler.CommandHandler.LoadLibraryHandler import LoadLibraryHandler
-from javonet.core.handler.CommandHandler.InvokeStaticMethodHandler import InvokeStaticMethodHandler
-from javonet.core.handler.CommandHandler.SetStaticFieldHandler import SetStaticFieldHandler
-from javonet.core.handler.CommandHandler.CreateClassInstanceHandler import CreateClassInstanceHandler
-from javonet.core.handler.CommandHandler.GetStaticFieldHandler import GetStaticFieldHandler
-from javonet.core.handler.CommandHandler.ResolveInstanceHandler import ResolveInstanceHandler
-from javonet.core.handler.CommandHandler.GetTypeHandler import GetTypeHandler
-from javonet.core.handler.CommandHandler.InvokeInstanceMethodHandler import InvokeInstanceMethodHandler
-from javonet.core.handler.CommandHandler.CastingHandler import CastingHandler
-from javonet.core.handler.CommandHandler.GetInstanceFieldHandler import GetInstanceFieldHandler
-from javonet.core.handler.CommandHandler.SetInstanceFieldHandler import SetInstanceFieldHandler
-from javonet.core.handler.CommandHandler.DestructReferenceHandler import DestructReferenceHandler
-from javonet.core.handler.CommandHandler.ArrayGetItemHandler import ArrayGetItemHandler
-from javonet.core.handler.CommandHandler.ArrayGetSizeHandler import ArrayGetSizeHandler
-from javonet.core.handler.CommandHandler.ArrayGetRankHandler import ArrayGetRankHandler
-from javonet.core.handler.CommandHandler.ArraySetItemHandler import ArraySetItemHandler
-from javonet.core.handler.CommandHandler.ArrayHandler import ArrayHandler
-from javonet.core.handler.CommandHandler.GetEnumItemHandler import GetEnumItemHandler
-from javonet.core.handler.CommandHandler.GetEnumNameHandler import GetEnumNameHandler
-from javonet.core.handler.CommandHandler.GetEnumValueHandler import GetEnumValueHandler
+from javonet.core.handler.ValueHandler import ValueHandler
+from javonet.core.handler.LoadLibraryHandler import LoadLibraryHandler
+from javonet.core.handler.InvokeStaticMethodHandler import InvokeStaticMethodHandler
+from javonet.core.handler.SetStaticFieldHandler import SetStaticFieldHandler
+from javonet.core.handler.CreateClassInstanceHandler import CreateClassInstanceHandler
+from javonet.core.handler.GetStaticFieldHandler import GetStaticFieldHandler
+from javonet.core.handler.ResolveInstanceHandler import ResolveInstanceHandler
+from javonet.core.handler.GetTypeHandler import GetTypeHandler
+from javonet.core.handler.InvokeInstanceMethodHandler import InvokeInstanceMethodHandler
+from javonet.core.handler.CastingHandler import CastingHandler
+from javonet.core.handler.GetInstanceFieldHandler import GetInstanceFieldHandler
+from javonet.core.handler.SetInstanceFieldHandler import SetInstanceFieldHandler
+from javonet.core.handler.DestructReferenceHandler import DestructReferenceHandler
+from javonet.core.handler.ArrayGetItemHandler import ArrayGetItemHandler
+from javonet.core.handler.ArrayGetSizeHandler import ArrayGetSizeHandler
+from javonet.core.handler.ArrayGetRankHandler import ArrayGetRankHandler
+from javonet.core.handler.ArraySetItemHandler import ArraySetItemHandler
+from javonet.core.handler.ArrayHandler import ArrayHandler
+from javonet.core.handler.GetEnumItemHandler import GetEnumItemHandler
+from javonet.core.handler.GetEnumNameHandler import GetEnumNameHandler
+from javonet.core.handler.GetEnumValueHandler import GetEnumValueHandler
+from javonet.core.handler.EnableNamespaceHandler import EnableNamespaceHandler
+from javonet.core.handler.EnableTypeHandler import EnableTypeHandler
 
 from javonet.core.handler.HandlerDictionary import handler_dict
-from javonet.core.handler.ReferencesCache import ReferencesCache
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
 from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 from javonet.utils.CommandType import CommandType
 from javonet.utils.Command import Command
@@ -31,7 +33,6 @@ from javonet.utils.Command import Command
 class Handler(AbstractHandler):
 
     def __init__(self):
-
         handler_dict[CommandType.Value] = ValueHandler()
         handler_dict[CommandType.LoadLibrary] = LoadLibraryHandler()
         handler_dict[CommandType.InvokeStaticMethod] = InvokeStaticMethodHandler()
@@ -53,7 +54,8 @@ class Handler(AbstractHandler):
         handler_dict[CommandType.GetEnumItem] = GetEnumItemHandler()
         handler_dict[CommandType.GetEnumName] = GetEnumNameHandler()
         handler_dict[CommandType.GetEnumValue] = GetEnumValueHandler()
-
+        handler_dict[CommandType.EnableNamespace] = EnableNamespaceHandler()
+        handler_dict[CommandType.EnableType] = EnableTypeHandler()
 
     def handle_command(self, command):
         try:

data/lib/javonet-ruby-sdk/Binaries/Python/{Windows/X64/javonet/core/handler/CommandHandler → Linux/X64/javonet/core/handler}/InvokeInstanceMethodHandler.py

@@ -1,31 +1,31 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
-
-
-class InvokeInstanceMethodHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 2
-
-    def process(self, command):
-        try:
-            if len(command.payload) < self._required_parameters_count:
-                raise Exception("InvokeInstanceMethod 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:
-            exc_type, exc_value = type(e), e
-            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
-            raise new_exc from None
+from javonet.core.handler.AbstractCommandHandler import *
+
+
+class InvokeInstanceMethodHandler(AbstractCommandHandler):
+
+    def __init__(self):
+        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:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/{CommandHandler/InvokeStaticMethodHandler.py → InvokeStaticMethodHandler.py}

@@ -1,6 +1,6 @@
 import traceback
 
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class InvokeStaticMethodHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/{CommandHandler/LoadLibraryHandler.py → LoadLibraryHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 import sys
 import os
 

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/{CommandHandler/ResolveInstanceHandler.py → ResolveInstanceHandler.py}

@@ -1,5 +1,5 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
-from javonet.core.handler.ReferencesCache import ReferencesCache
+from javonet.core.handler.AbstractCommandHandler import *
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
 
 
 class ResolveInstanceHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/{CommandHandler/SetInstanceFieldHandler.py → SetInstanceFieldHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class SetInstanceFieldHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/{MacOs/X64/javonet/core/handler/CommandHandler → Linux/X64/javonet/core/handler}/SetStaticFieldHandler.py

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class SetStaticFieldHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/handler/{CommandHandler/ValueHandler.py → ValueHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class ValueHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/namespaceCache/NamespaceCache.py

@@ -0,0 +1,44 @@
+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:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(NamespaceCache, cls).__new__(cls)
+        return cls._instance
+
+    def cache_namespace(self, namespace_regex):
+        with self._lock:
+            self.namespace_cache.append(namespace_regex)
+
+    def is_namespace_cache_empty(self):
+        with self._lock:
+            return len(self.namespace_cache) == 0
+
+    def is_type_allowed(self, type_to_check):
+        with self._lock:
+            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
+
+    def get_cached_namespaces(self):
+        with self._lock:
+            return self.namespace_cache[:]
+
+    def clear_cache(self):
+        with self._lock:
+            self.namespace_cache.clear()
+            return 0

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/CommandSerializer.py

@@ -65,9 +65,6 @@ class CommandSerializer:
                 inner_command = command.get_payload()[0]
                 self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
                 queue.append(inner_command)
-            elif isinstance(command.get_payload()[0], Exception):
-                result = self.serialize_primitive(str(command.get_payload()[0]))
-                self.insert_into_buffer(result)
             else:
                 result = self.serialize_primitive(command.get_payload()[0])
                 self.insert_into_buffer(result)

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/receiver/Receiver.py

@@ -10,4 +10,7 @@ class Receiver:
         return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray)))
 
     def HeartBeat(self, messageByteArray, messageByteArrayLen):
-        return bytearray([49, 48])
+        response_byte_array = bytearray(2)
+        response_byte_array[0] = messageByteArray[11]
+        response_byte_array[1] = messageByteArray[12] - 2
+        return response_byte_array

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/referenceCache/ReferencesCache.py

@@ -0,0 +1,38 @@
+import uuid
+import threading
+from javonet.utils.CommandType import CommandType
+
+class ReferencesCache(object):
+    _instance = None
+    references_cache = dict()
+    _lock = threading.Lock()  # Initialize a lock object
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(ReferencesCache, cls).__new__(cls)
+        return cls._instance
+
+    def cache_reference(self, object_reference):
+        with self._lock:
+            uuid_ = str(uuid.uuid4())
+            self.references_cache[uuid_] = object_reference
+            return uuid_
+
+    def resolve_reference(self, command):
+        if command.command_type != CommandType.Reference:
+            raise Exception(
+                "Trying to dereference Python command with command_type: " + str(command.command_type))
+        with self._lock:
+            try:
+                return self.references_cache[command.payload[0]]
+            except KeyError:
+                raise Exception("Object not found in references")
+
+    def delete_reference(self, reference_guid):
+        with self._lock:
+            try:
+                del self.references_cache[reference_guid]
+                return 0
+            except KeyError:
+                raise Exception("Object not found in references")

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/typeCache/TypeCache.py

@@ -0,0 +1,44 @@
+import re
+import types
+import threading
+
+
+class TypeCache(object):
+    _instance = None
+    type_cache = list()
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(TypeCache, cls).__new__(cls)
+        return cls._instance
+
+    def cache_type(self, type_regex):
+        with self._lock:
+            self.type_cache.append(type_regex)
+
+    def is_type_cache_empty(self):
+        with self._lock:
+            return len(self.type_cache) == 0
+
+    def is_type_allowed(self, type_to_check):
+        with self._lock:
+            if isinstance(type_to_check, types.ModuleType):
+                name_to_check = type_to_check.__name__
+            else:
+                name_to_check = ".".join([type_to_check.__module__, type_to_check.__name__])
+            for pattern in self.type_cache:
+                if re.match(pattern, name_to_check):
+                    return True
+        return False
+
+    def get_cached_types(self):
+        with self._lock:
+            return self.type_cache[:]
+
+    def clear_cache(self):
+        with self._lock:
+            self.type_cache.clear()
+            return 0

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/CommandType.py

@@ -36,3 +36,5 @@ class CommandType(Enum):
     AsRef = 31
     AsOut = 32
     GetRefValue = 33
+    EnableNamespace = 34
+    EnableType = 35

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/ArrayGetItemHandler.py → ArrayGetItemHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class ArrayGetItemHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/CommandHandler → MacOs/X64/javonet/core/handler}/ArrayGetRankHandler.py

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 #import numpy as np
 
 

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/ArrayGetSizeHandler.py → ArrayGetSizeHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 class ArrayGetSizeHandler(AbstractCommandHandler):
     def __init__(self):

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/CommandHandler → MacOs/X64/javonet/core/handler}/ArrayHandler.py

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class ArrayHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/ArraySetItemHandler.py → ArraySetItemHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class ArraySetItemHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/CommandHandler → MacOs/X64/javonet/core/handler}/CastingHandler.py

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class CastingHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/CreateClassInstanceHandler.py → CreateClassInstanceHandler.py}

@@ -1,6 +1,6 @@
 from inspect import signature
 
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class CreateClassInstanceHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/CommandHandler → MacOs/X64/javonet/core/handler}/DestructReferenceHandler.py

@@ -1,6 +1,6 @@
-from javonet.core.handler.ReferencesCache import ReferencesCache
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
 
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class DestructReferenceHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/EnableNamespaceHandler.py

@@ -0,0 +1,28 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
+
+
+class EnableNamespaceHandler(AbstractCommandHandler):
+    def __init__(self):
+        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:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/EnableTypeHandler.py

@@ -0,0 +1,28 @@
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.typeCache.TypeCache import TypeCache
+
+
+class EnableTypeHandler(AbstractCommandHandler):
+    def __init__(self):
+        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:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/CommandHandler → MacOs/X64/javonet/core/handler}/GetEnumItemHandler.py

@@ -1,6 +1,6 @@
 from importlib import import_module
 
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class GetEnumItemHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/{Linux/X64/javonet/core/handler/CommandHandler → MacOs/X64/javonet/core/handler}/GetEnumNameHandler.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class GetEnumNameHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/GetEnumValueHandler.py → GetEnumValueHandler.py}

@@ -1,6 +1,6 @@
 from enum import Enum
 
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
 
 
 class GetEnumValueHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/GetInstanceFieldHandler.py → GetInstanceFieldHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class GetInstanceFieldHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/{CommandHandler/GetStaticFieldHandler.py → GetStaticFieldHandler.py}

@@ -1,4 +1,4 @@
-from javonet.core.handler.CommandHandler.AbstractCommandHandler import *
+from javonet.core.handler.AbstractCommandHandler import *
 
 
 class GetStaticFieldHandler(AbstractCommandHandler):

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/GetTypeHandler.py

@@ -0,0 +1,56 @@
+from importlib import import_module
+
+from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
+from javonet.core.namespaceCache.NamespaceCache import NamespaceCache
+from javonet.core.typeCache.TypeCache import TypeCache
+
+
+class GetTypeHandler(AbstractCommandHandler):
+    def __init__(self):
+        self._required_parameters_count = 1
+        self.namespace_cache = NamespaceCache()
+        self.type_cache = TypeCache()
+
+    def process(self, command):
+        try:
+            if len(command.payload) < self._required_parameters_count:
+                raise Exception(self.__class__.__name__ + " parameters mismatch!")
+
+            type_to_return = self._get_type_from_payload(command)
+
+            if type_to_return is None:
+                raise Exception(f"Type {command.payload[0]} not found")
+
+            if ((
+                    self.namespace_cache.is_namespace_cache_empty() and self.type_cache.is_type_cache_empty()) or  # both caches are empty
+                    self.namespace_cache.is_type_allowed(type_to_return) or  # namespace is allowed
+                    self.type_cache.is_type_allowed(type_to_return)  # type is allowed
+            ):
+                pass  # continue - type is allowed
+            else:
+                allowed_namespaces = ", ".join(self.namespace_cache.get_cached_namespaces())
+                allowed_types = ", ".join(self.type_cache.get_cached_types())
+                raise Exception(
+                    f"Type {type_to_return.__name__} not allowed. \nAllowed namespaces: {allowed_namespaces}\nAllowed types: {allowed_types}")
+
+            return type_to_return
+
+        except Exception as e:
+            exc_type, exc_value = type(e), e
+            new_exc = exc_type(exc_value).with_traceback(e.__traceback__)
+            raise new_exc from None
+
+    def _get_type_from_payload(self, command):
+        if len(command.payload) == 1:
+            type_name = command.payload[0].split(".")
+            if len(type_name) == 1:
+                return import_module(type_name[0])
+            else:
+                return self._get_type_from_nested_payload(type_name)
+        else:
+            return self._get_type_from_nested_payload(command.payload)
+
+    def _get_type_from_nested_payload(self, payload):
+        for i in range(len(payload) - 1):
+            loaded_module = import_module(".".join(payload[:i + 1]))
+        return getattr(loaded_module, payload[-1])