bool-hybrid-array 9.11.9__py3-none-any.whl → 9.11.10__py3-none-any.whl

bool_hybrid_array/core.py

@@ -7,18 +7,13 @@ except:
 import builtins
 from types import MappingProxyType
 import array,bisect,numpy as np
-from collections.abc import MutableSequence,Iterable,Generator,Iterator,Sequence
+from collections.abc import MutableSequence,Iterable,Generator,Iterator,Sequence,Collection
 import itertools,copy,sys,math,weakref,random,mmap,os
 from functools import reduce
 import operator,ctypes,gc,abc,types
 from functools import lru_cache
 from typing import _GenericAlias
 from typing import Callable, Union, Sequence, MutableSequence, Any, overload, Sized
-from ctypes import *
-try:
-    import msvcrt
-except ImportError:
-    pass
 hybrid_array_cache:list[tuple[Any]] = []
 try:
     msvcrt = ctypes.CDLL('msvcrt.dll')
@@ -334,7 +329,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):# type:
         return f"BoolHybridArr([{','.join(map(str,self))}])"
     def __reversed__(self):
         if not self:return BHA_Iterator([])
-        return BHA_Iterator(map(self.__getitem__,range(-1,-1,-1)))
+        return BHA_Iterator(map(self.__getitem__,range(self.size-1,-1,-1)))
     def insert(self, key: int, value: Any) -> None:
         value = bool(value)
         key = key if key >= 0 else key + self.size
@@ -872,7 +867,7 @@ def Ask_BHA(path):
         if len(temp) == 1:
             return temp[0]
         return temp
-class BHA_Queue:
+class BHA_Queue(Collection,metaclass = ResurrectMeta):
     def __init__(self,data = (),*a,**k):
         self.a = BoolHybridArr(data,*a,**k)
         self.b = BoolHybridArr([],*a,**k)
@@ -885,8 +880,9 @@ class BHA_Queue:
         if self.b:
             return self.b.pop()
         elif self.a:
-            tmp = BoolHybridArr(reversed(self.a))
-            self.b.split_index,self.b.large,self.b.small,self.b.is_sparse = tmp.split_index,tmp.large,tmp.small,tmp.is_sparse
+            Type = self.b.Type
+            self.b = BoolHybridArr(reversed(self.a))
+            self.b.Type = Type
             self.a.clear()
             return self.dequeue()
         else:
@@ -938,215 +934,7 @@ def numba_opt():
     ])
     bisect.bisect_left = numba.njit(sig, cache=True)(bisect.bisect_left)
     bisect.bisect_right = numba.njit(sig, cache=True)(bisect.bisect_right)
