ssz.sedes package

Submodules

ssz.sedes.base module

class ssz.sedes.base.BaseBitfieldCompositeSedes(*args, **kwds): Bases: BaseSedes[TSerializable, TDeserialized]

class ssz.sedes.base.BaseProperCompositeSedes(*args, **kwds)

Bases: BaseSedes[TSerializable, TDeserialized]

abstract property chunk_count: int | None

abstract property element_size_in_tree: int

abstract get_element_sedes(index: int) → BaseSedes

abstract property is_packing: bool

abstract serialize_element_for_tree(index: int, element: TSerializable) → bytes

class ssz.sedes.base.BaseSedes(*args, **kwds)

Bases: ABC, Generic[TSerializable, TDeserialized]

abstract deserialize(data: bytes) → TDeserialized

abstract get_fixed_size() → int

abstract get_hash_tree_root(value: TSerializable) → Hash32

abstract get_hash_tree_root_and_leaves(value: TSerializable, cache: CacheObj) → Tuple[Hash32, CacheObj]

abstract get_key(value: Any) → str

abstract get_sedes_id() → str

abstract property is_fixed_sized: bool

abstract serialize(value: TSerializable) → bytes

ssz.sedes.basic module

class ssz.sedes.basic.BasicSedes(size: int)

Bases: BaseSedes[TSerializable, TDeserialized]

get_fixed_size()

get_hash_tree_root(value: TSerializable) → Hash32

get_hash_tree_root_and_leaves(value: TSerializable, cache: CacheObj) → Tuple[Hash32, CacheObj]

get_key(value: Any) → str

is_fixed_sized = True

class ssz.sedes.basic.BitfieldCompositeSedes(*args, **kwds)

Bases: BaseBitfieldCompositeSedes[TSerializable, TDeserialized]

get_key(value: Any) → str

class ssz.sedes.basic.HomogeneousProperCompositeSedes(*args, **kwds)

Bases: ProperCompositeSedes[TSerializable, TDeserialized]

property chunk_count: int

get_sedes_id() → str

property is_packing: bool

class ssz.sedes.basic.ProperCompositeSedes(*args, **kwds)

Bases: BaseProperCompositeSedes[TSerializable, TDeserialized]

deserialize(data: bytes) → TDeserialized

property element_size_in_tree: int

get_key(value: Any) → str

serialize(value: TSerializable) → bytes

serialize_element_for_tree(index: int, element: TSerializable) → bytes

ssz.sedes.bitlist module

class ssz.sedes.bitlist.Bitlist(max_bit_count: int)

Bases: BitfieldCompositeSedes[Union[bytes, bytearray], bytes]

property chunk_count: int

deserialize(data: bytes) → Tuple[bool, ...]

get_fixed_size()

get_hash_tree_root(value: Sequence[bool]) → bytes

get_hash_tree_root_and_leaves(value: Sequence[bool], cache: CacheObj) → Tuple[Hash32, CacheObj]

get_sedes_id() → str

is_fixed_sized = False

serialize(value: Sequence[bool]) → bytes

ssz.sedes.bitlist.get_bitlist_len(x: int) → int

ssz.sedes.bitvector module

class ssz.sedes.bitvector.Bitvector(bit_count: int)

Bases: BitfieldCompositeSedes[Union[bytes, bytearray], bytes]

property chunk_count: int

deserialize(data: bytes) → bytes

get_fixed_size()

get_hash_tree_root(value: Sequence[bool]) → bytes

get_hash_tree_root_and_leaves(value: Sequence[bool], cache: CacheObj) → Tuple[Hash32, CacheObj]

get_sedes_id() → str

is_fixed_sized = True

serialize(value: Sequence[bool]) → bytes

ssz.sedes.boolean module

class ssz.sedes.boolean.Bit: Bases: Boolean

class ssz.sedes.boolean.Boolean

Bases: BasicSedes[bool, bool]

deserialize(data: bytes) → bool

get_sedes_id() → str

serialize(value: bool) → bytes

ssz.sedes.byte module

class ssz.sedes.byte.Byte

Bases: BasicSedes[bytes, bytes]

deserialize(data: bytes) → bytes

get_sedes_id() → str

serialize(value: bytes) → bytes

size = 1

ssz.sedes.byte_list module

class ssz.sedes.byte_list.ByteList(max_length: int)

Bases: List[Union[bytes, bytearray], bytes]

Equivalent to List(byte, size) but more convenient & efficient.

When encoding a series of bytes, List(byte, …) requires an awkward input shaped like: (b'A', b'B', b'C'). ByteList accepts a simple bytes object like b'ABC' for encoding.

deserialize(data: bytes) → bytes

get_hash_tree_root(value: bytes) → bytes

get_sedes_id() → str

serialize(value: bytes | bytearray) → bytes

serialize_element_for_tree(index: int, byte_value: int) → bytes

ssz.sedes.byte_vector module

class ssz.sedes.byte_vector.ByteVector(size: int)

Bases: Vector[Union[bytes, bytearray], bytes]

Equivalent to Vector(byte, size) but more efficient.

deserialize(data: bytes) → bytes

get_hash_tree_root(value: bytes) → bytes

