javonet-ruby-sdk 2.4.10 → 2.4.11

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

@@ -1,89 +0,0 @@
-from javonet.core.handler.AbstractHandler import AbstractHandler
-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.referenceCache.ReferencesCache import ReferencesCache
-from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
-from javonet.utils.CommandType import CommandType
-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()
-        handler_dict[CommandType.SetStaticField] = SetStaticFieldHandler()
-        handler_dict[CommandType.CreateClassInstance] = CreateClassInstanceHandler()
-        handler_dict[CommandType.GetStaticField] = GetStaticFieldHandler()
-        handler_dict[CommandType.Reference] = ResolveInstanceHandler()
-        handler_dict[CommandType.GetType] = GetTypeHandler()
-        handler_dict[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodHandler()
-        handler_dict[CommandType.Cast] = CastingHandler()
-        handler_dict[CommandType.GetInstanceField] = GetInstanceFieldHandler()
-        handler_dict[CommandType.SetInstanceField] = SetInstanceFieldHandler()
-        handler_dict[CommandType.DestructReference] = DestructReferenceHandler()
-        handler_dict[CommandType.ArrayGetItem] = ArrayGetItemHandler()
-        handler_dict[CommandType.ArrayGetSize] = ArrayGetSizeHandler()
-        handler_dict[CommandType.ArrayGetRank] = ArrayGetRankHandler()
-        handler_dict[CommandType.ArraySetItem] = ArraySetItemHandler()
-        handler_dict[CommandType.Array] = ArrayHandler()
-        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:
-            if command.command_type == CommandType.RetrieveArray:
-                response_array = handler_dict[CommandType.Reference].handle_command(command.payload[0])
-                return Command.create_array_response(response_array, command.runtime_name)
-
-            response = handler_dict.get(command.command_type).handle_command(command)
-            return self.__parse_response(response, command.runtime_name)
-        except Exception as e:
-            return ExceptionSerializer.serialize_exception(e, command)
-
-    def __parse_response(self, response, runtime_name):
-        if self.__is_response_simple_type(response) or self.__is_response_null(response):
-            return Command.create_response(response, runtime_name)
-        else:
-            reference_cache = ReferencesCache()
-            guid = reference_cache.cache_reference(response)
-            return Command.create_reference(guid, runtime_name)
-
-    @staticmethod
-    def __is_response_simple_type(response):
-        return isinstance(response, (int, float, bool, str))
-
-    @staticmethod
-    def __is_response_null(response):
-        return response is None
-
-    @staticmethod
-    def __is_response_array(response):
-        return isinstance(response, list);

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/handler/HandlerDictionary.py

@@ -1,8 +0,0 @@
-handler_dict = {}
-
-
-class HandlerDictionary:
-
-    @staticmethod
-    def add_handler_to_dict(command_type, handler):
-        handler_dict[command_type] = handler

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/handler/InvokeInstanceMethodHandler.py

@@ -1,31 +0,0 @@
-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/Windows/X64/javonet/core/handler/InvokeStaticMethodHandler.py

@@ -1,35 +0,0 @@
-import traceback
-
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class InvokeStaticMethodHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        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:
-            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/Windows/X64/javonet/core/handler/LoadLibraryHandler.py

@@ -1,25 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-import sys
-import os
-
-
-class LoadLibraryHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        self._required_parameters_count = 1
-
-    def process(self, command):
-        try:
-            if len(command.payload) != self._required_parameters_count:
-                raise Exception("LoadLibrary payload parameters mismatch")
-
-            if os.path.isdir(command.payload[0]):
-                sys.path.append(command.payload[0])
-            else:
-                raise Exception(command.payload[0] + " does not exist");
-
-            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/Windows/X64/javonet/core/handler/ResolveInstanceHandler.py

@@ -1,19 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-from javonet.core.referenceCache.ReferencesCache import ReferencesCache
-
-
-class ResolveInstanceHandler(AbstractCommandHandler):
-    def __init__(self):
-        self._required_parameters_count = 1
-
-    def process(self, command):
-        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:
-            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/Windows/X64/javonet/core/handler/SetInstanceFieldHandler.py

@@ -1,29 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class SetInstanceFieldHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        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:
-            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/Windows/X64/javonet/core/handler/SetStaticFieldHandler.py

@@ -1,29 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import *
-
-
-class SetStaticFieldHandler(AbstractCommandHandler):
-
-    def __init__(self):
-        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:
-            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/Windows/X64/javonet/core/handler/ValueHandler.py

@@ -1,6 +0,0 @@
-from javonet.core.handler.AbstractCommandHandler import AbstractCommandHandler
-
-
-class ValueHandler(AbstractCommandHandler):
-    def process(self, command):
-        return command.payload[0]

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/interpreter/Interpreter.py

@@ -1,34 +0,0 @@
-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
-from javonet.utils.connectionData.IConnectionData import IConnectionData
-
-class Interpreter:
-
-    def execute(self, command, connection_data: IConnectionData):
-        command_serializer = CommandSerializer()
-        serialized_command = command_serializer.serialize(command, connection_data)
-        response = None
-        if connection_data.connection_type == ConnectionType.WebSocket:
-            from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
-            response = WebSocketClient().send_message(connection_data, serialized_command)
-        elif (command.runtime_name == RuntimeName.python) & (connection_data.connection_type == ConnectionType.InMemory):
-            from javonet.core.receiver.Receiver import Receiver
-            response = Receiver().SendCommand(serialized_command, len(serialized_command))
-        else:
-            from javonet.core.transmitter.Transmitter import Transmitter
-            response = Transmitter.send_command(serialized_command)
-
-        command_deserializer = CommandDeserializer(response, len(response))
-        return command_deserializer.deserialize()
-
-    def process(self, byte_array, byte_array_len, connection_data: IConnectionData):
-        command_deserializer = CommandDeserializer(byte_array, byte_array_len)
-        received_command = command_deserializer.deserialize()
-        python_handler = Handler()
-        command_serializer = CommandSerializer()
-        response_command = python_handler.handle_command(received_command)
-        encoded_response = command_serializer.serialize(response_command, connection_data)
-        return encoded_response

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

@@ -1,44 +0,0 @@
-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/Windows/X64/javonet/core/protocol/CommandDeserializer.py

@@ -1,147 +0,0 @@
-from javonet.core.protocol.TypeDeserializer import TypeDeserializer
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.Type import Type
-from javonet.utils.StringEncodingMode import StringEncodingMode
-
-
-class CommandDeserializer:
-    position = 0
-    buffer = []
-    command = 0
-    buffer_len = 0
-
-    def __init__(self, buffer, buffer_len):
-        self.buffer = buffer
-        self.buffer_len = buffer_len
-        self.command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
-        self.position = 11
-
-    def is_at_end(self):
-        return self.position == self.buffer_len
-
-    def deserialize(self):
-        while not self.is_at_end():
-            self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
-        return self.command
-
-    # def copy_from(self, bytes_to_copy, elements_to_skip):
-    #     size = len(bytes_to_copy) - elements_to_skip
-    #     new_byte_array = bytes_to_copy[size:]
-    #     return new_byte_array
-
-    def read_object(self, type_num):
-        type_value = Type(type_num)
-        switch = {
-            Type.Command: self.read_command,
-            Type.JavonetString: self.read_string,
-            Type.JavonetInteger: self.read_int,
-            Type.JavonetBoolean: self.read_bool,
-            Type.JavonetFloat: self.read_float,
-            Type.JavonetByte: self.read_byte,
-            Type.JavonetChar: self.read_char,
-            Type.JavonetLongLong: self.read_longlong,
-            Type.JavonetDouble: self.read_double,
-            Type.JavonetUnsignedLongLong: self.read_ullong,
-            Type.JavonetUnsignedInteger: self.read_uint,
-            Type.JavonetNoneType: self.read_none
-        }
-        return switch.get(type_value, lambda: Exception("Type not supported"))()
-
-    def read_command(self):
-        p = self.position
-        number_of_elements_in_payload = TypeDeserializer.deserialize_int(self.buffer[p + 1: p + 5])
-        runtime = self.buffer[p + 5]
-        command_type = self.buffer[p + 6]
-        self.position += 7
-        return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
-        return self.read_command_recursively(number_of_elements_in_payload, return_command)
-
-    def read_command_recursively(self, number_of_elements_in_payload_left, cmd):
-        if number_of_elements_in_payload_left == 0:
-            return cmd
-        else:
-            p = self.position
-            cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
-            return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
-
-    def read_string(self):
-        p = self.position
-        string_encoding_mode = StringEncodingMode(self.buffer[p+1])
-        size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
-        self.position += 6
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
-
-    def read_int(self):
-        size = 4
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
-
-    def read_bool(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_bool(self.buffer[p:p+size])
-
-    def read_float(self):
-        size = 4
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
-    
-    def read_byte(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_byte(self.buffer[p:p+size])
-    
-    def read_char(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_char(self.buffer[p:p+size])
-
-    def read_longlong(self):
-        size = 8
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
-
-    def read_double(self):
-        size = 8
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
-
-    def read_ullong(self):
-        size = 8
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
-
-    def read_uint(self):
-        size = 4
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
-
-    def read_none(self):
-        size = 1
-        self.position += 2
-        p = self.position
-        self.position += size
-        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])
-    

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

@@ -1,61 +0,0 @@
-from collections import deque
-from typing import Deque
-
-from javonet.core.protocol.TypeSerializer import TypeSerializer
-from javonet.utils.Command import Command
-from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.connectionData.IConnectionData import IConnectionData
-
-
-class CommandSerializer:
-    byte_buffer = []
-
-    def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
-        queue: Deque[Command] = deque()
-        queue.append(root_command)
-        self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
-        self.insert_into_buffer(connection_data.serialize_connection_data())
-        self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
-        return self.serialize_recursively(queue)
-
-    @staticmethod
-    def serialize_primitive(payload_item):
-        if payload_item is None:
-            return TypeSerializer.serialize_none()
-        if isinstance(payload_item, bool):
-            return TypeSerializer.serialize_bool(payload_item)
-        elif isinstance(payload_item, int):
-            if payload_item in range(-2 ** 31, 2 ** 31):
-                return TypeSerializer.serialize_int(payload_item)
-            elif payload_item in range(-2 ** 63, 2 ** 63):
-                return TypeSerializer.serialize_longlong(payload_item)
-            else:
-                return TypeSerializer.serialize_ullong(payload_item)
-        elif isinstance(payload_item, float):
-            return TypeSerializer.serialize_double(payload_item)
-        elif isinstance(payload_item, str):
-            return TypeSerializer.serialize_string(payload_item)
-        else:
-            raise Exception("Python: Type serialization not supported for type: " + payload_item)
-
-    def insert_into_buffer(self, arguments):
-        self.byte_buffer = self.byte_buffer + arguments
-
-    def serialize_recursively(self, queue):
-        if not queue:
-            return self.byte_buffer
-        command = queue.pop()
-        queue.append(command.drop_first_payload_argument())
-        if len(command.get_payload()) > 0:
-            if isinstance(command.get_payload()[0], Command):
-                inner_command = command.get_payload()[0]
-                self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
-                queue.append(inner_command)
-            else:
-                result = self.serialize_primitive(command.get_payload()[0])
-                self.insert_into_buffer(result)
-            return self.serialize_recursively(queue)
-        else:
-            queue.pop()
-
-        return self.serialize_recursively(queue)

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/protocol/TypeDeserializer.py

@@ -1,64 +0,0 @@
-import struct
-
-from javonet.utils import Command, CommandType, RuntimeName
-from javonet.utils.StringEncodingMode import StringEncodingMode
-
-
-class TypeDeserializer:
-
-    @staticmethod
-    def deserialize_command(encoded_command ):
-        return Command(RuntimeName(encoded_command[0]), CommandType(encoded_command[1]), [])
-
-    @staticmethod
-    def deserialize_string(string_encoding_mode, encoded_string):
-        if string_encoding_mode == StringEncodingMode.ASCII:
-            return bytearray(encoded_string).decode('ascii')
-        if string_encoding_mode == StringEncodingMode.UTF8:
-            return bytearray(encoded_string).decode('utf-8')
-        if string_encoding_mode == StringEncodingMode.UTF16:
-            return bytearray(encoded_string).decode('utf-16')
-        if string_encoding_mode == StringEncodingMode.UTF32:
-            return bytearray(encoded_string).decode('utf-32')
-
-        raise IndexError("String encoding mode out of range")
-
-    @staticmethod
-    def deserialize_int(encoded_int):
-        return struct.unpack("<i", bytearray(encoded_int))[0]
-    
-    @staticmethod
-    def deserialize_bool(encoded_bool):
-        return struct.unpack("<?", bytearray(encoded_bool))[0]
-    
-    @staticmethod
-    def deserialize_float(encoded_float):
-        return struct.unpack("<f", bytearray(encoded_float))[0]
-
-    @staticmethod
-    def deserialize_byte(encoded_byte):
-        return struct.unpack("<B", bytearray(encoded_byte))[0]
-    
-    @staticmethod
-    def deserialize_char(encoded_char):
-        return struct.unpack("<b", bytearray(encoded_char))[0]
-
-    @staticmethod
-    def deserialize_longlong(encoded_longlong):
-        return struct.unpack("<q", bytearray(encoded_longlong))[0]
-
-    @staticmethod
-    def deserialize_double(encoded_double):
-        return struct.unpack("<d", bytearray(encoded_double))[0]
-
-    @staticmethod
-    def deserialize_ullong(encoded_unsigned_longlong):
-        return struct.unpack("<Q", bytearray(encoded_unsigned_longlong))[0]
-
-    @staticmethod
-    def deserialize_uint(encoded_unsigned_int):
-        return struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
-
-    @staticmethod
-    def deserialize_none(encoded_none):
-        return None