-class InPutObject:
-    def __init__(self):
-        self._stdout = sys.stdout
-        if sys.platform == "win32":
-            self._get_char = lambda: ord(msvcrt.getche())
-            self.backch = " \b"
-        else:
-            libc_path = "libc.so.6" if sys.platform == "linux" else "libSystem.B.dylib"
-            self.libc = ctypes.cdll.LoadLibrary(libc_path)
-            self._get_char = lambda:(c:=ord(self.libc.getchar()),
-                self._stdout.write(chr(c)),self._stdout.flush())[0]
-            self.backch = "\b \b"
-        self._whitespace = {ord('\n'), ord('\t'), ord(' '), 0, ord("\r")}
-        self.getchar = self._get_char
-        self._buf = []
-    
-    def _read_char(self):
-        while True:
-            if self._buf:char = self._buf.pop(0)
-            else:char = self._get_char()
-            if char in self._whitespace or char == -1:
-                continue
-            return char
-
-    def _parse_int(self):
-        chars = []
-        while True:
-            if self._buf:
-                char = self._buf.pop(0)
-            else:
-                char = self._get_char()
-            if char in self._whitespace or char == -1:
-                break
-            if char == 8:
-                sys.stdout.write(self.backch)
-                sys.stdout.flush()
-                try:
-                    chars.pop()
-                except:
-                    pass
-                continue
-            elif chr(char) not in '+-0123456789':
-                self._buf.append(char)
-                break
-            else:
-                chars.append(chr(char))
-        return ''.join(chars) if chars else '0'
-
-    def _parse_float(self):
-        chars = []
-        while True:
-            if self._buf:
-                char = self._buf.pop(0)
-            else:
-                char = self._get_char()
-            if char in self._whitespace or char == -1:
-                break
-            if char == 8:
-                sys.stdout.write(self.backch)
-                sys.stdout.flush()
-                try:
-                    chars.pop()
-                except:
-                    pass
-                continue
-            elif chr(char) not in '+-0123456789.eE':
-                self._buf.append(char)
-                break
-            chars.append(chr(char))
-        return ''.join(chars) if chars else '0.0'
-
-    def _parse_complex(self):
-        chars = []
-        while True:
-            if self._buf:
-                char = self._buf.pop(0)
-            else:
-                char = self._get_char()
-            if char in self._whitespace or char == -1:
-                break
-            if char == 8:
-                sys.stdout.write(self.backch)
-                sys.stdout.flush()
-                try:
-                    chars.pop()
-                except:
-                    pass
-                continue
-            if chr(char) not in '+-0123456789.eEj':
-                self._buf.append(char)
-                break
-            chars.append(chr(char))
-        return ''.join(chars) if chars else '0+0j'
-
-    def _parse_char(self):
-        char = self._read_char()
-        return chr(char) if char not in self._whitespace and char != -1 else '\0'
-
-    def _parse_char_array(self, max_len=1024):
-        chars = []
-        count = 0
-        while count < max_len - 1:
-            char = self._get_char()
-            if char == 8:
-                sys.stdout.write(self.backch)
-                sys.stdout.flush()
-                try:
-                    chars.pop()
-                except:
-                    pass
-                continue
-            if char in self._whitespace or char == -1:
-                break
-            chars.append(chr(char))
-            count += 1
-        return ''.join(chars)
-    def _parse_ptr(self):
-        chars = []
-        while True:
-            if self._buf:
-                char = self._buf.pop(0)
-            else:
-                char = self._get_char()
-            if char in self._whitespace or char == -1:
-                break
-            if char == 8:
-                sys.stdout.write(self.backch)
-                sys.stdout.flush()
-                try:
-                    chars.pop()
-                except:
-                    pass
-                continue
-            if chr(char) not in '0123456789abcdefABCDEFx':
-                self._buf.append(char)
-                break
-            chars.append(chr(char))
-        return ''.join(chars) if chars else '0'
-    def __rshift__(self, target):
-        if isinstance(target, ctypes._SimpleCData):
-            target_type = type(target)
-            if target_type == c_void_p:
-                ptr_str = self._parse_ptr()
-                if ptr_str.startswith('0x') or ptr_str.startswith('0X'):
-                    val = c_void_p(int(ptr_str, 16))
-                else:
-                    val = c_void_p(int(ptr_str) if ptr_str.isdigit() else 0)
-            elif target_type == c_char_p:
-                str_val = self._parse_char_array()
-                val = c_char_p(str_val.encode('utf-8'))
-                ctypes.memmove(target, val, len(str_val.encode('utf-8')))
-            elif target_type == c_wchar_p:
-                str_val = self._parse_char_array()
-                val = c_wchar_p(str_val)
-                ctypes.memmove(target, val, len(str_val) * ctypes.sizeof(c_wchar))
-            elif np.issubdtype(np.dtype(target_type), np.integer):
-                val = target_type(int(self._parse_int()))
-            elif np.issubdtype(np.dtype(target_type), np.floating):
-                val = target_type(float(self._parse_float()))
-            elif np.issubdtype(np.dtype(target_type), np.complexfloating):
-                val = target_type(complex(self._parse_complex()))
-            elif target_type == c_char:
-                val = c_char(self._parse_char().encode('utf-8')[0])
-            elif target_type == c_wchar:
-                val = c_wchar(self._parse_char())
-            else:
-                raise TypeError(f"Unsupported ctypes type: {target_type}")
-            if target_type not in (c_char_p, c_wchar_p):
-                ctypes.memmove(byref(target), byref(val), sizeof(target))
-        elif isinstance(target, (np.generic, np.ndarray)):
-            if isinstance(target, np.generic) or target.ndim == 0:
-                if np.issubdtype(target.dtype, np.integer):
-                    val = np.array(self._parse_int(), dtype=target.dtype)
-                elif np.issubdtype(target.dtype, np.floating):
-                    val = np.array(self._parse_float(), dtype=target.dtype)
-                elif np.issubdtype(target.dtype, np.complexfloating):
-                    val = np.array(self._parse_complex(), dtype=target.dtype)
-                elif np.issubdtype(target.dtype, np.character):
-                    val = np.array(self._parse_char(), dtype=target.dtype)
-                else:
-                    val = np.array(self._parse_int(), dtype=target.dtype)
-                target[...] = val[()]
-            else:
-                for i in range(target.size):
-                    if np.issubdtype(target.dtype, np.integer):
-                        val = np.array(self._parse_int(), dtype=target.dtype)
-                    elif np.issubdtype(target.dtype, np.floating):
-                        val = np.array(self._parse_float(), dtype=target.dtype)
-                    elif np.issubdtype(target.dtype, np.complexfloating):
-                        val = np.array(self._parse_complex(), dtype=target.dtype)
-                    elif np.issubdtype(target.dtype, np.character):
-                        val = np.array(self._parse_char(), dtype=target.dtype)
-                    else:
-                        val = np.array(self._parse_int(), dtype=target.dtype)
-                    target.flat[i] = val[()]
-        else:
-            raise TypeError(f"Unsupported target type: {type(target)}")
-        return self
-    __str__ = lambda self:""
-    __repr__ = lambda self:""
-class OutPutObject:
-    def __lshift__(self, data):
-        sys.stdout.write(str(data))
-        return self
-    __str__ = lambda self:""
-    __repr__ = lambda self:""
-cin = InPutObject()
-cout = OutPutObject()
-endl = "\n"
+from ._cppiostream import cin,cout,endl
 builtins.np = np
 builtins.T = BHA_bool(1)
 builtins.F = BHA_bool(0)

