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

bool_hybrid_array/core.py

@@ -1,4 +1,9 @@
+# cython: language_level=3, boundscheck=False, wraparound=False, initializedcheck=False
 from __future__ import annotations
+try:from mypy_extensions import mypyc_attr
+except:
+    def mypyc_attr(*a,**k):
+        return lambda func:func
 import builtins
 from types import MappingProxyType
 import array,bisect,numpy as np
@@ -7,24 +12,29 @@ 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 Union,_GenericAlias
-hybrid_array_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')
     memcpy = msvcrt.memcpy
 except:
-    libc = ctypes.CDLL('libc.so.6')
-    memcpy = libc.memcpy
+    try:
+        libc = ctypes.CDLL('libc.so.6')
+        memcpy = libc.memcpy
+    except:
+        libc = ctypes.CDLL('libc.so')
+        memcpy = libc.memcpy
 memcpy.argtypes = (ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t)
 memcpy.restype = ctypes.c_void_p
-if 'UnionType' in types.__dict__:
-    class Union:
-        def __getitem__(self,*args):
-            return reduce(operator.or_, args)
-    Union = Union()
 if 'GenericAlias' in types.__dict__:
     _GenericAlias = types.GenericAlias
-class ResurrectMeta(abc.ABCMeta,metaclass=abc.ABCMeta):
+class ResurrectMeta(abc.ABCMeta,metaclass=abc.ABCMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
     name = 'ResurrectMeta'
     def __new__(cls, name, bases, namespace):
@@ -37,7 +47,7 @@ class ResurrectMeta(abc.ABCMeta,metaclass=abc.ABCMeta):
         super_cls.__setattr__('name', name)
         super_cls.__setattr__('bases', bases)
         super_cls.__setattr__('namespace', namespace)
-        super_cls.__setattr__('original_dict', dict(obj.__dict__))
+        super_cls.__setattr__('original_dict', dict(obj.__dict__))# type: ignore[assignment]
         try:del obj.original_dict["__abstractmethods__"]
         except:pass
         try:del obj.original_dict["_abc_impl"]
@@ -50,7 +60,7 @@ class ResurrectMeta(abc.ABCMeta,metaclass=abc.ABCMeta):
         except:pass
         try:del obj.original_dict['_abc_negative_cache_version']
         except:pass
-        super_cls.__setattr__('original_dict', MappingProxyType(obj.original_dict))
+        super_cls.__setattr__('original_dict', MappingProxyType(obj.original_dict))# type: ignore[assignment]
         return obj
     @lru_cache
     def __str__(cls):
@@ -62,14 +72,16 @@ class ResurrectMeta(abc.ABCMeta,metaclass=abc.ABCMeta):
             return f'ResurrectMeta(cls = {cls},{name = },{bases = },{namespace = })'
         return str(cls)
     def __del__(cls):
-        exec(f"builtins.{cls.__name__} = cls")
-        if not sys.is_finalizing():
-            print(f'警告：禁止删除常变量：{cls}！')
-            raise TypeError(f'禁止删除常变量：{cls}')
+        try:
+            setattr(builtins,cls.name,cls)
+            if not sys.is_finalizing():
+                print(f'警告：禁止删除常变量：{cls}！')
+                raise TypeError(f'禁止删除常变量：{cls}')
+        except NameError:pass
     def __hash__(cls):
         return hash(cls.name+cls.__module__)
     def __setattr__(cls,name,value):
-        if not hasattr(cls, 'x'):
+        if not hasattr(cls, 'x') or name.startswith('_'):
             super().__setattr__(name,value)
             return
         if hasattr(cls, 'name') and cls.name == 'BHA_Bool' and repr(value) in {'T','F'} and name in {'T','F'}:
@@ -101,7 +113,7 @@ class ResurrectMeta(abc.ABCMeta,metaclass=abc.ABCMeta):
         pass
     original_dict = MappingProxyType(original_dict)
 ResurrectMeta.__class__ = ResurrectMeta
-class BHA_Function(metaclass=ResurrectMeta):
+class BHA_Function(metaclass=ResurrectMeta):# type: ignore
     def __init__(self,v):
         self.data,self.module = v,__name__
     def __call__(self,*a,**b):
@@ -121,14 +133,16 @@ def {name}({params}):
         exec(func_code, globals(), local_namespace)
         dynamic_func = local_namespace[name]
         return cls(dynamic_func)
-class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
+@mypyc_attr(native_class=False)
+class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
+    @mypyc_attr(native_class=False)
     class _CompactBoolArray(Sequence,Exception):
         def __init__(self, size: int):
             self.size = size
             self.n_uint8 = (size + 7) >> 3
-            self.data = np.zeros(self.n_uint8, dtype=np.uint8)
-        def __setitem__(self, index: int | slice, value):
+            self.data = np.zeros(self.n_uint8, dtype=np.uint8)# type: ignore[assignment]
+        def __setitem__(self, index: int | slice, value: Any):
             ctypes_arr = self.data.ctypes.data_as(ctypes.POINTER(ctypes.c_ubyte))
             if isinstance(index, slice):
                 start, stop, step = index.indices(self.size)
@@ -155,6 +169,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
             ctypes_arr[uint8_pos] &= ~(1 << bit_offset) & 0xFF
             if value:
                 ctypes_arr[uint8_pos] |= (1 << bit_offset)
+
         def __getitem__(self, index: int | slice) -> bool | list[bool]:
             if isinstance(index, slice):
                 start, stop, step = index.indices(self.size)
@@ -180,7 +195,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
             new_instance = self.__class__(size=self.size)
             new_instance.data = self.data.copy()
             return new_instance
-    def __init__(self, split_index: int, size=None, is_sparse=False ,Type:Callable = None,hash_ = True) -> None:
+    def __init__(self, split_index: int, size=None, is_sparse=False ,Type:Callable = None,hash_:Any = True) -> None:
         self.Type = Type if Type is not None else builtins.BHA_Bool
         self.split_index = int(split_index)
         self.size = size or 0
@@ -217,7 +232,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
         return func
     def __hash__(self):
         return self._cached_hash
-    def accessor(self, i: int, value: bool|None = None) -> bool|None:
+    def accessor(self, i: int, value: Any = None) -> Any:
         def _get_sparse_info(index: int) -> tuple[int, bool]:
             pos = bisect.bisect_left(self.large, index)
             exists = pos < len(self.large) and self.large[pos] == index
@@ -241,7 +256,12 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
                     if pos < len(self.large):
                         del self.large[pos]
                 return None
-    def __getitem__(self, key:int|slice = -1) -> BoolHybridArray:
+    @overload
+    def __getitem__(self, idx: int, /) -> Any: ...
+    @overload
+    def __getitem__(self, idx: slice, /) -> list: ...
+
+    def __getitem__(self, key:int|slice = -1,/) -> Any:
         if isinstance(key, slice):
             start, stop, step = key.indices(self.size)
             return BoolHybridArr((self[i] for i in range(start, stop, step)),hash_ = self.hash_)
@@ -249,7 +269,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
         if 0 <= key < self.size:
             return self.Type(self.accessor(key))
         raise IndexError("索引超出范围")
-    def __setitem__(self, key: int | slice, value) -> None:
+    def __setitem__(self, key: int | slice, value:Any) -> None:
         if isinstance(key, int):
             adjusted_key = key if key >= 0 else key + self.size
             if not (0 <= adjusted_key < self.size):
@@ -284,15 +304,23 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     def __repr__(self) -> str:
         return(f"BoolHybridArray(split_index={self.split_index}, size={self.size}, "
         +f"is_sparse={self.is_sparse}, small_len={len(self.small)}, large_len={len(self.large)})")
-    def __delitem__(self, key: int = -1) -> None:
+    @overload
+    def __delitem__(self, key: int, /) -> None: ...
+    @overload
+    def __delitem__(self, key: slice, /) -> None: ...
+
+    def __delitem__(self, key: int|slice = -1,/) -> None:
         key = key if key >= 0 else key + self.size
+        if isinstance(key, slice):
+            start, stop, step = key.indices(self.size)
+            for i in range(start,stop,step):del self[i]
         if not (0 <= key < self.size):
             raise IndexError(f"索引 {key} 超出范围 [0, {self.size})")
         if key <= self.split_index:
             if key >= len(self.small):
                 raise IndexError(f"小索引 {key} 超出small数组范围（长度{len(self.small)}）")
-            self.small = np.delete(self.small, key)
-            self.small = np.append(self.small, not self.is_sparse)
+            self.small = np.delete(self.small, key)# type: ignore[assignment]
+            self.small = np.append(self.small, not self.is_sparse)# type: ignore[assignment]
             self.split_index -= min(self.split_index, len(self.small) - 1)
         else:
             pos = bisect.bisect_left(self.large, key)
@@ -307,7 +335,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     def __reversed__(self):
         if not self:return BHA_Iterator([])
         return BHA_Iterator(map(self.__getitem__,range(-1,-1,-1)))
-    def insert(self, key: int, value: bool) -> None:
+    def insert(self, key: int, value: Any) -> None:
         value = bool(value)
         key = key if key >= 0 else key + self.size
         key = max(0, min(key, self.size))
@@ -318,7 +346,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
                     (0, key - len(self.small) + 1),
                     constant_values=not self.is_sparse
                 )