get_hash_tree_root_and_leaves(value: bytes, cache: CacheObj) → Tuple[Hash32, CacheObj]

get_sedes_id() → str

serialize(value: bytes | bytearray) → bytes

serialize_element_for_tree(index: int, byte_value: int) → bytes

ssz.sedes.container module

class ssz.sedes.container.Container(field_sedes: Sequence[BaseSedes[Any, Any]])

Bases: ProperCompositeSedes[Sequence[Any], Tuple[Any, …]]

property chunk_count: int

deserialize_fixed_size_parts(stream: IO[bytes]) → Iterable[Tuple[Tuple[Any], Tuple[int, BaseSedes[Any, Any]]]]

deserialize_variable_size_parts(offset_pairs: Tuple[Tuple[int, BaseSedes[Any, Any]], ...], stream: IO[bytes]) → Iterable[Any]

get_element_sedes(index: int) → BaseSedes

get_fixed_size()

get_hash_tree_root(value: Tuple[Any, ...]) → bytes

get_hash_tree_root_and_leaves(value: Tuple[Any, ...], cache: CacheObj) → Tuple[Hash32, CacheObj]

get_sedes_id() → str

property is_fixed_sized

property is_packing: bool

serialize(value) → bytes

ssz.sedes.list module

class ssz.sedes.list.List(element_sedes: BaseSedes[Any, Any], max_length: int)

Bases: HomogeneousProperCompositeSedes[Sequence[TSerializable], Tuple[TDeserialized, …]]

get_element_sedes(index) → BaseSedes[TSerializable, TDeserialized]

get_fixed_size()

get_hash_tree_root(value: Iterable[TSerializable]) → bytes

get_hash_tree_root_and_leaves(value: TSerializable, cache: CacheObj) → Tuple[Hash32, CacheObj]

is_fixed_sized = False

ssz.sedes.serializable module

class ssz.sedes.serializable.BaseSerializable(*args, cache=None, **kwargs)

Bases: Sequence

as_dict()

cache = None

copy(*args, **kwargs)

get_key() → bytes

classmethod get_sedes_id() → str

property hash_tree_root

reset_cache()

class ssz.sedes.serializable.Meta(has_fields, fields, container_sedes, field_names, field_attrs)

Bases: tuple

container_sedes: Container | None: Alias for field number 2

field_attrs: Tuple[str, ...] | None: Alias for field number 4

field_names: Tuple[str, ...] | None: Alias for field number 3

fields: Tuple[Tuple[str, BaseSedes], ...] | None: Alias for field number 1

has_fields: bool: Alias for field number 0

class ssz.sedes.serializable.MetaSerializable(name, bases, namespace)

Bases: ABCMeta

deserialize(data: bytes) → TSerializable

get_fixed_size()

get_hash_tree_root(value: TSerializable, cache: bool = True) → bytes

property is_fixed_sized

serialize(value: TSerializable) → bytes

class ssz.sedes.serializable.Serializable(*args, cache=None, **kwargs)

Bases: BaseSerializable

The base class for serializable objects.

ssz.sedes.serializable.make_immutable(value)

ssz.sedes.serializable.merge_args_to_kwargs(args, kwargs, arg_names)

ssz.sedes.serializable.merge_kwargs_to_args(args, kwargs, arg_names)

ssz.sedes.serializable.validate_args_and_kwargs(args, kwargs, arg_names)

ssz.sedes.signed_serializable module

class ssz.sedes.signed_serializable.MetaSignedSerializable(name, bases, namespace): Bases: MetaSerializable

class ssz.sedes.signed_serializable.SignedMeta(has_fields, fields, container_sedes, signed_container_sedes, field_names, field_attrs)

Bases: tuple

container_sedes: Container | None: Alias for field number 2

field_attrs: Tuple[str, ...] | None: Alias for field number 5

field_names: Tuple[str, ...] | None: Alias for field number 4

fields: Tuple[Tuple[str, BaseSedes]] | None: Alias for field number 1

has_fields: bool: Alias for field number 0

signed_container_sedes: Container | None: Alias for field number 3

class ssz.sedes.signed_serializable.SignedSerializable(*args, cache=None, **kwargs)

Bases: BaseSerializable

property signing_root

ssz.sedes.uint module

class ssz.sedes.uint.UInt(num_bits: int)

Bases: BasicSedes[int, int]

deserialize(data: bytes) → int

get_sedes_id() → str

serialize(value: int) → bytes

ssz.sedes.vector module

class ssz.sedes.vector.Vector(element_sedes: BaseSedes[Any, Any], length: int)

Bases: HomogeneousProperCompositeSedes[Sequence[TSerializable], Tuple[TDeserialized, …]]

get_element_sedes(index) → BaseSedes[TSerializable, TDeserialized]

get_fixed_size() → int

get_hash_tree_root(value: Sequence[Any]) → bytes

get_hash_tree_root_and_leaves(value: Sequence[Any], cache: CacheObj) → Tuple[Hash32, CacheObj]

property is_fixed_sized: bool

property length: int

Module contents

ssz.sedes.infer_sedes(value): Try to find a sedes objects suitable for a given Python object.