easybits 0.1.0__tar.gz

easybits-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: easybits
+Version: 0.1.0
+Summary: A friendly interface for exploring bits.
+Author: Chris Proctor
+Author-email: chris@chrisproctor.net
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: bitarray (>=3.0.0,<4.0.0)
+Description-Content-Type: text/markdown
+
+# Easybits
+
+A friendly interface for exploring bits.
+

easybits-0.1.0/README.md

@@ -0,0 +1,3 @@
+# Easybits
+
+A friendly interface for exploring bits.

easybits-0.1.0/easybits/__init__.py

@@ -0,0 +1,111 @@
+from bitarray import bitarray
+from bitarray.util import (
+    zeros, 
+    ones, 
+    int2ba,
+    ba2int,
+)
+from easybits.util import is_bit_string
+from easybits.errors import (
+    NotEnoughBits, 
+    IntegersRequireLength, 
+    IntegerAdditionRequiresSameLength,
+)
+
+class Bits(bitarray):
+    """A wrapper around bitarray with a more idiomatic interface for beginners.
+    - Integers are always signed.
+    """
+
+    @classmethod
+    def zeros(cls, length):
+        return Bits(zeros(length))
+
+    @classmethod
+    def ones(cls, length):
+        return Bits(ones(length))
+
+    def __new__(cls, value, length=None, encoding='ascii'):
+        if isinstance(value, bytes):
+            bits = bitarray()
+            bits.frombytes(value)
+        elif isinstance(value, bool):
+            bits = bitarray([value])
+        elif isinstance(value, int):
+            if not length:
+                raise IntegersRequireLength()
+            bits = int2ba(value, length=length, signed=True)
+        elif isinstance(value, str):
+            if is_bit_string(value):
+                bits = bitarray(value)
+            else:
+                bits = bitarray()
+                bits.frombytes(value.encode(encoding))
+        elif isinstance(value, list):
+            bits = bitarray(value)
+        elif isinstance(value, bitarray):
+            bits = value
+        else:
+            raise ValueError(f"Can't create bits from {value}")
+        if length:
+            if length < len(bits):
+                raise NotEnoughBits(value, length)
+            else:
+                sized_bits = bitarray(length)
+                sized_bits[-len(bits):] = bits
+        else:
+            sized_bits = bits
+        return super().__new__(cls, sized_bits)
+
+    def __str__(self):
+        bits = self.to01()
+
+    def __repr__(self):
+        return self.to01()
+
+    @property
+    def bool(self):
+        return [bool(b) for b in  self.tolist()]
+
+    @property
+    def int(self):
+        return ba2int(self, signed=True)
+
+    @property
+    def bytes(self):
+        return self.tobytes()
+
+    @property
+    def ascii(self):
+        return self.bytes.decode("ascii")
+
+    def __add__(self, other):
+        """Performs bitwise addition on `self` and `other`. Does not
+        check for overflow.
+        """
+        a, b = self, Bits(other)
+        if not len(a) == len(b):
+            raise IntegerAdditionRequiresSameLength()
+        result = Bits.zeros(len(a))
+        carry = 0
+        for i in reversed(range(len(a))):
+            result[i] = a[i] ^ b[i] ^ carry
+            carry = (a[i] & b[i]) | (a[i] & carry) | (b[i] & carry)
+        return result
+
+    def __sub__(self, other):
+        """Performs bitwise addition on `self` and `other`. Does not
+        check for overflow.
+        """
+        a, b = self, Bits(other)
+        if not len(a) == len(b):
+            raise IntegerAdditionRequiresSameLength()
+        return a + (-b)
+
+    def __neg__(self):
+        """Treats `self` as an integer, and flips its sign.
+        """
+        if self[0]:
+            return ~self + Bits(1, length=len(self))
+        else:
+            return ~(self + Bits(-1, length=len(self)))

easybits-0.1.0/easybits/errors.py

@@ -0,0 +1,15 @@
+class BitsError(Exception):
+    message = "Bits error"
+
+    def __str__(self):
+        return self.message
+
+class NotEnoughBits(BitsError):
+    def __init__(self, obj, length):
+        self.message = f"{obj} cannot fit into {length} bits."
+
+class IntegersRequireLength(BitsError):
+    message = "Binary representations of integers require that a length be provided."
+
+class IntegerAdditionRequiresSameLength(BitsError):
+    message = "Can only add integers of the same length."

easybits-0.1.0/easybits/util.py

@@ -0,0 +1,5 @@
+
+def is_bit_string(value):
+    bit_chars = {'1', '0', ' '}
+    return not (set(value) - bit_chars)
+

easybits-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[tool.poetry]
+name = "easybits"
+version = "0.1.0"
+description = "A friendly interface for exploring bits."
+authors = ["Chris Proctor <chris@chrisproctor.net>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+bitarray = "^3.0.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"