Renaming get_fn_needs_length to the more accurate read_fn_needs_length.

scott-griffiths · scott-griffiths · commit 18d9ed9a3a95 · 2024-01-15T16:59:50.000Z
diff --git a/bitstring/__init__.py b/bitstring/__init__.py
@@ -199,13 +199,13 @@ def bool_bits2chars(bitlength: Literal[1]):
                     multiplier=8, description="a bytes object"),
     # Unknown length types
     DtypeDefinition('se', Bits._setse, Bits._getse, int, True, None,
-                    get_fn_needs_length=False, description="a signed exponential-Golomb code"),
+                    read_fn_needs_length=False, description="a signed exponential-Golomb code"),
     DtypeDefinition('ue', Bits._setue, Bits._getue, int, False, None,
-                    get_fn_needs_length=False, description="an unsigned exponential-Golomb code"),
+                    read_fn_needs_length=False, description="an unsigned exponential-Golomb code"),
     DtypeDefinition('sie', Bits._setsie, Bits._getsie, int, True, None,
-                    get_fn_needs_length=False, description="a signed interleaved exponential-Golomb code"),
+                    read_fn_needs_length=False, description="a signed interleaved exponential-Golomb code"),
     DtypeDefinition('uie', Bits._setuie, Bits._getuie, int, False, None,
-                    get_fn_needs_length=False, description="an unsigned interleaved exponential-Golomb code"),
+                    read_fn_needs_length=False, description="an unsigned interleaved exponential-Golomb code"),
     # Special case pad type
     DtypeDefinition('pad', Bits._setpad, Bits._getpad, None, False, None,
                     description="a skipped section of padding"),
