cbytesparse.c.bytesparse

class cbytesparse.c.bytesparse(start: Address | None = None, *args: Any, endex: Address | None = None)

Wrapper for more bytearray compatibility.

Please refer to cbytesparse.py.bytesparse for more information.

Methods

__init__

append

append_backup

append_restore

block_span

blocks

bound

clear

clear_backup

clear_restore

collapse_blocks

content_blocks

content_items

content_keys

content_values

copy

count

crop

crop_backup

crop_restore

cut

delete

delete_backup

delete_restore

equal_span

extend

extend_backup

extend_restore

extract

fill

fill_backup

fill_restore

find

flood

flood_backup

flood_restore

from_blocks

from_bytes

from_items

from_memory

from_values

fromhex

gaps

get

hex

index

insert

insert_backup

insert_restore

intervals

items

keys

peek

poke

poke_backup

poke_restore

pop

pop_backup

pop_restore

popitem

popitem_backup

popitem_restore

read

readinto

remove

remove_backup

remove_restore

reserve

reserve_backup

reserve_restore

reverse

rfind

rindex

rvalues

setdefault

setdefault_backup

setdefault_restore

shift

shift_backup

shift_restore

to_blocks

to_bytes

update

update_backup

update_restore

validate

values

view

write

write_backup

write_restore

Attributes

bound_endex

bound_span

bound_start

content_endex

content_endin

content_parts

content_size

content_span

content_start

contiguous

endex

endin

span

start

__add__(value, /)

Return self+value.

__bool__()

True if self else False

__bytes__()
__contains__(key, /)

Return key in self.

__copy__()
__deepcopy__()
__delitem__(key, /)

Delete self[key].

__eq__(value, /)

Return self==value.

__ge__(value, /)

Return self>=value.

__getitem__(key, /)

Return self[key].

__gt__(value, /)

Return self>value.

__hash__ = None
__iadd__(value, /)

Return self+=value.

__imul__(value, /)

Return self*=value.

__init__(*args, **kwargs)
__iter__()

Implement iter(self).

__le__(value, /)

Return self<=value.

__len__()

Return len(self).

__lt__(value, /)

Return self<value.

__mul__(value, /)

Return self*value.

__ne__(value, /)

Return self!=value.

__new__(**kwargs)
__radd__(value, /)

Return value+self.

__reduce__()

bytesparse.__reduce_cython__(self)

__repr__()

Return repr(self).

__reversed__()
__rmul__(value, /)

Return value*self.

__setitem__(key, value, /)

Set self[key] to value.

__setstate__()

bytesparse.__setstate_cython__(self, __pyx_state)

__sizeof__()
__str__()

Return str(self).

_block_index_at(address)
_block_index_endex(address)
_block_index_start(address)
_prebound_endex(start_min, size)
_prebound_endex_backup(start_min, size)
_prebound_start(endex_max, size)
_prebound_start_backup(endex_max, size)
_rectify_address(address)
_rectify_span(start, endex)
append(item)
append_backup()
append_restore()
block_span(address)
blocks(start, endex)
bound(start, endex)
clear(start, endex)
clear_backup(start, endex)
clear_restore(backup)
classmethod collapse_blocks(blocks)
content_blocks(block_index_start, block_index_endex, block_index_step)
content_items(start, endex)
content_keys(start, endex)
content_values(start, endex)
copy()
count(item, start, endex)
crop(start, endex)
crop_backup(start, endex)
crop_restore(backup_start, backup_endex)
cut(start, endex, bound)
delete(start, endex)
delete_backup(start, endex)
delete_restore(backup)
equal_span(address)
extend(items, offset)
extend_backup(offset)
extend_restore(content_endex)
extract(start, endex, pattern, step, bound)
fill(start, endex, pattern)
fill_backup(start, endex)
fill_restore(backup)
find(item, start, endex)
flood(start, endex, pattern)
flood_backup(start, endex)
flood_restore(gaps)
classmethod from_blocks(blocks, offset, start, endex, copy, validate)
classmethod from_bytes(data, offset, start, endex, copy, validate)
classmethod from_items(items, offset, start, endex, validate)
classmethod from_memory(memory, offset, start, endex, copy, validate)
classmethod from_values(values, offset, start, endex, validate)
classmethod fromhex(string)
gaps(start, endex)
get(address, default)
hex(*args)
index(item, start, endex)
insert(address, data)
insert_backup(address, data)
insert_restore(address, backup)
intervals(start, endex)
items(start, endex, pattern)
keys(start, endex)
peek(address)
poke(address, item)
poke_backup(address)
poke_restore(address, item)
pop(address, default)
pop_backup(address)
pop_restore(address, item)
popitem()
popitem_backup()
popitem_restore(address, item)
read(address, size)
readinto(address, buffer)
remove(item, start, endex)
remove_backup(item, start, endex)
remove_restore(backup)
reserve(address, size)
reserve_backup(address, size)
reserve_restore(address, backup)
reverse()
rfind(item, start, endex)
rindex(item, start, endex)
rvalues(start, endex, pattern)
setdefault(address, default)
setdefault_backup(address)
setdefault_restore(address, item)
shift(offset)
shift_backup(offset)
shift_restore(offset, backup)
to_blocks(start, endex)
to_bytes(start, endex)
update(data, clear, **kwargs)
update_backup(data, clear, **kwargs)
update_restore(backups)
validate()
values(start, endex, pattern)
view(start, endex)
write(address, data, clear)
write_backup(address, data, clear)
write_restore(backups)