bool_hybrid_array/int_array/__init__.py

@@ -1,155 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import annotations
-from ..core import *
-import builtins
-class IntBitTag(BHA_bool, metaclass=ResurrectMeta):
-    def __str__(self):
-        return "'-1'" if (hasattr(self, 'is_sign_bit') and self.is_sign_bit and self) else "'1'" if self else "'0'"
-    __repr__ = __str__
-    __del__ = lambda self:self
-class IntHybridArray(BoolHybridArray):
-    def __init__(self, int_array: list[int], bit_length: int = 8):
-        self.bit_length = bit_length
-        bool_data = []
-        max_required_bits = 1
-        for num in int_array:
-            if num == 0:
-                required_bits = 1
-            else:
-                abs_num = abs(num)
-                num_bits_needed = abs_num.bit_length()
-                required_bits = 1 + num_bits_needed
-            if required_bits > max_required_bits:
-                max_required_bits = required_bits
-        self.bit_length = max_required_bits
-        for num in int_array:
-            if num >= 0:
-                sign_bit = False
-                num_bits = [bool((num >> i) & 1) for i in range(self.bit_length - 1)]
-            else:
-                sign_bit = True
-                abs_num = abs(num)
-                num_bits = [not bool((abs_num >> i) & 1) for i in range(self.bit_length - 1)]
-                carry = 1
-                for j in range(len(num_bits)):
-                    if carry:
-                        num_bits[j] = not num_bits[j]
-                        carry = 0 if num_bits[j] else 1
-            bool_data.append(sign_bit)
-            bool_data.extend(num_bits)
-        self.total_bits = len(bool_data)
-        super().__init__(0, self.total_bits, False, IntBitTag, False)
-        for idx in range(self.total_bits):
-            if idx < self.size:
-                super().__setitem__(idx, bool_data[idx])
-            else:
-                super().append(bool_data[idx])
-        for i in range(0, self.total_bits, self.bit_length):
-            if i < self.size:
-                bit_tag = super().__getitem__(i)
-                bit_tag.is_sign_bit = True
-
-    def to_int(self, bit_chunk):
-        sign_bit = bit_chunk[0].value
-        num_bits = [bit.value for bit in bit_chunk[1:]]
-        if not sign_bit:
-            num = 0
-            for j in range(len(num_bits)):
-                if num_bits[j]:
-                    num += (1 << j)
-        else:
-            num_bits_inv = [not b for b in num_bits]
-            carry = 1
-            for j in range(len(num_bits_inv)):
-                if carry:
-                    num_bits_inv[j] = not num_bits_inv[j]
-                    carry = 0 if num_bits_inv[j] else 1
-            num = 0
-            for j in range(len(num_bits_inv)):
-                if num_bits_inv[j]:
-                    num += (1 << j)
-            num = -num
-        return num
-
-    def __getitem__(self, key):
-        if isinstance(key, slice):
-            start, stop, step = key.indices(len(self))
-            result = []
-            for i in range(start, stop, step):
-                block_start = i * self.bit_length
-                block_end = block_start + self.bit_length
-                if block_end > self.size:
-                    raise IndexError("索引超出范围")
-                bit_chunk = [super(self.__class__, self).__getitem__(j) for j in range(block_start, block_end)]
-                num = self.to_int(bit_chunk)
-                result.append(num)
-            return IntHybridArray(result, self.bit_length)
-        key = key if key >= 0 else key + len(self)
-        if not (0 <= key < len(self)):
-            raise IndexError("索引超出范围")
-        block_start = key * self.bit_length
-        block_end = block_start + self.bit_length
-        if block_end > self.size:
-            raise IndexError("索引超出范围")
-        bit_chunk = [super(self.__class__, self).__getitem__(j) for j in range(block_start, block_end)]
-        return self.to_int(bit_chunk)
-
-    def __setitem__(self, key, value):
-        tmp = list(self)
-        tmp[key] = value
-        self.__init__(tmp)
-    def __iter__(self):
-        return map(self.__getitem__,range(len(self)))
-
-    def __str__(self):
-        return f"IntHybridArray([{', '.join(map(str, self))}])"
-    __repr__ = __str__
-
-    def __len__(self):
-        return self.total_bits // self.bit_length
-    def __delitem__(self, index: int = -1):
-        index = index if index >= 0 else index + len(self)
-        if not (0 <= index < len(self)):
-            raise IndexError("删除索引超出范围")
-        target_num = self[index]
-        pop_bit_start = index * self.bit_length
-        pop_bit_end = pop_bit_start + self.bit_length
-        for _ in range(self.bit_length):
-            super().__delitem__(pop_bit_start)
-        self.total_bits -= self.bit_length
-    def index(self, value):
-        value = int(value)
-        x = f"{value} 不在 IntHybridArray 中"
-        for idx in range(len(self)+1>>1):
-            if self[idx] == value:
-                return idx
-            elif self[-idx] == value:
-                x = len(self)-idx
-        if x != f"{value} 不在 IntHybridArray 中":
-            return x
-        raise ValueError(x)
-    def rindex(self, value):
-        value = int(value)
-        x = f"{value} 不在 IntHybridArray 中"
-        for idx in range(len(self)+1>>1):
-            if self[-idx] == value:
-                return -idx
-            elif self[idx] == value:
-                x = -(len(self)-idx)
-        if x != f"{value} 不在 IntHybridArray 中":
-            return x
-        raise ValueError(x)
-    def extend(self, iterable:Iterable) -> None:
-        if isinstance(iterable, (Iterator, Generator, map)):
-            iterable,copy = itertools.tee(iterable, 2)
-            len_ = sum(1 for _ in copy)
-        else:
-            len_ = len(iterable)
-        self.total_bits += len_*self.bit_length
-        for i,j in zip(range(len_),iterable):
-            self[-i-1] = j
-    def append(self,value):
-        self.total_bits += self.bit_length
-        self.size = self.total_bits
-        self[-1] = value
+try:from .compile_core import *
+except:from .core import *
 __all__ = tuple(globals())

