fixed formatting and function naming in bitmask_serial.py. updated...

fixed formatting and function naming in bitmask_serial.py.  updated test_encode_decode_bitmask_to_hex().

pyproject.toml

@@ -7,7 +7,7 @@ max_line_length = 131
 
 [tool.flake8]
 max-line-length = 131
-ignore = "E203"  # black likes to put spaces around the colons in ranges, so make flake8 ignore them
+ignore = ["E203", "W503"]  # ignore flake8 messages caused by the black formatter
 
 [tool.black]
 line-length = 131

src/main/python/Octeres/bitmask/bitmask_serial.py

@@ -17,7 +17,7 @@ default_hex_block_size = 256
 hex_map = "0123456789abcdef"
 
 
-def hex_string_to_bit_intervals0(hex_str: str, limit: Optional[int] = None) -> Tuple[int, IntervalList]:
+def _hex_string_to_bit_intervals_v0(hex_str: str, limit: Optional[int] = None) -> Tuple[int, IntervalList]:
     """
     Given a hex string and limit (number of bits), return a set of intervals that will be used to create a LiteBitmaskSlots.
     """
@@ -55,7 +55,7 @@ def hex_string_to_bit_intervals0(hex_str: str, limit: Optional[int] = None) -> T
     return bit_count, intervals
 
 
-def hex_string_to_bit_intervals1(hex_str: str, limit: Optional[int] = None) -> Tuple[int, IntervalList]:
+def _hex_string_to_bit_intervals_v1(hex_str: str, limit: Optional[int] = None) -> Tuple[int, IntervalList]:
     """
     Given a hex string and limit (number of bits), return a set of intervals that will be used to create a LiteBitmaskSlots.
     """
@@ -93,7 +93,7 @@ def hex_string_to_bit_intervals1(hex_str: str, limit: Optional[int] = None) -> T
     return bit_count, intervals
 
 
-def hex_string_to_bit_intervals2(hex_str: str, limit: Optional[int] = None) -> Tuple[int, IntervalList]:
+def _hex_string_to_bit_intervals_v2(hex_str: str, limit: Optional[int] = None) -> Tuple[int, IntervalList]:
     """
     Given a hex string and limit (number of bits), return a set of intervals that will be used to create a LiteBitmaskSlots.
     """
@@ -148,10 +148,8 @@ def hex_string_to_bit_intervals2(hex_str: str, limit: Optional[int] = None) -> T
     return bit_count, intervals
 
 