-            self.small = np.insert(self.small, key, value)
+            self.small = np.insert(self.small, key, value)# type: ignore[assignment]
             self.split_index = min(self.split_index + 1, len(self.small) - 1)
         else:
             pos = bisect.bisect_left(self.large, key)
@@ -334,7 +362,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
         return BHA_Iterator(map(self.__getitem__,range(self.size)))
     def __next__(self):
         return next(self.generator)
-    def __contains__(self, value) -> bool:
+    def __contains__(self, value:Any) -> bool:
         if not isinstance(value, (bool,np.bool_,self.Type,BHA_bool)):return False
         if not self.size:return False
         for i in range(10):
@@ -348,9 +376,9 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     def __bool__(self) -> bool:
         return bool(self.size)
     def __any__(self):
-        return T in self
+        return builtins.T in self
     def __all__(self):
-        return F not in self
+        return builtins.F not in self
     def __eq__(self, other) -> bool:
         if not isinstance(other, (BoolHybridArray, list, tuple, np.ndarray, array.array)):
             return False
@@ -413,8 +441,6 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
         arr += other
         arr.optimize()
         return arr
-    def __invert__(self) -> BoolHybridArray:
-        return BoolHybridArr(not val for val in self)
     def __rand__(self, other) -> BoolHybridArray:
         if type(other) == int:
             other = bin(other)[2:]