bool_hybrid_array/int_array/core.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+from collections.abc import Iterable
+from ..core import *
+import builtins
+class IntBitTag(BHA_bool, metaclass=ResurrectMeta):
+    def __str__(self):
+        return "'-1'" if (hasattr(self, 'is_sign_bit') and self.is_sign_bit and self) else "'1'" if self else "'0'"
+    __repr__ = __str__
+    __del__ = lambda self:self
+class IntHybridArray(BoolHybridArray,metaclass=ResurrectMeta):
+    def __init__(self, int_array: list[int], bit_length: int = 8):
+        self.bit_length = bit_length
+        bool_data = []
+        max_required_bits = 1
+        for num in int_array:
+            if num == 0:
+                required_bits = 1
+            else:
+                abs_num = abs(num)
+                num_bits_needed = abs_num.bit_length()
+                required_bits = 1 + num_bits_needed
+            if required_bits > max_required_bits:
+                max_required_bits = required_bits
+        self.bit_length = max_required_bits
+        for num in int_array:
+            if num >= 0:
+                sign_bit = False
+                num_bits = [bool((num >> i) & 1) for i in range(self.bit_length - 1)]
+            else:
+                sign_bit = True
+                abs_num = abs(num)
+                num_bits = [not bool((abs_num >> i) & 1) for i in range(self.bit_length - 1)]
+                carry = 1
+                for j in range(len(num_bits)):
+                    if carry:
+                        num_bits[j] = not num_bits[j]
+                        carry = 0 if num_bits[j] else 1
+            bool_data.append(sign_bit)
+            bool_data.extend(num_bits)
+        self.total_bits = len(bool_data)
+        super().__init__(0, self.total_bits, False, IntBitTag, False)
+        for idx in range(self.total_bits):
+            if idx < self.size:
+                super().__setitem__(idx, bool_data[idx])
+            else:
+                super().append(bool_data[idx])
+        for i in range(0, self.total_bits, self.bit_length):
+            if i < self.size:
+                bit_tag = super().__getitem__(i)
+                bit_tag.is_sign_bit = True
+
+    def to_int(self, bit_chunk):
+        sign_bit = bit_chunk[0].value
+        num_bits = [bit.value for bit in bit_chunk[1:]]
+        if not sign_bit:
+            num = 0
+            for j in range(len(num_bits)):
+                if num_bits[j]:
+                    num += (1 << j)
+        else:
+            num_bits_inv = [not b for b in num_bits]
+            carry = 1
+            for j in range(len(num_bits_inv)):
+                if carry:
+                    num_bits_inv[j] = not num_bits_inv[j]
+                    carry = 0 if num_bits_inv[j] else 1
+            num = 0
+            for j in range(len(num_bits_inv)):
+                if num_bits_inv[j]:
+                    num += (1 << j)
+            num = -num
+        return num
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            start, stop, step = key.indices(len(self))
+            result = []
+            for i in range(start, stop, step):
+                block_start = i * self.bit_length
+                block_end = block_start + self.bit_length
+                if block_end > self.size:
+                    raise IndexError("索引超出范围")
+                bit_chunk = [super(self.__class__, self).__getitem__(j) for j in range(block_start, block_end)]
+                num = self.to_int(bit_chunk)
+                result.append(num)
+            return IntHybridArray(result, self.bit_length)
+        key = key if key >= 0 else key + len(self)
+        if not (0 <= key < len(self)):
+            raise IndexError("索引超出范围")
+        block_start = key * self.bit_length
+        block_end = block_start + self.bit_length
+        if block_end > self.size:
+            raise IndexError("索引超出范围")
+        bit_chunk = [super(self.__class__, self).__getitem__(j) for j in range(block_start, block_end)]
+        return self.to_int(bit_chunk)
+
+    def __setitem__(self, key, value):
+        tmp = list(self)
+        tmp[key] = value
+        self.__init__(tmp)
+    def __iter__(self):
+        return map(self.__getitem__,range(len(self)))
+
+    def __str__(self):
+        return f"IntHybridArray([{', '.join(map(str, self))}])"
+    __repr__ = __str__
+
+    def __len__(self):
+        return self.total_bits // self.bit_length
+    def __delitem__(self, index: int = -1):
+        index = index if index >= 0 else index + len(self)
+        if not (0 <= index < len(self)):
+            raise IndexError("删除索引超出范围")
+        target_num = self[index]
+        pop_bit_start = index * self.bit_length
+        pop_bit_end = pop_bit_start + self.bit_length
+        for _ in range(self.bit_length):
+            super().__delitem__(pop_bit_start)
+        self.total_bits -= self.bit_length
+    def index(self, value):
+        value = int(value)
+        x = f"{value} 不在 IntHybridArray 中"
+        for idx in range(len(self)+1>>1):
+            if self[idx] == value:
+                return idx
+            elif self[-idx] == value:
+                x = len(self)-idx
+        if x != f"{value} 不在 IntHybridArray 中":
+            return x
+        raise ValueError(x)
+    def rindex(self, value):
+        value = int(value)
+        x = f"{value} 不在 IntHybridArray 中"
+        for idx in range(len(self)+1>>1):
+            if self[-idx] == value:
+                return -idx
+            elif self[idx] == value:
+                x = -(len(self)-idx)
+        if x != f"{value} 不在 IntHybridArray 中":
+            return x
+        raise ValueError(x)
+    def extend(self, iterable:Iterable) -> None:
+        if isinstance(iterable, (Iterator, Generator, map)):
+            iterable,copy = itertools.tee(iterable, 2)
+            len_ = sum(1 for _ in copy)
+        else:
+            len_ = len(iterable)
+        self.total_bits += len_*self.bit_length
+        for i,j in zip(range(len_),iterable):
+            self[-i-1] = j
+    def append(self,value):
+        self.total_bits += self.bit_length
+        self.size = self.total_bits
+        self[-1] = value