-def hex_string_to_bit_intervals3(
-    hex_str: str,
-    limit: Optional[int] = None,
-    hex_block_size: Optional[int] = None,
+def _hex_string_to_bit_intervals_v3(
+    hex_str: str, limit: Optional[int] = None, hex_block_size: Optional[int] = None
 ) -> Tuple[int, IntervalList]:
     """
     Given a hex string, a limit (number of bits) and an optional hex block size, return a set of intervals that will be used to
@@ -216,10 +214,8 @@ def hex_string_to_bit_intervals3(
     return bit_count, intervals
 
 
-def hex_string_to_bit_intervals4(
-    hex_str: str,
-    limit: Optional[int] = None,
-    hex_block_size: Optional[int] = None,
+def _hex_string_to_bit_intervals_v4(
+    hex_str: str, limit: Optional[int] = None, hex_block_size: Optional[int] = None
 ) -> Tuple[int, IntervalList]:
     """
     Given a hex string, a limit (number of bits) and an optional hex block size, return a set of intervals that will be used to
@@ -283,10 +279,8 @@ def hex_string_to_bit_intervals4(
     return bit_count, intervals
 
 
-def hex_string_to_bit_intervals5(
-    hex_str: str,
-    limit: Optional[int] = None,
-    hex_block_size: Optional[int] = None,
+def _hex_string_to_bit_intervals_v5(
+    hex_str: str, limit: Optional[int] = None, hex_block_size: Optional[int] = None
 ) -> Tuple[int, IntervalList]:
     """
     Given a hex string, a limit (number of bits) and an optional hex block size, return a set of intervals that will be used to
@@ -362,7 +356,7 @@ def hex_string_to_bit_intervals5(
     return bit_count, intervals
 
 
-def intervals_to_hex_string0(length: int, intervals: IntervalList) -> str:
+def _intervals_to_hex_string_v0(length: int, intervals: IntervalList) -> str:
     bits = 0
     end_offset = length - 1
     for bit_start, bit_end in intervals:
@@ -371,7 +365,7 @@ def intervals_to_hex_string0(length: int, intervals: IntervalList) -> str:
     return hex(bits)[2:].zfill((length + 3) // 4)
 
 
-def intervals_to_hex_string1(length: int, intervals: IntervalList) -> str:
+def _intervals_to_hex_string_v1(length: int, intervals: IntervalList) -> str:
     hex_str = ""
     hex_prev = 0
     prev_bits_int = 0
@@ -529,8 +523,8 @@ class _BitmaskSerializer:
         bitmask = eb.concatenate(bitmask_lst)
         return bitmask
 
-    # def encode_litebitmask_to_hex(self, bitmask: EnhancedBitmask) -> str:
-    #     pass
+    def encode_litebitmask_to_hex(self, bitmask: LiteBitmask) -> str:
+        return _intervals_to_hex_string(bitmask.length, bitmask.intervals)
 
     def decode_hex_to_litebitmask(self, hex_string: str, limit=None) -> LiteBitmask:
         """given a hex_string(lower case), convert it from a hex_string
@@ -538,7 +532,7 @@ class _BitmaskSerializer:
 
         Use limit to create a bitmask not divisible by 4
         """
-        _, intervals = hex_string_to_bit_intervals(hex_string, limit=limit)
+        _, intervals = _hex_string_to_bit_intervals(hex_string, limit=limit)
         # bit_idx_first = intervals[0][0] if intervals else -1
         # bit_idx_last = intervals[-1][1] if intervals else -1
         # bitmask = LiteBitmaskSlots(limit, bit_count, intervals, bit_idx_first, bit_idx_last)
@@ -560,5 +554,6 @@ def BitmaskSerializer():
     BitS = _BitmaskSerializer()
     return BitS
 
-hex_string_to_bit_intervals = hex_string_to_bit_intervals5
-intervals_to_hex_string = intervals_to_hex_string1
+
+_hex_string_to_bit_intervals = _hex_string_to_bit_intervals_v5
+_intervals_to_hex_string = _intervals_to_hex_string_v1

src/test/python/bitmask/test_bitmask_serial.py

@@ -7,7 +7,7 @@ from contextlib import nullcontext
 from Octeres.bitmask import EnhancedBitmask
 from Octeres.bitmask import BitmaskSerializer
 from Octeres.bitmask.bitmask_lite import LiteBitmask, convert_bitmask_to_litebitmask, intersection_all
-from Octeres.bitmask.bitmask_serial import intervals_to_hex_string
+
 
 BitS = BitmaskSerializer()
 
@@ -73,17 +73,18 @@ def test_encode_decode_bitmask_to_hex(
         if hexmask_out is None:
             hexmask_out = hexmask_in
         eb_bitmask_r = BitS.decode_hex_to_bitmask(hexmask_in, limit=length)
+        eb_hexmask_r = BitS.encode_bitmask_to_hex(eb_bitmask_r)
         l_bitmask_r = convert_bitmask_to_litebitmask(eb_bitmask_r)
         l_bitmask_r2 = BitS.decode_hex_to_litebitmask(hexmask_in, limit=length)
-        l_hexmask_r2 = intervals_to_hex_string(l_bitmask_r2.length, l_bitmask_r2.intervals)
-        # todo:
-        #   add code to encode it to hexmask and then back again, asserting correctness.
-        #   check validation of each of the bitmasks provided.
+        l_hexmask_r2 = BitS.encode_litebitmask_to_hex(l_bitmask_r2)
 
+        s_bitmask = l_bitmask.to_slots()
         s_bitmask_r = l_bitmask_r.to_slots()
         s_bitmask_r2 = l_bitmask_r2.to_slots()
-        print(eb_bitmask_r)
+
         assert intersection_all(l_bitmask_r, l_bitmask)
         assert eb_bitmask_r.intersection_all(eb_bitmask)
+        assert intersection_all(s_bitmask, s_bitmask_r2)
         assert intersection_all(s_bitmask_r, s_bitmask_r2)
+        assert eb_hexmask_r == hexmask_out
         assert l_hexmask_r2 == hexmask_out