@@ -535,7 +561,8 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     def __reduce__(self):
         return BoolHybridArr,(np.asarray(self),self.is_sparse,self.Type,self.hash_,),
     dequeue = lambda self:self.pop(0)
-class BoolHybridArr(BoolHybridArray,metaclass=ResurrectMeta):
+@mypyc_attr(native_class=False)
+class BoolHybridArr(BoolHybridArray,metaclass=ResurrectMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
     def __new__(cls, lst: Iterable = (), is_sparse=None, Type = None, hash_ = True, split_index = None) -> BoolHybridArray:
         a = isinstance(lst, (Iterator, Generator, map))
@@ -610,7 +637,8 @@ def FalsesArray(size, Type = None,hash_ = True):
     split_index = int(split_index) if split_index < 150e+7*2 else int(145e+7*2)
     return BoolHybridArray(split_index,size,True,Type = Type,hash_ = hash_)
 Bool_Array = np.arange(2,dtype = np.uint8)
-class BHA_bool(int,metaclass=ResurrectMeta):
+@mypyc_attr(native_class=False)
+class BHA_bool(int,metaclass=ResurrectMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
     def __new__(cls, value):
         core_value = bool(value)
@@ -644,16 +672,14 @@ class BHA_bool(int,metaclass=ResurrectMeta):
     def __len__(self):
         raise TypeError("'BHA_bool' object has no attribute '__len__'")
     __rand__,__ror__,__rxor__ = __and__,__or__,__xor__
-class BHA_Bool(BHA_bool,metaclass=ResurrectMeta):
+@mypyc_attr(native_class=False)
+class BHA_Bool(BHA_bool,metaclass=ResurrectMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
     @lru_cache
     def __new__(cls,v):
-        if(builtins.T == True)and(builtins.F == False):
-            return builtins.T if v else builtins.F
-        else:
-            builtins.T,builtins.F = BHA_Bool.T,BHA_Bool.F
-            return BHA_Bool.T if v else BHA_Bool.F
-class BHA_List(list,metaclass=ResurrectMeta):
+        return builtins.T if v else builtins.F
+@mypyc_attr(native_class=False)
+class BHA_List(list,metaclass=ResurrectMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
     def __init__(self,arr):
         def Temp(v):
@@ -717,7 +743,8 @@ class BHA_List(list,metaclass=ResurrectMeta):
     def to_ascii_art(self, width=20):
         art = '\n'.join([' '.join(['■' if j else ' '  for j in i]) for i in self])
         return art
-class BHA_Iterator(Iterator,metaclass=ResurrectMeta):
+@mypyc_attr(native_class=False)
+class BHA_Iterator(Iterator,metaclass=ResurrectMeta):# type: ignore
     __module__ = 'bool_hybrid_array'
     def __init__(self,data):
         self.data,self.copy_data = itertools.tee(iter(data),2)
@@ -738,12 +765,13 @@ class BHA_Iterator(Iterator,metaclass=ResurrectMeta):
         arr = np.fromiter(self, dtype=dtype)
         return arr.copy() if copy else arr.view()
     __rand__,__ror__,__rxor__ = __and__,__or__,__xor__
-class ProtectedBuiltinsDict(dict,metaclass=ResurrectMeta):
+@mypyc_attr(native_class=False)
+class ProtectedBuiltinsDict(dict,metaclass=ResurrectMeta):# type: ignore
     def __init__(self, *args, protected_names = ("T", "F", "BHA_Bool", "BHA_List", "BoolHybridArray", "BoolHybridArr",
                                 "TruesArray", "FalsesArray", "ProtectedBuiltinsDict", "builtins",
                                 "__builtins__", "__dict__","ResurrectMeta","math",
                                 "np","protected_names","BHA_Function",
-                                "__class__","Ask_BHA","Create_BHA","Ask_arr","numba_opt","bool_hybrid_array"),
+                                "__class__","Ask_BHA","Create_BHA","Ask_arr","numba_opt","bool_hybrid_array","BHA_Queue","cin","cout","endl"),
                  name = 'builtins', **kwargs):
         super().__init__(*args, **kwargs)
         if name == 'builtins':
@@ -838,7 +866,7 @@ def Ask_BHA(path):
         memcpy(arr.buffer_info()[0], bit_stream, total_len),arr)[-1]
         if(n := int(x, base=16),
         lead_zero := len(x) - len(x.lstrip('0')),
-        total_len := lead_zero + (n.bit_length() if n else 1))
+        total_len := lead_zero + n.bit_length())
         else array.array('B'))
         temp = BHA_List(map(temp2,temp))
         if len(temp) == 1:
@@ -854,7 +882,8 @@ class BHA_Queue:
     def enqueue(self,v):
         self.a.push(v)
     def dequeue(self):
-        if self.b:return self.b.pop()
+        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
@@ -886,7 +915,7 @@ def Create_BHA(path,arr):
             mm[:] = temp
             mm.flush()
 def numba_opt():
-    import numba
+    import numba # type: ignore
     sig = numba.types.Union([
         numba.types.intp(
             numba.types.Array(numba.types.uint32, 1, 'C'),
@@ -909,6 +938,215 @@ 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"
 builtins.np = np
 builtins.T = BHA_bool(1)
 builtins.F = BHA_bool(0)
@@ -926,7 +1164,11 @@ builtins.BHA_Function = BHA_Function
 builtins.Ask_BHA = Ask_BHA
 builtins.Create_BHA = Create_BHA
 builtins.numba_opt = numba_opt
-Tid,Fid = id(T),id(F)
+builtins.cin = cin
+builtins.cout = cout
+builtins.endl = endl
+builtins.BHA_Queue = BHA_Queue
+Tid,Fid = id(builtins.T),id(builtins.F)
 original_id = builtins.id
 def fake_id(obj):
     if isinstance(obj, BHA_bool):return Tid if obj else Fid
@@ -936,8 +1178,4 @@ original_builtins_dict = builtins.__dict__.copy()
 __builtins__ = ProtectedBuiltinsDict(original_builtins_dict)
 builtins = __builtins__
 sys.modules['builtins'] = builtins
-builtins.name = 'builtins'
-try:
-    sys.flags.optimize = 2
-except:
-    pass
+builtins.name = 'builtins'

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bool-hybrid-array
-Version: 9.11.7
+Version: 9.11.9
 Summary: 一个高效的布尔数组（密集+稀疏混合存储，节省内存）
 Home-page: https://github.com/BKsell/bool-hybrid-array
 Author: 蔡靖杰
@@ -613,6 +613,8 @@ print(f"出队2个元素后: {q}")  # 输出：BHA_Queue([T,T,F,T,F])
 * **9.11.5**：新增BHA_Queue双栈实现队列
 * **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）
 
 
 

bool_hybrid_array-9.11.9.dist-info/RECORD

@@ -0,0 +1,13 @@
+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,,

bool_hybrid_array-9.11.7.dist-info/RECORD

@@ -1,10 +0,0 @@
-bool_hybrid_array/__init__.py,sha256=MvnpVFUFs0Dtf69ZsTguNfXP2k1PHhR2e9Hwsz6weR4,1039
-bool_hybrid_array/__main__.py,sha256=pjoWN4Noa_K44fqQPqp8H-diKSDf0Da8hdWFgvWUigQ,9083
-bool_hybrid_array/core.py,sha256=QlAhD8TSRIym76ZjtfYdLsaqtz3Es_dYT754RMQoUoY,40854
-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.7.dist-info/licenses/LICENSE,sha256=Sg4rnGXkBDYkwJCWyxdWp5H60rhVAxpNvFh_l3JWZdY,1070
-bool_hybrid_array-9.11.7.dist-info/METADATA,sha256=Dsk-thuJ8y4ikh_JK2Ckht-ar5WhiwJow68-mLH_zL0,25858
-bool_hybrid_array-9.11.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bool_hybrid_array-9.11.7.dist-info/top_level.txt,sha256=vk-TD77wuVQsN1rJ6uVWZX4sC_wya_WplRDwQKJoBZM,18
-bool_hybrid_array-9.11.7.dist-info/RECORD,,