Bytes#

Added in version 2.32.

class Bytes(**kwargs)#

A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin.

The purpose of a Bytes is to keep the memory region that it holds alive for as long as anyone holds a reference to the bytes. When the last reference count is dropped, the memory is released. Multiple unrelated callers can use byte data in the Bytes without coordinating their activities, resting assured that the byte data will not change or move while they hold a reference.

A Bytes can come from many different origins that may have different procedures for freeing the memory region. Examples are memory from malloc(), from memory slices, from a MappedFile or memory from other allocators.

Bytes work well as keys in HashTable. Use equal() and hash() as parameters to new() or new_full(). Bytes can also be used as keys in a Tree by passing the compare() function to new().

The data pointed to by this bytes must not be modified. For a mutable array of bytes see GByteArray. Use unref_to_array() to create a mutable array for a Bytes sequence. To create an immutable Bytes from a mutable GByteArray, use the free_to_bytes() function.

Constructors#

class Bytes
classmethod new(data: list[int] | None = None) → Bytes#

Creates a new Bytes from data.

data is copied. If size is 0, data may be None.

Added in version 2.32.

Parameters:

data – the data to be used for the bytes

classmethod new_take(data: list[int] | None = None) → Bytes#

Creates a new Bytes from data.

After this call, data belongs to the Bytes and may no longer be modified by the caller. The memory of data has to be dynamically allocated and will eventually be freed with free().

For creating Bytes with memory from other allocators, see new_with_free_func().

data may be None if size is 0.

Added in version 2.32.

Parameters:

data – the data to be used for the bytes

Methods#

class Bytes
compare(bytes2: Bytes) → int#

Compares the two Bytes values.

This function can be used to sort GBytes instances in lexicographical order.

If bytes1 and bytes2 have different length but the shorter one is a prefix of the longer one then the shorter one is considered to be less than the longer one. Otherwise the first byte where both differ is used for comparison. If bytes1 has a smaller value at that position it is considered less, otherwise greater than bytes2.

Added in version 2.32.

Parameters:

bytes2 – a pointer to a Bytes to compare with bytes1

equal(bytes2: Bytes) → bool#

Compares the two Bytes values being pointed to and returns True if they are equal.

This function can be passed to new() as the key_equal_func parameter, when using non-None Bytes pointers as keys in a HashTable.

Added in version 2.32.

Parameters:

bytes2 – a pointer to a Bytes to compare with bytes1

get_data() → list[int] | None#

Get the byte data in the Bytes. This data should not be modified.

This function will always return the same pointer for a given Bytes.

None may be returned if size is 0. This is not guaranteed, as the Bytes may represent an empty string with data non-None and size as 0. None will not be returned if size is non-zero.

Added in version 2.32.

get_region(element_size: int, offset: int, n_elements: int) → Any | None#

Gets a pointer to a region in bytes.

The region starts at offset many bytes from the start of the data and contains n_elements many elements of element_size size.

n_elements may be zero, but element_size must always be non-zero. Ideally, element_size is a static constant (eg: sizeof a struct).

This function does careful bounds checking (including checking for arithmetic overflows) and returns a non-None pointer if the specified region lies entirely within the bytes. If the region is in some way out of range, or if an overflow has occurred, then None is returned.

Note: it is possible to have a valid zero-size region. In this case, the returned pointer will be equal to the base pointer of the data of bytes, plus offset. This will be non-None except for the case where bytes itself was a zero-sized region. Since it is unlikely that you will be using this function to check for a zero-sized region in a zero-sized bytes, None effectively always means “error”.

Added in version 2.70.

Parameters:

  • element_size – a non-zero element size

  • offset – an offset to the start of the region within the bytes

  • n_elements – the number of elements in the region

get_size() → int#

Get the size of the byte data in the Bytes.

This function will always return the same value for a given Bytes.

Added in version 2.32.

hash() → int#

Creates an integer hash code for the byte data in the Bytes.

This function can be passed to new() as the key_hash_func parameter, when using non-None Bytes pointers as keys in a HashTable.

Added in version 2.32.

new_from_bytes(offset: int, length: int) → Bytes#

Creates a Bytes which is a subsection of another Bytes. The offset + length may not be longer than the size of bytes.

A reference to bytes will be held by the newly created Bytes until the byte data is no longer needed.

Since 2.56, if offset is 0 and length matches the size of bytes, then bytes will be returned with the reference count incremented by 1. If bytes is a slice of another Bytes, then the resulting Bytes will reference the same Bytes instead of bytes. This allows consumers to simplify the usage of Bytes when asynchronously writing to streams.

Added in version 2.32.

Parameters:

  • offset – offset which subsection starts at

  • length – length of subsection