Removed dependency to bitstring

Author: dhondta

docs/pages/helpers.md

@@ -86,7 +86,6 @@ It also provides some other utility functions, decorators, context managers and
 **Name** | **Description**
 --- | ---
 `range2` | alternative to `range` that supports floats
-`ts.BitArray` | slightly extended `BitArray` class from [`bitstring`](https://github.com/scott-griffiths/bitstring)
 `ts.capture` | decorator for capturing `stdout` and `stderr` of a function
 `ts.Capture` | context manager for capturing `stdout` and `stderr` of a code block
 `ts.dateparse` | date parsing function relying on `dateparser.parse`

pyproject.toml

@@ -34,7 +34,6 @@ classifiers = [
 dependencies = [
   "argcomplete>=3.0.8",
   "asciistuff>=1.3.1",
-  "bitstring==4.0.2",
   "codext>=1.15.4",
   "coloredlogs",
   "colorful",
@@ -68,7 +67,7 @@ dependencies = [
   "toml",
   "tqdm",
   "virtualenv>=20.26.3",
-  "weasyprint>=60.2",
+  "weasyprint>=64.1",
   "xmltodict",
 ]
 dynamic = ["version"]

src/tinyscript/argreparse.py

@@ -753,13 +753,14 @@ def parse_known_args(self, args=None, namespace=None):
             if not hasattr(namespace, dest):
                 setattr(namespace, dest, self._defaults[dest])
         # parse the arguments and exit if there are any errors
+        a = (args, namespace) if sys.version_info.minor < 12 else (args, namespace, False)
         if self.exit_on_error:
             try:
-                namespace, args = self._parse_known_args(args, namespace)
+                namespace, args = self._parse_known_args(*a)
             except ArgumentError as err:
                 self.error(str(err))
         else:
-            namespace, args = self._parse_known_args(args, namespace)
+            namespace, args = self._parse_known_args(*a)
         if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
             args.extend(set(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR)))
             try:

src/tinyscript/helpers/data/transform/common.py

@@ -3,7 +3,6 @@
 
 """
 from ..types import is_bin, is_bytes, is_hex, is_int, is_list, is_pos_int, is_str
-from ..utils import BitArray as Bits
 from ...compat import b, ensure_str
 
 for _m in ["binascii", "functools", "math"]:
@@ -91,10 +90,12 @@ def bin2hex(binary_string, nbits_in=8, nbits_out=8) -> str:
 def bin2int(binary_string, nbits_in=8, nbits_out=8, order="big", unsigned=True) -> int:
     """ Convert a binary string (eventually using a separator) to an integer, using a given number of bits and in little
          or big endian. """
-    bs = binary_string
+    bs, n_b, n_B = binary_string, nbits_in, nbits_out
     __validation(b=bs, o=order, u=unsigned)
-    bs, pref = Bits(bin2bin(bs, nbits_in, nbits_out)), ["", "u"][unsigned]
-    return getattr(bs, pref + ("intle" if order == "little" else "intbe"))
+    bs = bin2bin(bs, n_b, n_B)
+    if order == "little":
+        bs = ''.join(reversed([bs[i:i+n_B] for i in range(0, len(bs), n_B)]))
+    return int(bs, 2) - (1 << len(bs)) if not unsigned and bs[0] == "1" else int(bs, 2)
 
 
 @__ensure_bitstring
@@ -117,61 +118,44 @@ def hex2bin(hex_string, nbits_in=8, nbits_out=8) -> str:
     return bin2bin(padz(bs, n_b), n_b, n_B)
 
 
-def hex2int(hex_string, order="big", unsigned=True) -> int:
+def hex2int(hex_string, nbits_in=8, nbits_out=8, order="big", unsigned=True) -> int:
     """ Convert a hexadecimal string to a big integer. """
-    h = hex_string
-    __validation(h=h, o=order, u=unsigned)
-    bs = Bits()
-    bs.hex = h
-    pref = ["", "u"][unsigned]
-    return getattr(bs, pref + ("intle" if order == "little" else "intbe"))
+    n_B = nbits_out
+    return bin2int(hex2bin(hex_string, nbits_in, n_B), n_B, n_B, order, unsigned)
 
 
 def hex2str(hex_string) -> str:
     """ Convert a hexadecimal string to a string of 8-bits characters. """
     h = hex_string
     __validation(h=h)
-    return ensure_str(binascii.unhexlify(b(hex_string)))
+    return ensure_str(binascii.unhexlify(b(h)))
 
 
 # INTEGER ==> *
 def int2bin(integer, nbits_in=8, nbits_out=8, order="big", unsigned=True) -> str:
     """ Convert an integer to a binary string in little or big endian. """
-    i = integer
-    __validation(i=i, n_b=nbits_in, n_B=nbits_out, o=order, u=unsigned)
-    bs = Bits()
-    nbits = i.bit_length() + int(not unsigned)
-    bs.hex = int(math.ceil(max(nbits, 1) / 8.0)) * 2 * "0"
-    pref = ["", "u"][unsigned]
-    setattr(bs, pref + ("intle" if order == "little" else "intbe"), i)
-    bs._nbits = nbits_in
-    bs.nbits = nbits_out
-    return bs.bin
-
-
-def int2hex(integer, order="big", unsigned=True) -> str:
+    i, n_b, n_B = integer, nbits_in, nbits_out
+    __validation(i=i, n_b=n_b, n_B=nbits_out, o=order, u=unsigned)
+    if not unsigned and i < 0:
+        i = (1 << n_b) + i
+    bs = format(i, f'0{n_b}b')
+    bs = "".join(bs[i:i+n_b] for i in range(0, len(bs), n_b))
+    bs = bs.zfill(len(bs) + (n_b - (len(bs) % n_b)) % n_b)
+    if order == "little":
+        bs = "".join(reversed([bs[i:i+n_b] for i in range(0, len(bs), n_b)]))
+    return bin2bin(bs, n_b, n_B)
+
+
+def int2hex(integer, nbits_in=8, nbits_out=8, order="big", unsigned=True) -> str:
     """ Convert an integer to a hexadecimal string. """
-    i = integer
-    __validation(i=i, o=order, u=unsigned)
-    bs = Bits()
-    nbits = i.bit_length() + int(not unsigned)
-    bs.hex = int(math.ceil(max(nbits, 1) / 8.0)) * 2 * "0"
-    pref = ["", "u"][unsigned]
-    setattr(bs, pref + ("intle" if order == "little" else "intbe"), i)
-    return bs.hex
-    #"".join([h[i:i+2] for i in range(0, len(h), 2)][::-1])
+    n_B = nbits_out
+    return bin2hex(int2bin(integer, nbits_in, n_B, order, unsigned), n_B, n_B)
 
 
-def int2str(integer, order="big", unsigned=True) -> str:
+def int2str(integer, nbits_in=8, nbits_out=8, order="big", unsigned=True) -> str:
     """ Convert a big integer to a string of 8-bits characters. """
-    i = integer
-    __validation(i=i, o=order, u=unsigned)
-    bs = Bits()
-    nbits = i.bit_length() + int(not unsigned)
-    bs.hex = int(math.ceil(max(nbits, 1) / 8.0)) * 2 * "0"
-    pref = ["", "u"][unsigned]
-    setattr(bs, pref + ("intle" if order == "little" else "intbe"), i)
-    return ensure_str(bs.bytes)
+    n_B = nbits_out
+    return bin2str(int2bin(integer, nbits_in, n_B, order, unsigned), n_B, n_B)
 
 
 def int2uni(integer) -> str:
@@ -202,15 +186,11 @@ def str2hex(chars_string) -> str:
     return ensure_str(binascii.hexlify(b(s)))
 
 
-def str2int(chars_string, order="big", unsigned=True) -> int:
+def str2int(chars_string, nbits_in=8, nbits_out=8, order="big", unsigned=True) -> int:
     """ Convert a string of 8-bits characters to a big integer or, if using blocks of nchars characters, a list of big
          integers. """
-    s = chars_string
-    __validation(s=s, o=order, u=unsigned)
-    bs = Bits()
-    bs.bytes = b(s)
-    pref = ["", "u"][unsigned]
-    return getattr(bs, pref + ("intle" if order == "little" else "intbe"))
+    n_B = nbits_out
+    return bin2int(str2bin(chars_string, nbits_in, n_B), n_B, n_B, order, unsigned)
 
 
 def str2lst(chars_string) -> list:

src/tinyscript/helpers/data/utils.py

@@ -13,85 +13,12 @@
 lazy_load_module("string", alias="strmod")
 
 
-__all__ = __features__ = ["BitArray", "entropy", "entropy_bits", "pad", "unpad"]
+__all__ = __features__ = ["entropy", "entropy_bits", "pad", "unpad"]
 
 
 PAD = ["ansic9.23", "incremental", "iso7816-4", "pkcs5", "pkcs7", "w3c"]
 
 
-def __init_bitstring(bs):
-    OLD_CODE, NEW_CODE = """
-        def _getlength(self)%s:
-            \"\"\"Return the length of the bitstring in bits.\"\"\"
-            return self._datastore.bitlength
-    """, """
-        def _getlength(self)%s:
-            \"\"\"Return the length of the bitstring in bits.\"\"\"
-            l = self._datastore.bitlength
-            return l + (8 - l %% 8) %% 8 if getattr(Bits, "_padding", True) else l
-    """
-    try:
-        patchy.replace(bs.Bits._getlength, OLD_CODE % " -> int", NEW_CODE % " -> int")
-    except (SyntaxError, ValueError):
-        patchy.replace(bs.Bits._getlength, OLD_CODE % "", NEW_CODE % "")
-    OLD_CODE, NEW_CODE = """
-        def _getbin(self)%s:
-            \"\"\"Return interpretation as a binary string.\"\"\"
-            return self._readbin(%s)
-    """, """
-        def _getbin(self)%s:
-            \"\"\"Return interpretation as a binary string.\"\"\"
-            Bits._padding = False
-            r = self._readbin(%s)
-            Bits._padding = True
-            return r
-    """
-    try:
-        patchy.replace(bs.Bits._getbin, OLD_CODE % (" -> str", "0, self.len"), NEW_CODE % (" -> str", "0, self.len"))
-    except (SyntaxError, ValueError):
-        patchy.replace(bs.Bits._getbin, OLD_CODE % ("", "self.len, 0"), NEW_CODE % ("", "self.len, 0"))
-lazy_load_module("bitstring", postload=__init_bitstring)
-
-
-def __init_bitarray():
-    class BitArray(bitstring.BitArray):
-        __doc__ = """ Small improvement to the original bitstring.BitArray class.
-        
-        It allows to set the number of bits per group (by default, 8, for considering bytes).
-        
-        """ + bitstring.BitArray.__doc__
-        
-        def __new__(cls, auto=None, length=None, offset=None, nbits=8, **kwargs):
-            if auto:
-                if not auto.startswith("0b"):
-                    auto = "0b" + auto
-            c = super(BitArray, cls).__new__(cls, auto, length, offset, **kwargs)
-            c._nbits = nbits
-            c.original = True
-            return c
-        
-        @property
-        def nbits(self):
-            return self._nbits
-        
-        @nbits.setter
-        def nbits(self, n):
-            ob = self.bin
-            nb = ""
-            for i in range(0, len(ob), self._nbits):
-                group = ob[i:i+self._nbits]
-                if i > 0 and len(group) < self._nbits:
-                    break
-                group = pad(group, ">0", n)[-n:]
-                if int(ob[i:i+self._nbits], 2) != int(group, 2):
-                    self.original = False
-                nb += group
-            self.bin = nb
-            self._nbits = n
-    return BitArray
-BitArray = lazy_object(__init_bitarray)
-
-
 def entropy(string):
     """ Shannon entropy computation function. """
     s = string

src/tinyscript/helpers/text.py

@@ -177,7 +177,7 @@ def _beautify(txt, raw=False):
                     pass
             md += line + "\n"
         # 3. links incorrectly rendered after using pandoc
-        for link in re.findall("(<(.*?)>)", md):
+        for link in re.findall(r"(<(.*?)>)", md):
             md = md.replace(link[0], "[{0}]({1}{0})".format(link[1], ["", "mailto:"][is_email(link[1])]))
     # import only when required to render Markdown in the terminal
     from rich.markdown import Markdown
@@ -201,7 +201,7 @@ def _txt_list(text, format=None, ordered=False):
         r = "<{}l>".format(["u", "o"][ordered])
     elif format in ["md", "rst", "textile"]:
         r = ""
-    for line in re.split("\n[\-\*] ", text):
+    for line in re.split(r"\n[\-\*] ", text):
         line = line.lstrip("*- ")
         if format == "html":
             r += "\n<li>{}</li>".format(line)

tests/test_helpers_data_utils.py

@@ -13,10 +13,6 @@ def test_common_utility_functions(self):
         BIN = "01010"
         STR = "test"
         HEX = "deadbeefc0f3b1ac00"
-        bs = BitArray("01010101")
-        self.assertEqual(bs.nbits, 8)
-        self.assertEqual(bs.bin, "01010101")
-        self.assertEqual(bs.hex, "55")
         self.assertEqual(pad(STR, "\x00"), STR + 4 * "\x00")
         self.assertEqual(pad(STR, ">\x00"), 4 * "\x00" + STR)
         self.assertEqual(unpad(pad(STR, "\x00"), "\x00"), STR)