diff --git a/bitstring/bits.py b/bitstring/bits.py
@@ -1191,20 +1191,20 @@ def _read_dtype_list(self, dtypes: List[Dtype], pos: int) -> Tuple[List[Union[in
         has_stretchy_token = False
         bits_after_stretchy_token = 0
         for dtype in dtypes:
-            stretchy = dtype.bitlength is None and dtype.get_fn_needs_length
+            stretchy = dtype.bitlength is None and dtype.read_fn_needs_length
             if stretchy:
                 if has_stretchy_token:
                     raise bitstring.Error("It's not possible to have more than one 'filler' token.")
                 has_stretchy_token = True
             elif has_stretchy_token:
-                if not dtype.get_fn_needs_length:
+                if not dtype.read_fn_needs_length:
                     raise bitstring.Error(f"It's not possible to parse a variable length token '{dtype}' after a 'filler' token.")
                 bits_after_stretchy_token += dtype.bitlength
 
         # We should have precisely zero or one stretchy token
         vals = []
         for dtype in dtypes:
-            stretchy = dtype.bitlength is None and dtype.get_fn_needs_length
+            stretchy = dtype.bitlength is None and dtype.read_fn_needs_length
             if stretchy:
                 bits_remaining = len(self) - pos
                 # Set length to the remaining bits
@@ -1660,9 +1660,9 @@ def _pp(self, dtype1: Dtype, dtype2: Optional[Dtype], bits_per_group: int, width
         colour = Colour(bitstring.options.colourful_prettyprinting)
         name1 = dtype1.name
         name2 = dtype2.name if dtype2 is not None else None
-        if not dtype1.get_fn_needs_length:
+        if not dtype1.read_fn_needs_length:
             raise ValueError(f"Can't use Dtype '{dtype1}' in pp() as it has an unknown length.")
-        if dtype2 is not None and not dtype2.get_fn_needs_length:
+        if dtype2 is not None and not dtype2.read_fn_needs_length:
             raise ValueError(f"Can't use Dtype '{dtype1}' in pp() as it has an unknown length.")
         offset_width = 0
         offset_sep = ' :' if lsb0 else ': '
diff --git a/bitstring/bitstream.py b/bitstring/bitstream.py
@@ -356,7 +356,7 @@ def read(self, fmt: Union[int, str, Dtype]) -> Union[int, float, str, Bits, bool
             self._pos += fmt
             return bs
         dtype = bitstring.dtypes.Dtype(fmt)
-        if dtype.bitlength is None and dtype.get_fn_needs_length:
+        if dtype.bitlength is None and dtype.read_fn_needs_length:
             # No length specified? Try again, but read to end.
             bitlength = len(self) - self._pos
             items, remainder = divmod(bitlength, dtype.bits_per_item)
diff --git a/bitstring/dtypes.py b/bitstring/dtypes.py
@@ -11,7 +11,7 @@
 
 class Dtype:
 
-    __slots__ = ('read_fn', 'name', 'set_fn', 'get_fn', 'return_type', 'is_signed', 'set_fn_needs_length', 'get_fn_needs_length', 'bitlength', 'bits_per_item', 'length')
+    __slots__ = ('read_fn', 'name', 'set_fn', 'get_fn', 'return_type', 'is_signed', 'set_fn_needs_length', 'read_fn_needs_length', 'bitlength', 'bits_per_item', 'length')
 
     def __new__(cls, token: Union[str, Dtype, None] = None, /, length: Optional[int] = None) -> Dtype:
         if isinstance(token, cls):
@@ -42,8 +42,8 @@ def create(cls, definition: DtypeDefinition, length: Optional[int]) -> Dtype:
         if x.bitlength is not None:
             x.bitlength *= x.bits_per_item
         x.set_fn_needs_length = definition.set_fn_needs_length
-        x.get_fn_needs_length = definition.get_fn_needs_length
-        if not x.get_fn_needs_length or len(dtype_register.names[x.name].allowed_lengths) == 1:
+        x.read_fn_needs_length = definition.read_fn_needs_length
+        if not x.read_fn_needs_length or len(dtype_register.names[x.name].allowed_lengths) == 1:
             x.read_fn = definition.read_fn
         else:
             x.read_fn = functools.partial(definition.read_fn, length=x.bitlength)
@@ -60,12 +60,12 @@ def create(cls, definition: DtypeDefinition, length: Optional[int]) -> Dtype:
         return x
 
     def __str__(self) -> str:
-        hide_length = not self.get_fn_needs_length or len(dtype_register.names[self.name].allowed_lengths) == 1 or self.length is None
+        hide_length = not self.read_fn_needs_length or len(dtype_register.names[self.name].allowed_lengths) == 1 or self.length is None
         length_str = '' if hide_length else str(self.length)
         return f"{self.name}{length_str}"
 
     def __repr__(self) -> str:
-        hide_length = not self.get_fn_needs_length or len(dtype_register.names[self.name].allowed_lengths) == 1 or self.length is None
+        hide_length = not self.read_fn_needs_length or len(dtype_register.names[self.name].allowed_lengths) == 1 or self.length is None
         length_str = '' if hide_length else ', ' + str(self.length)
         return f"{self.__class__.__name__}('{self.name}{length_str}')"
 
@@ -103,7 +103,7 @@ class DtypeDefinition:
     # Represents a class of dtypes, such as uint or float, rather than a concrete dtype such as uint8.
 
     def __init__(self, name: str, set_fn, get_fn, return_type: Any = Any, is_signed: bool = False, bitlength2chars_fn = None,
-                 get_fn_needs_length: bool = True, allowed_lengths: Tuple[int, ...] = tuple(), multiplier: int = 1, description: str = ''):
+                 read_fn_needs_length: bool = True, allowed_lengths: Tuple[int, ...] = tuple(), multiplier: int = 1, description: str = ''):
 
         # Consistency checks
         # if not set_fn_needs_length and allowed_lengths:
@@ -115,7 +115,7 @@ def __init__(self, name: str, set_fn, get_fn, return_type: Any = Any, is_signed:
         self.description = description
         self.return_type = return_type
         self.is_signed = is_signed
-        self.get_fn_needs_length = get_fn_needs_length
+        self.read_fn_needs_length = read_fn_needs_length
         self.allowed_lengths = AllowedLengths(allowed_lengths)
 
         self.multiplier = multiplier
@@ -134,7 +134,7 @@ def length_checked_get_fn(bs):
             self.get_fn = get_fn  # Interpret everything
 
         # Create a reading function from the get_fn.
-        if self.get_fn_needs_length:
+        if self.read_fn_needs_length:
             if len(self.allowed_lengths) == 1:
                 def read_fn(bs, start):
                     return self.get_fn(bs[start:start + self.allowed_lengths.value[0]])
@@ -173,7 +173,7 @@ def getDtype(self, length: Optional[int] = None) -> Dtype:
         if length is None:
             d = Dtype.create(self, None)
             return d
-        if not self.get_fn_needs_length:
+        if not self.read_fn_needs_length:
             raise ValueError(f"A length ({length}) shouldn't be supplied for the dtype '{self.name}'.")
         d = Dtype.create(self, length)
         return d