{bool_hybrid_array-9.11.9.dist-info → bool_hybrid_array-9.11.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bool-hybrid-array
-Version: 9.11.9
+Version: 9.11.10
 Summary: 一个高效的布尔数组（密集+稀疏混合存储，节省内存）
 Home-page: https://github.com/BKsell/bool-hybrid-array
 Author: 蔡靖杰
@@ -614,7 +614,8 @@ print(f"出队2个元素后: {q}")  # 输出：BHA_Queue([T,T,F,T,F])
 * **9.11.6**：修复从9.11.3版本开始cpython用户无法安装bool-hybrid-array包的问题
 * **9.11.7**：修复TypeError: 'map' object is not reversible的错误
 * **9.11.8**：增加了Windows系统Python3.14的C扩展优化
-* **9.11.9**：修复BHA_Queue的bug，新增cin和cout（使用方式：a = ctypes.c_int();cin >> a;cout << a）
+* **9.11.9**：修复BHA_Queue的bug，新增cin和cout（使用方式：a = ctypes.c_int();cin >> a;cout << a，支持各种ctypes类型、numpy标量）
+* **9.11.10**：修复cin的AttributeError的错误
 
 
 

bool_hybrid_array-9.11.10.dist-info/RECORD

@@ -0,0 +1,14 @@
+bool_hybrid_array/__init__.py,sha256=KzXCj4pevLEmZMp789nBkklGWOVGVy7iUohoA3cxhL8,1078
+bool_hybrid_array/__main__.py,sha256=uFyebfsZl1tW54AVcc6IDhk36BglTGb_Vw3Djx8pq00,8987
+bool_hybrid_array/_cppiostream.py,sha256=uisSGktor52VFxhTcMN011RtzuUE8O1Fgz2VltnPi3c,8447
+bool_hybrid_array/compile_core.pyd,sha256=_bSaBSVM8x_fkxdP_-4AiIYWVEkTgV3DWCPXzP-i-00,556544
+bool_hybrid_array/core.c,sha256=6jlDe0FTZweoWtfhabEQMOk7kfwaiPFDoe0yYPCMpS8,3230449
+bool_hybrid_array/core.py,sha256=nv-veRvbioLefXCe66Py1avxb7_8OZbT5CeyQm-ErQE,42031
+bool_hybrid_array/秘密.md,sha256=Ii2NvXmv-Ktu04zJsGLcQZvlzT4gOatByE4B2wTK1Ks,48
+bool_hybrid_array/int_array/__init__.py,sha256=CCKDUL5GBAXOprc9FhtLNL_rP4IDhvGVWJ-Dporp6YI,112
+bool_hybrid_array/int_array/core.py,sha256=hnXHSLabtbDCnO3JX0M5tsF0BWlQpjWKu7RplMx7i8A,6236
+bool_hybrid_array-9.11.10.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
+bool_hybrid_array-9.11.10.dist-info/METADATA,sha256=kmw6K6GnXPoBGWxeNaZ8Rm4HGPdjWwqIsw3WgP2gkM8,26133
+bool_hybrid_array-9.11.10.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+bool_hybrid_array-9.11.10.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
+bool_hybrid_array-9.11.10.dist-info/RECORD,,

{bool_hybrid_array-9.11.9.dist-info → bool_hybrid_array-9.11.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bool_hybrid_array-9.11.9.dist-info/RECORD

@@ -1,13 +0,0 @@
-bool_hybrid_array/__init__.py,sha256=QGalf9IbiqJSBW7wmbpduG333dmkQISsLMeQja-qtSg,1077
-bool_hybrid_array/__main__.py,sha256=pjoWN4Noa_K44fqQPqp8H-diKSDf0Da8hdWFgvWUigQ,9083
-bool_hybrid_array/compile_core.pyd,sha256=lriymUZtvs_ryeGM_K8gM33iCIfxRH5Zr5GPKhuNCtw,555520
-bool_hybrid_array/core.c,sha256=VN0qsWCaJc0lEz6zHt7AFJsUcTieM5hkNtSeKh4ilIs,3616205
-bool_hybrid_array/core.cp314-win_amd64.pyd,sha256=bAIpe0dUTBNMVbIDlZoBdtLsN7TmzaOo2KcY16BEvYU,633856
-bool_hybrid_array/core.py,sha256=A1Lwn91T9N9-BhRBDIKJjVzvBVS036Mnaal3bfXN4To,50424
-bool_hybrid_array/秘密.md,sha256=Ii2NvXmv-Ktu04zJsGLcQZvlzT4gOatByE4B2wTK1Ks,48
-bool_hybrid_array/int_array/__init__.py,sha256=HPBdZu5qlXaRI4n_oK6WhnG4ml8H-FP1G44igVxPJIA,6225
-bool_hybrid_array-9.11.9.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
-bool_hybrid_array-9.11.9.dist-info/METADATA,sha256=8aIKi87Xbs3_J6hkpDGIjFXhE9GiVB2qH2-hJJJXJ7Y,26038
-bool_hybrid_array-9.11.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bool_hybrid_array-9.11.9.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
-bool_hybrid_array-9.11.9.dist-info/RECORD,,