update pyi work

bitarray/__init__.pyi

@@ -15,45 +15,61 @@ class decodetree:
 
 
 class bitarray:
-    def __init__(self, initializer: Union[int, str, Iterable[Bool], None]=0,
-                 endian: str=..., /) -> None: ...
+    def __init__(self,
+                 initializer: Union[int, str, Iterable[Bool], None]=0,
+                 endian: str = ..., /) -> None: ...
+
     def all(self) -> bool: ...
     def any(self) -> bool: ...
     def append(self, value: Bool, /) -> 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=1, start: int=0, stop: int=..., /) -> int: ...
+    def count(self,
+              value: Bool=1,
+              start: int=0,
+              stop: int = ..., /) -> int: ...
+
     def decode(self, code: Union[Codedict, decodetree], /) -> list: ...
     def encode(self, code: Codedict, x: Iterable, /) -> None: ...
     def endian(self) -> str: ...
     def extend(self, x: Iterable[Bool], /) -> None: ...
     def fill(self) -> int: ...
-    def find(self, a: Union[bitarray, Bool],
-             start: int=0, stop: int=..., /) -> int: ...
+    def find(self,
+             a: Union[bitarray, Bool],
+             start: int = 0,
+             stop: int = ..., /) -> int: ...
+
     def frombytes(self, a: bytes, /) -> None: ...
     def fromfile(self, f: BinaryIO, n: int=-1, /) -> None: ...
-    def index(self, a: Union[bitarray, Bool],
-              start: int=0, stop: int=..., /) -> int: ...
+    def index(self,
+              a: Union[bitarray, Bool],
+              start: int = 0,
+              stop: int = ..., /) -> int: ...
+
     def insert(self, i: int, value: Bool, /) -> None: ...
-    def invert(self, i: 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 pack(self, b: bytes, /) -> None: ...
-    def pop(self, i: int=..., /) -> Bool: ...
+    def pop(self, i: int = ..., /) -> Bool: ...
     def remove(self, value: Bool, /) -> None: ...
     def reverse(self) -> None: ...
     def search(self, a: Union[bitarray, Bool],
                limit: int = ...) -> list[int]: ...
+
     def setall(self, value: Bool, /) -> None: ...
     def sort(self, reverse: int) -> None: ...
     def to01(self) -> str: ...
     def tobytes(self) -> bytes: ...
     def tofile(self, f: BinaryIO, /) -> None: ...
     def tolist(self) -> list[int]: ...
-    def unpack(self, zero: bytes=..., one: bytes=...) -> bytes: ...
+    def unpack(self,
+               zero: bytes = ...,
+               one: bytes = ...) -> bytes: ...
 
     def __len__(self) -> int: ...
     def __iter__(self) -> Iterator[Bool]: ...
@@ -97,4 +113,5 @@ class frozenbitarray(bitarray):
 
 def bits2bytes(n: int, /) -> int: ...
 def get_default_endian() -> str: ...
+def _set_default_endian(endian: str) -> None: ...
 def _sysinfo() -> tuple: ...

bitarray/util.pyi

@@ -6,29 +6,39 @@ from bitarray import bitarray
 Bool = Union[Literal[0, 1], bool]
 
 
-def zeros(length: int, endian: Optional[str] = ...): ...
-def urandom(length: int, endian: Optional[str] = ...): ...
+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: str): ...
+def make_endian(a: bitarray, endian: str) -> bitarray: ...
 def rindex(a: bitarray, Value: Bool) -> int: ...
-def strip(a: bitarray, mode: Optional[str] = ...) -> bitarray: ...
+def strip(a: bitarray, mode: str = ...) -> bitarray: ...
+
 def count_n(a: bitarray, n: int, /) -> int: ...
 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: str = ...): ...
+def hex2ba(s: AnyStr, /,
+           endian: Optional[str] = ...) -> bitarray: ...
+
 def ba2base(n: int, a: bitarray, /) -> str: ...
-def base2ba(n: int, s: AnyStr, /, endian: str = ...): ...
-def ba2int(a: bitarray, signed: bool = ...): ...
+def base2ba(n: int,
+            s: AnyStr, /,
+            endian: Optional[str] = ...) -> bitarray: ...
+
+def ba2int(a: bitarray, signed: bool = ...) -> int: ...
 def int2ba(i: int, /,
-           length: int = ..., endian: str = ..., signed: bool = ...): ...
+           length: int = ...,
+           endian: str = ...,
+           signed: bool = ...) -> bitarray: ...
+
 def serialize(a: bitarray, /) -> bytes: ...
 def deserialize(b: bytes, /) -> bitarray: ...
 def huffman_code(freq_map: dict[Any, Union[int, float]],