PR feedbacke

ssz/sedes/base.py

@@ -102,7 +102,7 @@ class BaseCompositeSedes(BaseSedes[TSerializable, TDeserialized]):
     pass
 
 
-def _compute_section_0_size(element_sedes: Iterable[TSedes]) -> int:
+def _compute_fixed_size_section_length(element_sedes: Iterable[TSedes]) -> int:
     return sum(
         sedes.get_fixed_size() if sedes.is_fixed_sized else constants.OFFSET_SIZE
         for sedes in element_sedes
@@ -128,27 +128,27 @@ def serialize(self, value: Sequence[TSerializable]) -> bytes:
         pairs = self._get_item_sedes_pairs(value)
         element_sedes = tuple(sedes for element, sedes in pairs)
 
-        section_0_size = _compute_section_0_size(element_sedes)
+        fixed_size_section_length = _compute_fixed_size_section_length(element_sedes)
 
-        section_1_components = tuple(
+        variable_size_section_parts = tuple(
             sedes.serialize(item)
             for item, sedes
             in pairs
             if not sedes.is_fixed_sized
         )
 
-        if section_1_components:
+        if variable_size_section_parts:
             offsets = tuple(accumulate(
                 operator.add,
-                map(len, section_1_components[:-1]),
-                section_0_size,
+                map(len, variable_size_section_parts[:-1]),
+                fixed_size_section_length,
             ))
         else:
             offsets = ()
 
         offsets_iter = iter(offsets)
 
-        section_0_components = tuple(
+        fixed_size_section_parts = tuple(
             sedes.serialize(item) if sedes.is_fixed_sized else encode_offset(next(offsets_iter))
             for item, sedes
             in pairs
@@ -162,8 +162,8 @@ def serialize(self, value: Sequence[TSerializable]) -> bytes:
             raise DeserializationError("Did not consume all offsets while decoding value")
 
         return b"".join(concatv(
-            section_0_components,
-            section_1_components,
+            fixed_size_section_parts,
+            variable_size_section_parts,
         ))
 
     def deserialize(self, data: bytes) -> TDeserialized:

ssz/sedes/container.py

@@ -75,9 +75,9 @@ def _validate_serializable(self, value: Sequence[Any]) -> bytes:
     #
     # Deserialization
     #
-    def deserialize_section_0(self,
-                              stream: IO[bytes],
-                              ) -> Iterable[Tuple[Tuple[Any], Tuple[int, TSedes]]]:
+    def deserialize_fixed_size_parts(self,
+                                     stream: IO[bytes],
+                                     ) -> Iterable[Tuple[Tuple[Any], Tuple[int, TSedes]]]:
         fixed_items_and_offets = _deserialize_fixed_size_items_and_offsets(
             stream,
             self.field_sedes,
@@ -97,9 +97,9 @@ def deserialize_section_0(self,
         return fixed_size_values, offset_pairs
 
     @to_tuple
-    def deserialize_section_1(self,
-                              offset_pairs: Tuple[Tuple[int, TSedes], ...],
-                              stream: IO[bytes]) -> Iterable[Any]:
+    def deserialize_variable_size_parts(self,
+                                        offset_pairs: Tuple[Tuple[int, TSedes], ...],
+                                        stream: IO[bytes]) -> Iterable[Any]:
         offsets, fields = zip(*offset_pairs)
 
         *head_fields, last_field = fields
@@ -118,36 +118,36 @@ def _deserialize_stream(self, stream: IO[bytes]) -> Tuple[Any, ...]:
             # https://github.com/ethereum/eth2.0-specs/issues/854 is resolved
             return tuple()
 
-        fixed_size_values, offset_pairs = self.deserialize_section_0(stream)
+        fixed_size_values, offset_pairs = self.deserialize_fixed_size_parts(stream)
 
         if not offset_pairs:
             return fixed_size_values
 
-        dynamic_size_values = self.deserialize_section_1(offset_pairs, stream)
+        variable_size_values = self.deserialize_variable_size_parts(offset_pairs, stream)
 
-        section_0_iter = iter(fixed_size_values)
-        section_1_iter = iter(dynamic_size_values)
+        fixed_size_parts_iter = iter(fixed_size_values)
+        variable_size_parts_iter = iter(variable_size_values)
 
         value = tuple(
-            next(section_0_iter) if sedes.is_fixed_sized else next(section_1_iter)
+            next(fixed_size_parts_iter) if sedes.is_fixed_sized else next(variable_size_parts_iter)
             for sedes
             in self.field_sedes
         )
 
-        # Verify that bothe iterables have been fully consumed.
+        # Verify that both iterables have been fully consumed.
         try:
-            next(section_0_iter)
+            next(fixed_size_parts_iter)
         except StopIteration:
             pass
         else:
             raise DeserializationError("Did not consume all fixed size values")
 
         try:
-            next(section_1_iter)
+            next(variable_size_parts_iter)
         except StopIteration:
             pass
         else:
-            raise DeserializationError("Did not consume all dynamic size values")
+            raise DeserializationError("Did not consume all variable size values")
 
         return value
 

ssz/sedes/list.py

@@ -15,6 +15,9 @@
     sliding_window,
 )
 
+from ssz.constants import (
+    OFFSET_SIZE,
+)
 from ssz.exceptions import (
     DeserializationError,
     SerializationError,
@@ -98,12 +101,13 @@ def _deserialize_stream(self, stream: IO[bytes]) -> Iterable[TElement]:
                 return
 
             num_remaining_offset_bytes = first_offset - stream.tell()
-            if num_remaining_offset_bytes % 4 != 0:
+            if num_remaining_offset_bytes % OFFSET_SIZE != 0:
                 raise DeserializationError(
-                    f"Offset bytes was not a multiple of 4.  Got {num_remaining_offset_bytes}"
+                    f"Offset bytes was not a multiple of {OFFSET_SIZE}.  Got "
+                    f"{num_remaining_offset_bytes}"
                 )
 
-            num_remaining_offsets = num_remaining_offset_bytes // 4
+            num_remaining_offsets = num_remaining_offset_bytes // OFFSET_SIZE
             tail_offsets = tuple(s_decode_offset(stream) for _ in range(num_remaining_offsets))
 
             offsets = tuple(cons(first_offset, tail_offsets))