Bytearray API:

Module shared_atomic

class shared_atomic.atomic_bytearray. atomic_bytearray ( initial : bytes , mode : unicode = 'singleprocessing' , length : int = None , paddingdirection : unicode = 'right' , paddingbytes : bytes = b'\x00' , trimming_direction : unicode = 'right' , windows_unix_compatibility : bool = False )

bytearray provide atomic operations, the bytearray should be no longer than 8 bytes :attributes

encoding: readonly string character set size: readonly size of the array initial_length: readonly initial input length value: read/write value of the bytearray int_value: readonly int value reference: readonly pointer to the backend array mode: readonly ‘s’ for single process, ‘m’ for multiprocessing, on windows platform, only singleprocessing is supported

constructor to initialize the bytearray, the bytearray should be no longer than 8 bytes

Parameters

• initial – initial value of the bytearray, if the initial value is longer than 8 bytes, please specify the trimming target length, or else it would fail.

• mode – the mode in which the bytearray will be shared. ‘singleprocessing’ or ‘s’ for single process, ‘multiprocessing’ or ‘m’ for multiprocessing, on windows platform, only singleprocessing is supported, setting it to ‘m’ or ‘multiprocessing’ will be ignored.

• length – the expected length after padding/trimming for the input value, if not specified, no padding or trimming performed, use original value.

• paddingdirection – right, or left side the padding bytes would be added if not specified, pad to the right side, use ‘right’ or ‘r’ to specify right side, use ‘left’ or ‘l’ to specify the left side.

• paddingbytes – bytes to pad to the original bytes, by default b’\0’ can be multiple bytes like b’ab’, will be padded to the original bytes in circulation until the expected length is reached.

• trimming_direction – if initial bytes are longer, on which side the bytes will be trimmed. By default, on the right side, use ‘right’ or ‘r’ to specify right side, use ‘left’ or ‘l’ to specify the left side.

• windows_unix_compatibility – whether the source code should be compatible with windows x64

array_add_and_fetch ( n : bytes , trim = True ) → bytes

Increment and fetch atomically

Parameters

• n – bytes will be added to the array.

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the contents of resulted bytearray

array_and_and_fetch ( n : bytes , trim = True ) → bytes

Bitwise AND and fetch the result atomically

Parameters

• n – the other operand of AND operation.

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the contents of resulted bytearray

array_compare_and_set ( i : self_atomic_bytearray , n : bytes ) → bool

Compare and set atomically,This compares the contents of self with the contents of i. If equal, the operation is a read-modify-write operation that writes n into self. If they are not equal, the operation is a read and the current contents of itself are written into i.

Parameters

• i – the bytearray to be compared with

• n – another bytes to be ready to set to self if comparision return True

Returns

if self is equal to i return True, else return False

array_compare_and_set_value ( i : bytes , n : bytes , trim = True ) → bytes

Compare and swap atomically, This compares the contents of self with the contents of n. If equal, the operation is a read-modify-write operation that writes n into self. If they are not equal, No operation will be performed.

Parameters

• i – exchange value

• n – The value to be compared with

• trim – whether the returned bytes should be trimmed of tailing b’\0’

Returns

the initial value of the self

array_fetch_and_add ( n : bytes , trim = True ) → bytes

fetch and increment atomically

Parameters

• n – the bytes will be added to the array

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the original contents of the bytearray

array_fetch_and_and ( n : bytes , trim = True ) → bytes

Fetch then bitwise AND atomically

Parameters

• n – the other operands of AND operation

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the original contents of the bytearray

array_fetch_and_nand ( n : bytes , trim = True ) → bytes

fetch then bitwise NAND(AND first then NOT) atomically

Parameters

• n – the other operands of NAND operation

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the original contents of the bytearray

array_fetch_and_or ( n : bytes , trim = True ) → bytes

Fetch then bitwise OR atomically

Parameters

• n – the other operands of OR operation

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the original contents of the bytearray

array_fetch_and_sub ( n : bytes , trim = True ) → bytes

