simplify

bitarray/__init__.pyi

@@ -4,9 +4,6 @@ from unittest.runner import TextTestResult
 from typing import Any, BinaryIO, Literal, Union, overload
 
 
-Int1 = Literal[0, 1]
-Bool = Union[Int1, bool]
-Endian = Literal["little", "big"]
 Codedict = dict[Any, bitarray]
 
 
@@ -18,52 +15,52 @@ class decodetree:
 
 class bitarray:
     def __init__(self,
-                 initializer: Union[int, str, Iterable[Bool], None] = ...,
-                 endian: Endian = ..., /) -> None: ...
+                 initializer: Union[int, str, Iterable[int], None] = ...,
+                 endian: str = ..., /) -> None: ...
 
     def all(self) -> bool: ...
     def any(self) -> bool: ...
-    def append(self, value: Bool, /) -> None: ...
+    def append(self, value: int, /) -> None: ...
     def buffer_info(self) -> tuple[int, int, str, int, int]: ...
     def bytereverse(self) -> None: ...
     def clear(self) -> None: ...
     def copy(self) -> bitarray: ...
     def count(self,
-              value: Bool = ...,
+              value: int = ...,
               start: int = ...,
               stop: int = ..., /) -> int: ...
 
     def decode(self, code: Union[Codedict, decodetree], /) -> list: ...
     def encode(self, code: Codedict, x: Iterable, /) -> None: ...
-    def endian(self) -> Endian: ...
-    def extend(self, x: Iterable[Bool], /) -> None: ...
+    def endian(self) -> str: ...
+    def extend(self, x: Iterable[int], /) -> None: ...
     def fill(self) -> int: ...
     def find(self,
-             a: Union[bitarray, Bool],
+             a: Union[bitarray, int],
              start: int = ...,
              stop: int = ..., /) -> int: ...
 
     def frombytes(self, a: bytes, /) -> None: ...
     def fromfile(self, f: BinaryIO, n: int = ..., /) -> None: ...
     def index(self,
-              a: Union[bitarray, Bool],
+              a: Union[bitarray, int],
               start: int = ...,
               stop: int = ..., /) -> int: ...
 
-    def insert(self, i: int, value: Bool, /) -> None: ...
+    def insert(self, i: int, value: int, /) -> None: ...
     def invert(self, i: int = ...) -> None: ...
     def iterdecode(self,
                    code: Union[Codedict, decodetree], /) -> Iterator: ...
 
-    def itersearch(self, a: Union[bitarray, Bool], /) -> Iterator[int]: ...
+    def itersearch(self, a: Union[bitarray, int], /) -> Iterator[int]: ...
     def pack(self, b: bytes, /) -> None: ...
-    def pop(self, i: int = ..., /) -> Int1: ...
-    def remove(self, value: Bool, /) -> None: ...
+    def pop(self, i: int = ..., /) -> int: ...
+    def remove(self, value: int, /) -> None: ...
     def reverse(self) -> None: ...
-    def search(self, a: Union[bitarray, Bool],
+    def search(self, a: Union[bitarray, int],
                limit: int = ...) -> list[int]: ...
 
-    def setall(self, value: Bool, /) -> None: ...
+    def setall(self, value: int, /) -> None: ...
     def sort(self, reverse: int) -> None: ...
     def to01(self) -> str: ...
     def tobytes(self) -> bytes: ...
@@ -74,13 +71,13 @@ class bitarray:
                one: bytes = ...) -> bytes: ...
 
     def __len__(self) -> int: ...
-    def __iter__(self) -> Iterator[Int1]: ...
+    def __iter__(self) -> Iterator[int]: ...
     @overload
-    def __getitem__(self, i: int) -> Int1: ...
+    def __getitem__(self, i: int) -> int: ...
     @overload
     def __getitem__(self, s: slice) -> bitarray: ...
     @overload
-    def __setitem__(self, i: Union[int, slice], o: Bool) -> None: ...
+    def __setitem__(self, i: Union[int, slice], o: int) -> None: ...
     @overload
     def __setitem__(self, s: slice, o: bitarray) -> None: ...
     def __delitem__(self, i: Union[int, slice]) -> None: ...
@@ -113,8 +110,9 @@ class frozenbitarray(bitarray):
     def __hash__(self) -> int: ...
 
 
+__version__: str
 def bits2bytes(n: int, /) -> int: ...
-def get_default_endian() -> Endian: ...
+def get_default_endian() -> str: ...
 def test(verbosity: int = ..., repeat: int = ...) -> TextTestResult: ...
-def _set_default_endian(endian: Endian) -> None: ...
+def _set_default_endian(endian: str) -> None: ...
 def _sysinfo() -> tuple: ...

bitarray/util.pyi

@@ -1,43 +1,43 @@
 from typing import Any, AnyStr, BinaryIO, Hashable, Optional, Union
 
-from bitarray import bitarray, Int1, Bool, Endian
+from bitarray import bitarray
 
 
-def zeros(length: int, endian: Optional[Endian] = ...) -> bitarray: ...
-def urandom(length: int, endian: Optional[Endian] = ...) -> bitarray: ...
+def zeros(length: int, endian: Optional[str] = ...) -> bitarray: ...
+def urandom(length: int, endian: Optional[str] = ...) -> bitarray: ...
 def pprint(a: Any, stream: BinaryIO = ...,
            group: int = ...,
            indent: int = ...,
            width: int = ...) -> None: ...
 
-def make_endian(a: bitarray, endian: Endian) -> bitarray: ...
-def rindex(a: bitarray, Value: Bool) -> int: ...
+def make_endian(a: bitarray, endian: str) -> bitarray: ...
+def rindex(a: bitarray, Value: int) -> int: ...
 def strip(a: bitarray, mode: str = ...) -> bitarray: ...
 
 def count_n(a: bitarray, n: int, /) -> int: ...
-def parity(a: bitarray, /) -> Int1: ...
+def parity(a: bitarray, /) -> int: ...
 def count_and(a: bitarray, b: bitarray, /) -> int: ...
 def count_or(a: bitarray, b: bitarray, /) -> int: ...
 def count_xor(a: bitarray, b: bitarray, /) -> int: ...
 def subset(a: bitarray, b: bitarray, /) -> bool: ...
 
 def ba2hex(a: bitarray, /) -> str: ...
 def hex2ba(s: AnyStr, /,
-           endian: Optional[Endian] = ...) -> bitarray: ...
+           endian: Optional[str] = ...) -> bitarray: ...
 
 def ba2base(n: int, a: bitarray, /) -> str: ...
 def base2ba(n: int,
             s: AnyStr, /,
-            endian: Optional[Endian] = ...) -> bitarray: ...
+            endian: Optional[str] = ...) -> bitarray: ...
 
 def ba2int(a: bitarray, signed: int = ...) -> int: ...
 def int2ba(i: int, /,
            length: int = ...,
-           endian: Endian = ...,
+           endian: str = ...,
            signed: int = ...) -> bitarray: ...
 
 def serialize(a: bitarray, /) -> bytes: ...
 def deserialize(b: bytes, /) -> bitarray: ...
 def huffman_code(freq_map: dict[Hashable, Union[int, float]],
-                 endian: Optional[Endian] = ...
+                 endian: Optional[str] = ...
                  ) -> dict[Hashable, bitarray]: ...