DLMS-SPODES-client 0.19.35__py3-none-any.whl → 0.19.37__py3-none-any.whl

DLMS_SPODES_client/gurux_dlms/GXByteBuffer.py

@@ -1,545 +1,545 @@
-import struct
-
-
-class GXByteBuffer:
-    """ Byte array class is used to save received bytes. """
-    info = 'gurux'  # gurux object flag
-    __HEX_ARRAY = "0123456789ABCDEFGH"
-    __NIBBLE = 4
-    __LOW_BYTE_PART = 0x0F
-    __ARRAY_CAPACITY = 10
-
-    def __init__(self, value=None):
-        """
-        Constructor.
-        value: Buffer or capacity.
-        """
-        self._data = bytearray()
-        self.__size = 0
-        self.__position = 0
-        match value:
-            case bytearray() | bytes():
-                self.setCapacity(len(value))
-                self.set(value)
-            case GXByteBuffer():
-                self.setCapacity(value.size - value.position)
-                self.set(value)
-            case int():            self.setCapacity(value)
-            case str():            self.setHexString(value)
-            case _:                self.setCapacity(0)
-
-    def clear(self):
-        """ Clear buffer but do not release memory. """
-        self.position = 0
-        self.size = 0
-
-    def getCapacity(self):
-        if not self._data:
-            return 0
-        return len(self._data)
-
-    #
-    #      Allocate new size for the array in bytes.
-    #
-    #      @param capacity
-    #                 Buffer capacity.
-    #
-    def setCapacity(self, capacity):
-        if capacity == 0:
-            self._data = bytearray()
-            self.__size = 0
-            self.__position = 0
-        else:
-            if not self._data:
-                self._data = bytearray(capacity)
-            else:
-                tmp = self._data
-                self._data = bytearray(capacity)
-                if self.size < capacity:
-                    self._data[0:self.size] = tmp
-                else:
-                    self._data[0:capacity] = self._data
-                    self.__size = capacity
-
-    capacity = property(getCapacity, setCapacity)
-    """Buffer capacity."""
-
-    def getPosition(self):
-        return self.__position
-
-    def setPosition(self, value):
-        if value < 0 or value > len(self):
-            raise ValueError("position")
-        self.__position = value
-
-    position = property(getPosition, setPosition)
-    """Buffer position."""
-
-    def getSize(self):
-        return self.__size
-
-    def setsize(self, value):
-        if value < 0 or value > self.capacity:
-            raise ValueError("size")
-        self.__size = value
-        if self.__position > self.__size:
-            self.__position = self.__size
-
-    size = property(getSize, setsize)
-    """Buffer size."""
-
-    def __len__(self) -> int:
-        """Buffer size."""
-        return self.__size
-
-    def __getitem__(self, i):
-        return self._data[i]
-
-    def available(self) -> int:
-        """Amount of non read bytes in the buffer."""
-        return self.size - self.position
-
-    #
-    # Get buffer data as byte array.
-    #
-    def array(self) -> bytearray:
-        return self.subArray(0, self.size)
-
-    #
-    #      Returns sub array from byte buffer.
-    #
-    #      @param index
-    #                 Start index.
-    #      @param count
-    #                 Byte count.
-    # Sub array.
-    #
-    def subArray(self, index: int, count: int) -> bytearray:
-        if count != 0:
-            tmp = bytearray(count)
-            tmp[0:count] = self._data[index:index + count]
-            return tmp
-        return bytearray(0)
-
-    #
-    #      Move content from source to destination.
-    #
-    #      @param srcPos
-    #                 Source position.
-    #      @param destPos
-    #                 Destination position.
-    #      @param count
-    #                 Item count.
-    #
-    def move(self, srcPos, destPos, count):
-        if count < 0:
-            raise ValueError("count")
-        if count != 0:
-            self._data[destPos:destPos + count] = self._data[srcPos:srcPos + count]
-            self.size = destPos + count
-            if self.position > self.size:
-                self.position = self.size
-
-    #
-    #      Remove handled bytes.  This can be used in debugging to remove
-    #      handled
-    #      bytes.
-    #
-    def trim(self):
-        if self.size == self.position:
-            self.size = 0
-        else:
-            self.move(self.position, 0, self.size - self.position)
-        self.position = 0
-
-    #
-    #      Push the given byte into this buffer at the current position, and
-    #      then
-    #      increments the position.
-    #
-    #      @param item
-    #                 The byte to be added.
-    #
-    def setUInt8(self, item, index=None):
-        if index is None:
-            self.setUInt8(item, self.size)
-            self.size += 1
-        else:
-            if index >= self.capacity:
-                self.capacity = index + self.__ARRAY_CAPACITY
-            self._data[index] = item
-
-    #
-    #      Push the given byte into this buffer at the current position, and
-    #      then
-    #      increments the position.
-    #
-    #      @param item
-    #                 The byte to be added.
-    #
-    def setInt8(self, item, index=None):
-        self.setUInt8(item & 0xFF, index)
-
-    def setUInt16(self, item, index=None):
-        if index is None:
-            self.setUInt16(item, self.size)
-            self.size += 2
-        else:
-            if index + 2 >= self.capacity:
-                self.capacity = (index + self.__ARRAY_CAPACITY)
-            self._data[index] = int(((item >> 8) & 0xFF))
-            self._data[index + 1] = int((item & 0xFF))
-
-    def setUInt32(self, item, index=None):
-        if index is None:
-            self.setUInt32(item, self.size)
-            self.size += 4
-        else:
-            if index + 4 >= self.capacity:
-                self.capacity = index + self.__ARRAY_CAPACITY
-            self._data[index] = int(((item >> 24) & 0xFF))
-            self._data[index + 1] = int(((item >> 16) & 0xFF))
-            self._data[index + 2] = int(((item >> 8) & 0xFF))
-            self._data[index + 3] = int((item & 0xFF))
-
-    def setUInt64(self, item, index=None):
-        if index is None:
-            self.setUInt64(item, self.size)
-            self.size += 8
-        else:
-            if index + 8 >= self.capacity:
-                self.capacity = (index + self.__ARRAY_CAPACITY)
-            self._data[self.size] = int(((item >> 56) & 0xFF))
-            self._data[self.size + 1] = int(((item >> 48) & 0xFF))
-            self._data[self.size + 2] = int(((item >> 40) & 0xFF))
-            self._data[self.size + 3] = int(((item >> 32) & 0xFF))
-            self._data[self.size + 4] = int(((item >> 24) & 0xFF))
-            self._data[self.size + 5] = int(((item >> 16) & 0xFF))
-            self._data[self.size + 6] = int(((item >> 8) & 0xFF))
-            self._data[self.size + 7] = int((item & 0xFF))
-
-    def setFloat(self, value, index=None):
-        if index is None:
-            self.setFloat(value, self.size)
-            self.size += 4
-        else:
-            self.set(struct.pack("f", value), index)
-
-    def setDouble(self, value, index=None):
-        if index is None:
-            self.setDouble(value, self.size)
-            self.size += 8
-        else:
-            self.set(struct.pack("d", value), index)
-
-    def getUInt8(self, index: int = None) -> int:
-        if index is None:
-            index = self.position
-            value: int = self._data[index] & 0xFF
-            value = value % 2 ** 8
-            self.position += 1
-            return value
-        elif index >= self.size:
-            raise ValueError("getUInt8")
-        else:
-            value = self._data[index] & 0xFF
-            value = value % 2 ** 8
-            return value
-
-    def getInt8(self, index=None):
-        if index is None:
-            index = self.position
-            value = self._data[index]
-            value = (value + 2 ** 7) % 2 ** 8 - 2 ** 7
-            self.position += 1
-            return value
-        if index >= self.size:
-            raise ValueError("getInt8")
-        value = self._data[index]
-        value = (value + 2 ** 7) % 2 ** 8 - 2 ** 7
-        return value
-
-    def getUInt16(self, index=None):
-        if index is None:
-            index = self.position
-            value = ((self._data[index] & 0xFF) << 8) | (self._data[index + 1] & 0xFF)
-            value = value % 2 ** 16
-            self.position += 2
-            return value
-        if index + 2 > self.size:
-            raise ValueError("getUInt16")
-        value = ((self._data[index] & 0xFF) << 8) | (self._data[index + 1] & 0xFF)
-        value = value % 2 ** 16
-        return value
-
-    def getInt16(self):
-        return (self.getUInt16() + 2 ** 15) % 2 ** 16 - 2 ** 15
-
-    def getInt32(self, index=None):
-        if index is None:
-            index = self.position
-            if index + 4 > self.size:
-                raise ValueError("getInt32")
-            value = (self._data[index] & 0xFF) << 24 | (self._data[index + 1] & 0xFF) << 16 | (self._data[index + 2] & 0xFF) << 8 | (self._data[index + 3] & 0xFF)
-            value = (value + 2 ** 31) % 2 ** 32 - 2 ** 31
-            self.position += 4
-            return value
-
-        if index + 4 > self.size:
-            raise ValueError("getInt32")
-        value = (self._data[index] & 0xFF) << 24 | (self._data[index + 1] & 0xFF) << 16 | (self._data[index + 2] & 0xFF) << 8 | (self._data[index + 3] & 0xFF)
-        value = (value + 2 ** 31) % 2 ** 32 - 2 ** 31
-        return value
-
-    def getUInt32(self, index=None):
-        if index is None:
-            index = self.position
-            self.position += 4
-        if index + 4 > self.size:
-            raise ValueError("getUInt32")
-        value = self._data[index] & 0xFF
-        value = value << 24
-        value |= (self._data[index + 1] & 0xFF) << 16
-        value |= (self._data[index + 2] & 0xFF) << 8
-        value |= (self._data[index + 3] & 0xFF)
-        value = value % 2 ** 32
-        return value
-
-    def getFloat(self):
-        tmp = bytearray(4)
-        self.get(tmp)
-        # Swap bytes.
-        tmp2 = tmp[0]
-        tmp[0] = tmp[3]
-        tmp[3] = tmp2
-        tmp2 = tmp[1]
-        tmp[1] = tmp[2]
-        tmp[2] = tmp2
-        return struct.unpack("f", tmp)[0]
-
-    def getDouble(self):
-        tmp = bytearray(8)
-        self.get(tmp)
-        # Swap bytes.
-        tmp2 = tmp[0]
-        tmp[0] = tmp[7]
-        tmp[7] = tmp2
-        tmp2 = tmp[1]
-        tmp[1] = tmp[6]
-        tmp[6] = tmp2
-        tmp2 = tmp[2]
-        tmp[2] = tmp[5]
-        tmp[5] = tmp2
-        tmp2 = tmp[3]
-        tmp[3] = tmp[4]
-        tmp[4] = tmp2
-        return struct.unpack("d", tmp)[0]
-
-    def getInt64(self, index=None):
-        if index is None:
-            index = self.position
-            self.position += 8
-        value = ((self._data[index] & 0xFF)) << 56
-        value |= ((self._data[index + 1] & 0xFF)) << 48
-        value |= ((self._data[index + 2] & 0xFF)) << 40
-        value |= ((self._data[index + 3] & 0xFF)) << 32
-        value |= ((self._data[index + 4] & 0xFF)) << 24
-        value |= (self._data[index + 5] & 0xFF) << 16
-        value |= (self._data[index + 6] & 0xFF) << 8
-        value |= (self._data[index + 7] & 0xFF)
-        value = (value + 2 ** 63) % 2 ** 64 - 2 ** 63
-        return value
-
-    def getUInt64(self, index=None):
-        value = self.getInt64(index)
-        return value % 2 ** 64
-
-    #
-    #      Check is byte buffer ASCII string.
-    #
-    #      @param value
-    #                 Byte array.
-    # Is ASCII string.
-    #
-    @classmethod
-    def isAsciiString(cls, value):
-        # pylint: disable=too-many-boolean-expressions
-        if value:
-            for it in value:
-                if (it < 32 or it > 127) and it != '\r' and it != '\n' and it != '\t' and it != 0:
-                    return False
-        return True
-
-    def getString(self, index, count):
-        if index is None and count is None:
-            tmp = self._data[0:self.size]
-            if self.isAsciiString(tmp):
-                str_ = tmp.decode("utf-8").rstrip('\x00')
-            else:
-                str_ = tmp.hex(sep=' ')
-            self.position += count
-            return str_
-
-        if index + count > self.size:
-            raise ValueError("getString")
-        tmp = self._data[index:index + count]
-        if self.isAsciiString(tmp):
-            return tmp.decode("utf-8").rstrip('\x00')
-        return tmp.hex(sep=' ')
-
-    def set(self, value, index=None, count=None):
-        if isinstance(value, str):
-            value = value.encode()
-        if value:
-            if index is None:
-                if isinstance(value, GXByteBuffer):
-                    index = value.position
-                else:
-                    index = 0
-            if count is None:
-                count = len(value) - index
-            if isinstance(value, GXByteBuffer):
-                self.set(value._data, index, count)
-                value.position = index + count
-            elif value and count != 0:
-                if self.size + count > self.capacity:
-                    self.capacity = self.size + count + self.__ARRAY_CAPACITY
-                self._data[self.size:self.size + count] = value[index:index + count]
-                self.size += count
-
-    def get(self, target):
-        len1 = len(target)
-        if self.size - self.position < len1:
-            raise ValueError("get")
-        index = 0
-        for index in range(0, len1):
-            target[index] = self._data[self.position]
-            self.position = self.position + 1
-
-    #
-    #      Compares, whether two given arrays are similar starting from current
-    #      position.
-    #
-    #      @param arr
-    #                 Array to compare.
-    # True, if arrays are similar.  False, if the arrays differ.
-    #
-    def compare(self, arr):
-        len1 = len(arr)
-        if not arr or (self.size - self.position < len1):
-            return False
-        bytes_ = bytearray(len1)
-        self.get(bytes_)
-        ret = arr == bytes_
-        if not ret:
-            self.position -= len1
-        return ret
-
-    #
-    #      Reverses the order of the given array.
-    #
-    def reverse(self):
-        first = self.position
-        last = self.size - 1
-        tmp = int()
-        while last > first:
-            tmp = self._data[last]
-            self._data[last] = self._data[first]
-            self._data[first] = tmp
-            last -= 1
-            first += 1
-
-    #
-    #      Push the given hex string as byte array into this buffer at the
-    #      current
-    #      position, and then increments the position.
-    #
-    #      @param value
-    #                 Byte array to add.
-    #      @param index
-    #                 Byte index.
-    #      @param count
-    #                 Byte count.
-    #
-    def setHexString(self, value, index=0, count=None):
-        tmp = self.hexToBytes(value)
-        if count is None:
-            count = len(tmp)
-        self.set(tmp, index, count)
-
-    def __str__(self):
-        return self._data[:self.size].hex(sep=' ')
-
-    #
-    #      Get remaining data.
-    #
-    # Remaining data as byte array.
-    #
-    def remaining(self):
-        return self.subArray(self.position, self.size - self.position)
-
-    #
-    #      Get remaining data as a hex string.
-    #
-    #      @param addSpace
-    #                 Add space between bytes.
-    # Remaining data as a hex string.
-    #
-    def remainingHexString(self, addSpace=True):
-        return self.hex(self._data, addSpace, self.position, self.size - self.position)
-
-    #
-    #      Get data as hex string.
-    #
-    #      @param addSpace
-    #                 Add space between bytes.
-    #      @param index
-    #                 Byte index.
-    #      @param count
-    #                 Byte count.
-    # Data as hex string.
-    #
-    def toHex(self, addSpace=True, index=0, count=None):
-        if count is None:
-            count = len(self) - index
-        return self.hex(self._data, addSpace, index, count)
-
-    #Convert char hex value to byte value.
-    @classmethod
-    def ___getValue(cls, c):
-        #Id char.
-        if c.islower():
-            c = c.upper()
-        pos = GXByteBuffer.__HEX_ARRAY.find(c)
-        if pos == -1:
-            raise Exception("Invalid hex string")
-        return pos
-
-    @classmethod
-    def hexToBytes(cls, value):
-        """Convert string to byte array.
-        value: Hex string.
-        Returns byte array.
-        """
-        buff = bytearray()
-        if value:
-            lastValue = -1
-            for ch in value:
-                if ch != ' ':
-                    if lastValue == -1:
-                        lastValue = cls.___getValue(ch)
-                    elif lastValue != -1:
-                        buff.append(lastValue << GXByteBuffer.__NIBBLE | cls.___getValue(ch))
-                        lastValue = -1
-                elif lastValue != -1:
-                    buff.append(cls.___getValue(ch))
-                    lastValue = -1
-        return buff
-
-    @classmethod
-    def hex(cls, value, addSpace=True, index=0, count=None):
-        """ Convert byte array to hex string. """
-        return value[index:count].hex(sep=' ' if addSpace else '')
-
-    def get_data(self) -> bytes:
-        return bytes(self._data)[:self.size]
+import struct
+
+
+class GXByteBuffer:
+    """ Byte array class is used to save received bytes. """
+    info = 'gurux'  # gurux object flag
+    __HEX_ARRAY = "0123456789ABCDEFGH"
+    __NIBBLE = 4
+    __LOW_BYTE_PART = 0x0F
+    __ARRAY_CAPACITY = 10
+
+    def __init__(self, value=None):
+        """
+        Constructor.
+        value: Buffer or capacity.
+        """
+        self._data = bytearray()
+        self.__size = 0
+        self.__position = 0
+        match value:
+            case bytearray() | bytes():
+                self.setCapacity(len(value))
+                self.set(value)
+            case GXByteBuffer():
+                self.setCapacity(value.size - value.position)
+                self.set(value)
+            case int():            self.setCapacity(value)
+            case str():            self.setHexString(value)
+            case _:                self.setCapacity(0)
+
+    def clear(self):
+        """ Clear buffer but do not release memory. """
+        self.position = 0
+        self.size = 0
+
+    def getCapacity(self):
+        if not self._data:
+            return 0
+        return len(self._data)
+
+    #
+    #      Allocate new size for the array in bytes.
+    #
+    #      @param capacity
+    #                 Buffer capacity.
+    #
+    def setCapacity(self, capacity):
+        if capacity == 0:
+            self._data = bytearray()
+            self.__size = 0
+            self.__position = 0
+        else:
+            if not self._data:
+                self._data = bytearray(capacity)
+            else:
+                tmp = self._data
+                self._data = bytearray(capacity)
+                if self.size < capacity:
+                    self._data[0:self.size] = tmp
+                else:
+                    self._data[0:capacity] = self._data
+                    self.__size = capacity
+
+    capacity = property(getCapacity, setCapacity)
+    """Buffer capacity."""
+
+    def getPosition(self):
+        return self.__position
+
+    def setPosition(self, value):
+        if value < 0 or value > len(self):
+            raise ValueError("position")
+        self.__position = value
+
+    position = property(getPosition, setPosition)
+    """Buffer position."""
+
+    def getSize(self):
+        return self.__size
+
+    def setsize(self, value):
+        if value < 0 or value > self.capacity:
+            raise ValueError("size")
+        self.__size = value
+        if self.__position > self.__size:
+            self.__position = self.__size
+
+    size = property(getSize, setsize)
+    """Buffer size."""
+
+    def __len__(self) -> int:
+        """Buffer size."""
+        return self.__size
+
+    def __getitem__(self, i):
+        return self._data[i]
+
+    def available(self) -> int:
+        """Amount of non read bytes in the buffer."""
+        return self.size - self.position
+
+    #
+    # Get buffer data as byte array.
+    #
+    def array(self) -> bytearray:
+        return self.subArray(0, self.size)
+
+    #
+    #      Returns sub array from byte buffer.
+    #
+    #      @param index
+    #                 Start index.
+    #      @param count
+    #                 Byte count.
+    # Sub array.
+    #
+    def subArray(self, index: int, count: int) -> bytearray:
+        if count != 0:
+            tmp = bytearray(count)
+            tmp[0:count] = self._data[index:index + count]
+            return tmp
+        return bytearray(0)
+
+    #
+    #      Move content from source to destination.
+    #
+    #      @param srcPos
+    #                 Source position.
+    #      @param destPos
+    #                 Destination position.
+    #      @param count
+    #                 Item count.
+    #
+    def move(self, srcPos, destPos, count):
+        if count < 0:
+            raise ValueError("count")
+        if count != 0:
+            self._data[destPos:destPos + count] = self._data[srcPos:srcPos + count]
+            self.size = destPos + count
+            if self.position > self.size:
+                self.position = self.size
+
+    #
+    #      Remove handled bytes.  This can be used in debugging to remove
+    #      handled
+    #      bytes.
+    #
+    def trim(self):
+        if self.size == self.position:
+            self.size = 0
+        else:
+            self.move(self.position, 0, self.size - self.position)
+        self.position = 0
+
+    #
+    #      Push the given byte into this buffer at the current position, and
+    #      then
+    #      increments the position.
+    #
+    #      @param item
+    #                 The byte to be added.
+    #
+    def setUInt8(self, item, index=None):
+        if index is None:
+            self.setUInt8(item, self.size)
+            self.size += 1
+        else:
+            if index >= self.capacity:
+                self.capacity = index + self.__ARRAY_CAPACITY
+            self._data[index] = item
+
+    #
+    #      Push the given byte into this buffer at the current position, and
+    #      then
+    #      increments the position.
+    #
+    #      @param item
+    #                 The byte to be added.
+    #
+    def setInt8(self, item, index=None):
+        self.setUInt8(item & 0xFF, index)
+
+    def setUInt16(self, item, index=None):
+        if index is None:
+            self.setUInt16(item, self.size)
+            self.size += 2
+        else:
+            if index + 2 >= self.capacity:
+                self.capacity = (index + self.__ARRAY_CAPACITY)
+            self._data[index] = int(((item >> 8) & 0xFF))
+            self._data[index + 1] = int((item & 0xFF))
+
+    def setUInt32(self, item, index=None):
+        if index is None:
+            self.setUInt32(item, self.size)
+            self.size += 4
+        else:
+            if index + 4 >= self.capacity:
+                self.capacity = index + self.__ARRAY_CAPACITY
+            self._data[index] = int(((item >> 24) & 0xFF))
+            self._data[index + 1] = int(((item >> 16) & 0xFF))
+            self._data[index + 2] = int(((item >> 8) & 0xFF))
+            self._data[index + 3] = int((item & 0xFF))
+
+    def setUInt64(self, item, index=None):
+        if index is None:
+            self.setUInt64(item, self.size)
+            self.size += 8
+        else:
+            if index + 8 >= self.capacity:
+                self.capacity = (index + self.__ARRAY_CAPACITY)
+            self._data[self.size] = int(((item >> 56) & 0xFF))
+            self._data[self.size + 1] = int(((item >> 48) & 0xFF))
+            self._data[self.size + 2] = int(((item >> 40) & 0xFF))
+            self._data[self.size + 3] = int(((item >> 32) & 0xFF))
+            self._data[self.size + 4] = int(((item >> 24) & 0xFF))
+            self._data[self.size + 5] = int(((item >> 16) & 0xFF))
+            self._data[self.size + 6] = int(((item >> 8) & 0xFF))
+            self._data[self.size + 7] = int((item & 0xFF))
+
+    def setFloat(self, value, index=None):
+        if index is None:
+            self.setFloat(value, self.size)
+            self.size += 4
+        else:
+            self.set(struct.pack("f", value), index)
+
+    def setDouble(self, value, index=None):
+        if index is None:
+            self.setDouble(value, self.size)
+            self.size += 8
+        else:
+            self.set(struct.pack("d", value), index)
+
+    def getUInt8(self, index: int = None) -> int:
+        if index is None:
+            index = self.position
+            value: int = self._data[index] & 0xFF
+            value = value % 2 ** 8
+            self.position += 1
+            return value
+        elif index >= self.size:
+            raise ValueError("getUInt8")
+        else:
+            value = self._data[index] & 0xFF
+            value = value % 2 ** 8
+            return value
+
+    def getInt8(self, index=None):
+        if index is None:
+            index = self.position
+            value = self._data[index]
+            value = (value + 2 ** 7) % 2 ** 8 - 2 ** 7
+            self.position += 1
+            return value
+        if index >= self.size:
+            raise ValueError("getInt8")
+        value = self._data[index]
+        value = (value + 2 ** 7) % 2 ** 8 - 2 ** 7
+        return value
+
+    def getUInt16(self, index=None):
+        if index is None:
+            index = self.position
+            value = ((self._data[index] & 0xFF) << 8) | (self._data[index + 1] & 0xFF)
+            value = value % 2 ** 16
+            self.position += 2
+            return value
+        if index + 2 > self.size:
+            raise ValueError("getUInt16")
+        value = ((self._data[index] & 0xFF) << 8) | (self._data[index + 1] & 0xFF)
+        value = value % 2 ** 16
+        return value
+
+    def getInt16(self):
+        return (self.getUInt16() + 2 ** 15) % 2 ** 16 - 2 ** 15
+
+    def getInt32(self, index=None):
+        if index is None:
+            index = self.position
+            if index + 4 > self.size:
+                raise ValueError("getInt32")
+            value = (self._data[index] & 0xFF) << 24 | (self._data[index + 1] & 0xFF) << 16 | (self._data[index + 2] & 0xFF) << 8 | (self._data[index + 3] & 0xFF)
+            value = (value + 2 ** 31) % 2 ** 32 - 2 ** 31
+            self.position += 4
+            return value
+
+        if index + 4 > self.size:
+            raise ValueError("getInt32")
+        value = (self._data[index] & 0xFF) << 24 | (self._data[index + 1] & 0xFF) << 16 | (self._data[index + 2] & 0xFF) << 8 | (self._data[index + 3] & 0xFF)
+        value = (value + 2 ** 31) % 2 ** 32 - 2 ** 31
+        return value
+
+    def getUInt32(self, index=None):
+        if index is None:
+            index = self.position
+            self.position += 4
+        if index + 4 > self.size:
+            raise ValueError("getUInt32")
+        value = self._data[index] & 0xFF
+        value = value << 24
+        value |= (self._data[index + 1] & 0xFF) << 16
+        value |= (self._data[index + 2] & 0xFF) << 8
+        value |= (self._data[index + 3] & 0xFF)
+        value = value % 2 ** 32
+        return value
+
+    def getFloat(self):
+        tmp = bytearray(4)
+        self.get(tmp)
+        # Swap bytes.
+        tmp2 = tmp[0]
+        tmp[0] = tmp[3]
+        tmp[3] = tmp2
+        tmp2 = tmp[1]
+        tmp[1] = tmp[2]
+        tmp[2] = tmp2
+        return struct.unpack("f", tmp)[0]
+
+    def getDouble(self):
+        tmp = bytearray(8)
+        self.get(tmp)
+        # Swap bytes.
+        tmp2 = tmp[0]
+        tmp[0] = tmp[7]
+        tmp[7] = tmp2
+        tmp2 = tmp[1]
+        tmp[1] = tmp[6]
+        tmp[6] = tmp2
+        tmp2 = tmp[2]
+        tmp[2] = tmp[5]
+        tmp[5] = tmp2
+        tmp2 = tmp[3]
+        tmp[3] = tmp[4]
+        tmp[4] = tmp2
+        return struct.unpack("d", tmp)[0]
+
+    def getInt64(self, index=None):
+        if index is None:
+            index = self.position
+            self.position += 8
+        value = ((self._data[index] & 0xFF)) << 56
+        value |= ((self._data[index + 1] & 0xFF)) << 48
+        value |= ((self._data[index + 2] & 0xFF)) << 40
+        value |= ((self._data[index + 3] & 0xFF)) << 32
+        value |= ((self._data[index + 4] & 0xFF)) << 24
+        value |= (self._data[index + 5] & 0xFF) << 16
+        value |= (self._data[index + 6] & 0xFF) << 8
+        value |= (self._data[index + 7] & 0xFF)
+        value = (value + 2 ** 63) % 2 ** 64 - 2 ** 63
+        return value
+
+    def getUInt64(self, index=None):
+        value = self.getInt64(index)
+        return value % 2 ** 64
+
+    #
+    #      Check is byte buffer ASCII string.
+    #
+    #      @param value
+    #                 Byte array.
+    # Is ASCII string.
+    #
+    @classmethod
+    def isAsciiString(cls, value):
+        # pylint: disable=too-many-boolean-expressions
+        if value:
+            for it in value:
+                if (it < 32 or it > 127) and it != '\r' and it != '\n' and it != '\t' and it != 0:
+                    return False
+        return True
+
+    def getString(self, index, count):
+        if index is None and count is None:
+            tmp = self._data[0:self.size]
+            if self.isAsciiString(tmp):
+                str_ = tmp.decode("utf-8").rstrip('\x00')
+            else:
+                str_ = tmp.hex(sep=' ')
+            self.position += count
+            return str_
+
+        if index + count > self.size:
+            raise ValueError("getString")
+        tmp = self._data[index:index + count]
+        if self.isAsciiString(tmp):
+            return tmp.decode("utf-8").rstrip('\x00')
+        return tmp.hex(sep=' ')
+
+    def set(self, value, index=None, count=None):
+        if isinstance(value, str):
+            value = value.encode()
+        if value:
+            if index is None:
+                if isinstance(value, GXByteBuffer):
+                    index = value.position
+                else:
+                    index = 0
+            if count is None:
+                count = len(value) - index
+            if isinstance(value, GXByteBuffer):
+                self.set(value._data, index, count)
+                value.position = index + count
+            elif value and count != 0:
+                if self.size + count > self.capacity:
+                    self.capacity = self.size + count + self.__ARRAY_CAPACITY
+                self._data[self.size:self.size + count] = value[index:index + count]
+                self.size += count
+
+    def get(self, target):
+        len1 = len(target)
+        if self.size - self.position < len1:
+            raise ValueError("get")
+        index = 0
+        for index in range(0, len1):
+            target[index] = self._data[self.position]
+            self.position = self.position + 1
+
+    #
+    #      Compares, whether two given arrays are similar starting from current
+    #      position.
+    #
+    #      @param arr
+    #                 Array to compare.
+    # True, if arrays are similar.  False, if the arrays differ.
+    #
+    def compare(self, arr):
+        len1 = len(arr)
+        if not arr or (self.size - self.position < len1):
+            return False
+        bytes_ = bytearray(len1)
+        self.get(bytes_)
+        ret = arr == bytes_
+        if not ret:
+            self.position -= len1
+        return ret
+
+    #
+    #      Reverses the order of the given array.
+    #
+    def reverse(self):
+        first = self.position
+        last = self.size - 1
+        tmp = int()
+        while last > first:
+            tmp = self._data[last]
+            self._data[last] = self._data[first]
+            self._data[first] = tmp
+            last -= 1
+            first += 1
+
+    #
+    #      Push the given hex string as byte array into this buffer at the
+    #      current
+    #      position, and then increments the position.
+    #
+    #      @param value
+    #                 Byte array to add.
+    #      @param index
+    #                 Byte index.
+    #      @param count
+    #                 Byte count.
+    #
+    def setHexString(self, value, index=0, count=None):
+        tmp = self.hexToBytes(value)
+        if count is None:
+            count = len(tmp)
+        self.set(tmp, index, count)
+
+    def __str__(self):
+        return self._data[:self.size].hex(sep=' ')
+
+    #
+    #      Get remaining data.
+    #
+    # Remaining data as byte array.
+    #
+    def remaining(self):
+        return self.subArray(self.position, self.size - self.position)
+
+    #
+    #      Get remaining data as a hex string.
+    #
+    #      @param addSpace
+    #                 Add space between bytes.
+    # Remaining data as a hex string.
+    #
+    def remainingHexString(self, addSpace=True):
+        return self.hex(self._data, addSpace, self.position, self.size - self.position)
+
+    #
+    #      Get data as hex string.
+    #
+    #      @param addSpace
+    #                 Add space between bytes.
+    #      @param index
+    #                 Byte index.
+    #      @param count
+    #                 Byte count.
+    # Data as hex string.
+    #
+    def toHex(self, addSpace=True, index=0, count=None):
+        if count is None:
+            count = len(self) - index
+        return self.hex(self._data, addSpace, index, count)
+
+    #Convert char hex value to byte value.
+    @classmethod
+    def ___getValue(cls, c):
+        #Id char.
+        if c.islower():
+            c = c.upper()
+        pos = GXByteBuffer.__HEX_ARRAY.find(c)
+        if pos == -1:
+            raise Exception("Invalid hex string")
+        return pos
+
+    @classmethod
+    def hexToBytes(cls, value):
+        """Convert string to byte array.
+        value: Hex string.
+        Returns byte array.
+        """
+        buff = bytearray()
+        if value:
+            lastValue = -1
+            for ch in value:
+                if ch != ' ':
+                    if lastValue == -1:
+                        lastValue = cls.___getValue(ch)
+                    elif lastValue != -1:
+                        buff.append(lastValue << GXByteBuffer.__NIBBLE | cls.___getValue(ch))
+                        lastValue = -1
+                elif lastValue != -1:
+                    buff.append(cls.___getValue(ch))
+                    lastValue = -1
+        return buff
+
+    @classmethod
+    def hex(cls, value, addSpace=True, index=0, count=None):
+        """ Convert byte array to hex string. """
+        return value[index:count].hex(sep=' ' if addSpace else '')
+
+    def get_data(self) -> bytes:
+        return bytes(self._data)[:self.size]