fetch and decrement atomically

Parameters

• n – the bytes will be substracted from the array

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the original contents of the bytearray

array_fetch_and_xor ( n : bytes , trim = True ) → bytes

Fetch then bitwise XOR atomically

Parameters

• n – the other operands of XOR operation

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the original contents of the bytearray

array_get_and_set ( data : bytes , trim = True ) → bytes

Get and set atomically

Parameters

• data – new data

• trim – whether of not to trim the returning b’\0’ when get, default True

Returns

the original bytes

array_nand_and_fetch ( n : bytes , trim = True ) → bytes

bitsise NAND(AND first then NOT) and fetch the result atomically

:param n:the other operand of NAND operation :param trim: whether of not to trim the returning b’\0’ when fetch, default True :return: the contents of resulted bytearray

array_or_and_fetch ( n : bytes , trim = True ) → bytes

bitsise OR and fetch the result atomically

Parameters

• n – the other operand of OR operation

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the contents of resulted bytearray

array_shift ( i : self_atomic_bytearray , j : self_atomic_bytearray )

Value exchange between 3 bytearrays in 2 groups atomically, the initial_length field will be updated but not atomically. store i in itself after store itself in j

Parameters

• i – one atomic_bytearray

• j – another atomic_bytearray

Returns

None

array_store ( i : self_atomic_bytearray )

Atomically store contents from another bytearray to this bytearray, if the other bytearray is different with this one in size , the function will fail.

Parameters

i – another bytearray to store its value to self

Returns

None

array_sub_and_fetch ( n : bytes , trim = True ) → bytes

Decrement and fetch atomically

Parameters

• n – bytes will be subtracted from the array.

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the contents of resulted bytearray

array_xor_and_fetch ( n : bytes , trim = True ) → bytes

bitsise XOR and fetch the result atomically

Parameters

• n – the other operand of XOR operation

• trim – whether of not to trim the returning b’\0’ when fetch, default True

Returns

the contents of resulted bytearray

change_mode ( newmode = 'm' , windows_unix_compatibility : bool = False )

Switch between singleprocessing mode and multiprocessing mode, the contents will be copied , other threads/processes would not be aware of the change.

Parameters

• newmode – the mode to change to, ‘m’ for multiproessing, ‘s’ for singleprocessing. default ‘m’

• windows_unix_compatibility – if change to multiprocessing mode, whether the source code should be compatible with windows x64

Returns

None

get_bytes ( trim = True ) → bytes

Get all the bytes from the bytearray atomically :param trim: if True, the leading b’\0’ would be trimmed, by default: True

Returns

all the bytes in the bytearray

get_int ( ) → size_t

Get the integer representation from the bytearray, the whole array would be treated as a large integer

Returns

the integer representation

property int_value : size_t

same with get_int

resize ( newlength : char , paddingdirection : unicode = 'right' , paddingbytes : bytes = b'\x00' , trimming_direction : unicode = 'right' )

trim or pad the original contents in the bytearray to a new length, the new length should be no longer than 8 bytes, the original array wll be replaced with new array, which is only valid in the master process/thread

Parameters

• newlength – the expected new length of the original bytes.

• paddingdirection – if longer than original, left or right sidethe original bytes should be padded, by default right side,use ‘right’ or ‘r’ to specify right side, use ‘left’ or ‘l’ to specify the left side.

• paddingbytes – bytes to pad to the original bytes, by default b’\0’ can be multiple bytes like b’ab’, will be padded to the original bytes in circulation until the expected length is reached.

• trimming_direction – if shorted than original, left or right side the original bytes should be padded,use ‘right’ or ‘r’ to specify right side,use ‘left’ or ‘l’ to specify the left side.

Returns

None

set_bytes ( data : bytes )

Set the value in the bytearray, if the new data is longer than the original size of the array. it will expand the array accordingly which only could be used in the master process/thread the size of the bytearray can be check with self.size

Parameters

data – input bytearray

Returns

None

property value

same with get_bytes without trimming and set_bytes