bool-hybrid-array 9.6.4__py3-none-any.whl → 9.10.19__py3-none-any.whl

bool_hybrid_array/core.py

@@ -2,28 +2,104 @@ from __future__ import annotations
 import builtins
 import array,bisect,numpy as np
 from collections.abc import MutableSequence,Iterable,Generator,Iterator,Sequence
-import itertools,copy,sys,math,weakref
+import itertools,copy,sys,math,weakref,random,mmap,os
 from functools import reduce
-import operator,ctypes,gc,abc
+import operator,ctypes,gc,abc,types
+from functools import lru_cache
+from typing import Union,_GenericAlias
 hybrid_array_cache = []
-current_module = sys.modules[__name__]
-class ResurrectMeta(abc.ABCMeta):
+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):
+    __module__ = 'bool_hybrid_array'
+    name = 'ResurrectMeta'
     def __new__(cls, name, bases, namespace):
         meta_bases = tuple(type(base) for base in bases)
         if cls not in meta_bases:
             meta_bases = (cls,) + meta_bases
-        cls.name,cls.bases,cls.namespace = name, bases, namespace
-        return super().__new__(cls, name, bases, namespace)
+        obj = super().__new__(cls, name, bases, namespace)
+        super_cls = super(ResurrectMeta, obj)
+        super_cls.__setattr__('x',None)
+        super_cls.__setattr__('name', name)
+        super_cls.__setattr__('bases', bases)
+        super_cls.__setattr__('namespace', namespace)
+        super_cls.__setattr__('original_dict', dict(obj.__dict__))
+        del obj.original_dict["__abstractmethods__"]
+        del obj.original_dict["_abc_impl"]
+        return obj
+    @lru_cache
     def __str__(cls):
         return super().__repr__()[8:][:-2]
-    def __repr__(cls):
-        name, bases, namespace = cls.name,cls.bases,cls.namespace
-        return f'ResurrectMeta(cls = {cls},{name = },{bases = },{namespace = })'
+    @lru_cache
+    def __repr__(cls,detailed = False):
+        if detailed:
+            name, bases, namespace = cls.name,cls.bases,cls.namespace
+            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}！')
+            print(f'警告：禁止删除常变量：{cls}！')
             raise TypeError(f'禁止删除常变量：{cls}')
+    def __hash__(cls):
+        return hash(cls.name+cls.__module__)
+    def __setattr__(cls,name,value):
+        if not hasattr(cls, 'x'):
+            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'}:
+            super().__setattr__(name,value)
+            return
+        if hasattr(cls, 'original_dict') and name in cls.original_dict:
+            raise AttributeError(f'禁止修改属性：{name}')
+        else:
+            super().__setattr__(name,value)
+    def __delattr__(cls,name):
+        if name in cls.original_dict:
+            raise AttributeError(f'禁止删除属性：{name}')
+        else:
+            super().__delattr__(name)
+    if 'UnionType' not in types.__dict__:
+        def __or__(self,other):
+            return Union[self,other]
+        __ror__ = __or__
+    def __getitem__(self,*args):
+        return _GenericAlias(self,args)
+    x = None
+    original_dict = {"__delattr__":__delattr__,"__getitem__":__getitem__,"__setattr__":__setattr__,"__hash__":__hash__,
+    "__new__":__new__,"__del__":__del__,"__str__":__str__,"__repr__":__repr__,"__class__":abc.ABCMeta,"original_dict":None}
+    try:
+        original_dict["original_dict"] = original_dict
+        original_dict["__ror__"] = __ror__
+        original_dict["__or__"] = __or__
+    except:
+        pass
+ResurrectMeta.__class__ = ResurrectMeta
+class BHA_Function(metaclass=ResurrectMeta):
+    def __init__(self,v):
+        self.data,self.module = v,__name__
+    def __call__(self,*a,**b):
+        return self.data(*a,**b)
+    def __getattr__(self,name):
+        return getattr(self.data,name)
+    @classmethod
+    def string_define(cls, name, text, positional, default):
+        param_strs = list(positional)
+        param_strs.extend([f"{k}={v!r}" for k, v in default.items()])
+        params = ", ".join(param_strs)
+        func_code = f"""
+def {name}({params}):
+    {text}
+        """
+        local_namespace = {}
+        exec(func_code, globals(), local_namespace)
+        dynamic_func = local_namespace[name]
+        return cls(dynamic_func)
 class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     __module__ = 'bool_hybrid_array'
     class _CompactBoolArray(Sequence,Exception):
@@ -45,10 +121,13 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
                     val_bool = bool(value)
                     for i in indices:
                         self._set_single(i, val_bool, ctypes_arr)
+                self.data = np.ctypeslib.as_array(ctypes_arr, shape=(self.n_uint8,))
                 return
             if not (0 <= index < self.size):
                 raise IndexError(f"密集区索引 {index} 超出范围 [0, {self.size})")
             self._set_single(index, bool(value), ctypes_arr)
+            self.data = np.ctypeslib.as_array(ctypes_arr, shape=(self.n_uint8,))
+            self.data = self.data.view()
         def _set_single(self, index: int, value: bool, ctypes_arr):
             uint8_pos = index >> 3
             bit_offset = index & 7
@@ -76,6 +155,10 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
             length = len(self.data)
             if value:ctypes.memset(ctypes_arr, 0xff, length)
             else:ctypes.memset(ctypes_arr, 0, length)
+        def copy(self):
+            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:
         self.Type = Type if Type is not None else builtins.BHA_Bool
         self.split_index = int(split_index)
@@ -189,7 +272,7 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
                 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.split_index = min(self.split_index, len(self.small) - 1)
+            self.split_index -= min(self.split_index, len(self.small) - 1)
         else:
             pos = bisect.bisect_left(self.large, key)
             if pos < len(self.large) and self.large[pos] == key:
@@ -223,22 +306,26 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     def __len__(self) -> int:
         return self.size
     def __iter__(self):
-        return BHA_Iterator(self[i] for i in range(self.size))
+        return BHA_Iterator(map(self.__getitem__,range(self.size)))
     def __next__(self):
         return next(self.generator)
     def __contains__(self, value) -> bool:
         if not isinstance(value, (bool,np.bool_,self.Type,BHA_bool)):return False
-        b = any(1 for i in range(self.small.size>>1) if value==self.small[i] or value==self.small[self.small.size-i-1])
+        if not self.size:return False
+        for i in range(10):
+            if self[random.randint(0,self.size-1)] == value:
+                return True
+        b = any(1 for i in range(self.small.size+1>>1) if value==self.small[i] or value==self.small[self.small.size-i-1])
         if value == self.is_sparse:
             return self.large or b
         else:
             return len(self.large) == self.size-self.split_index-1 or b
     def __bool__(self) -> bool:
-        return self.size > 0
+        return self.size
     def __any__(self):
-        return self.count(True)>0
+        return T in self
     def __all__(self):
-        return self.count(True)==len(self)
+        return F not in self
     def __eq__(self, other) -> bool:
         if not isinstance(other, (BoolHybridArray, list, tuple, np.ndarray, array.array)):
             return False
@@ -255,9 +342,9 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
             raise ValueError(f"与运算要求数组长度相同（{len(self)} vs {len(other)}）")
         return BoolHybridArr(map(operator.and_, self, other),hash_ = self.hash_)
     def __int__(self):
-        if self.size == 0:
+        if not self.size:
             return 0
-        return reduce(lambda acc, val: operator.or_(operator.lshift(acc, 1), val),self,0)
+        return reduce(lambda acc, val: operator.or_(operator.lshift(acc, 1), int(val)),self,0)
     def __or__(self, other) -> BoolHybridArray:
         if type(other) == int:
             other = bin(other)[2:]
@@ -316,14 +403,15 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
     def __invert__(self) -> BoolHybridArray:
         return BoolHybridArr(not a for a in self)
     def copy(self) -> BoolHybridArray:
-        arr = BoolHybridArr(self)
-        arr.large,arr.small,arr.split_index,arr.is_sparse,arr.Type = (self.large,self.small,
-        self.split_index,self.is_sparse,self.Type)
+        arr = BoolHybridArray(split_index = self.split_index,size = self.size)
+        arr.large,arr.small,arr.split_index,arr.is_sparse,arr.Type,arr.size = (array.array(self.large.typecode, self.large),self.small.copy(),
+        self.split_index,BHA_Bool(self.is_sparse),self.Type,self.size)
         return arr
     def __copy__(self) -> BoolHybridArray:
         return self.copy()
     def find(self,value):
-        return BHA_List([i for i in range(len(self)) if self[i]==value])
+        from .int_array import IntHybridArray
+        return IntHybridArray([i for i in range(len(self)) if self[i]==value])
     def extend(self, iterable:Iterable) -> None:
         if isinstance(iterable, (Iterator, Generator, map)):
             iterable,copy = itertools.tee(iterable, 2)
@@ -337,13 +425,30 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
         self.size += 1
         self[-1] = v
     def index(self, value) -> int:
+        if self.size == 0:
+            raise ValueError('无法在空的 BoolHybridArray 中查找元素！')
         value = bool(value)
         x = 'not find'
         for i in range(self.size):
             if self[i] == value:
                 return i
-            elif self[-i] == value:
-                x = len(self)-i
+            if self[-i] == value:
+                x = self.size-i
+            if len(self)-i == i:
+                break
+        if x != 'not find':
+            return x
+        raise ValueError(f"{value} not in BoolHybridArray")
+    def rindex(self, value) -> int:
+        if self.size == 0:
+            raise ValueError('无法在空的 BoolHybridArray 中查找元素！')
+        value = bool(value)
+        x = 'not find'
+        for i in range(self.size):
+            if self[-i] == value:
+                return -i
+            if self[i] == value:
+                x = -(self.size-i)
             if len(self)-i == i:
                 break
         if x != 'not find':
@@ -389,6 +494,15 @@ class BoolHybridArray(MutableSequence,Exception,metaclass=ResurrectMeta):
         }
     def get_shape(self):
         return (self.size,)
+    def __array__(self,dtype = np.bool_,copy = None):
+        arr = np.fromiter(map(np.bool_,self), dtype=dtype)
+        return arr.copy() if copy else arr.view()
+    def view(self):
+        arr = TruesArray(0)
+        arr.__dict__ = self.__dict__
+        return arr
+    def __reduce__(self):
+        return BoolHybridArr,(np.asarray(self),self.is_sparse,self.Type,self.hash_,),
 class BoolHybridArr(BoolHybridArray,metaclass=ResurrectMeta):
     __module__ = 'bool_hybrid_array'
     def __new__(cls, lst: Iterable, is_sparse=None, Type = None, hash_ = True) -> BoolHybridArray:
@@ -407,7 +521,7 @@ class BoolHybridArr(BoolHybridArray,metaclass=ResurrectMeta):
         split_index = int(min(size * 0.8, math.sqrt(size) * 100))
         split_index = math.isqrt(size) if true_count>size/3*2 or true_count<size/3 else max(split_index, 1)
         split_index = int(split_index) if split_index < 150e+7*2 else int(145e+7*2)
-        arr = BoolHybridArray(split_index, size, is_sparse, Type, hash_ = F)
+        arr = BoolHybridArray(split_index = split_index, size = size, is_sparse = is_sparse, Type = Type, hash_ = F)
         small_max_idx = min(split_index, size - 1)
         if a:
             small_data = []
@@ -436,6 +550,7 @@ class BoolHybridArr(BoolHybridArray,metaclass=ResurrectMeta):
         arr.large = array.array(type_, arr.large)
         if hash_:
             global hybrid_array_cache
+            del hybrid_array_cache[-1]
             hybrid_array_cache = [
                 (ref, h) for ref, h in hybrid_array_cache 
                 if ref() is not None
@@ -448,7 +563,7 @@ class BoolHybridArr(BoolHybridArray,metaclass=ResurrectMeta):
                     elif arr == existing_array:
                         arr._cached_hash = existing_hash
                         return arr
-                except Exception:
+                except:
                     continue
         return arr
 def TruesArray(size, Type = None, hash_ = True):
@@ -470,36 +585,39 @@ class BHA_bool(int,metaclass=ResurrectMeta):
         instance.data = Bool_Array[1] if core_value else Bool_Array[0]
         instance.value = core_value
         return instance
+    @lru_cache
     def __str__(self):
         return 'True' if self else 'False'
+    @lru_cache
     def __repr__(self):
         return 'T' if self else 'F'
+    @lru_cache
     def __bool__(self):
         return self.value
+    @lru_cache
     def __int__(self):
         return int(self.data)
-    def __eq__(self,other):
-        return self.value is bool(other)
+    @lru_cache
     def __or__(self,other):
         return BHA_Bool(self.value|other)
+    @lru_cache
     def __and__(self,other):
         return BHA_Bool(self.value&other)
+    @lru_cache
     def __xor__(self,other):
         return BHA_Bool(self.value^other)
-    def __del__(self):
-        global T, F
-        print(f'你删除了1个常变量！可回收变量数：{gc.collect()}')
-        if self:builtins.T = self
-        else:builtins.F = self
-        if not sys.is_finalizing():
-            raise TypeError(f'禁止删除常变量{repr(self)}！')
+    def __hash__(self):
+        return hash(self.data)
+    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):
     __module__ = 'bool_hybrid_array'
+    @lru_cache
     def __new__(cls,v):
-        try:
-            return T if v else F
-        except NameError:
+        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):
@@ -517,12 +635,16 @@ class BHA_List(list,metaclass=ResurrectMeta):
             else:
                 return v
         super().__init__(map(Temp,arr))
+        try:self.hash_value = sum(map(hash,self))
+        except Exception as e:return hash(e)
+    def __hash__(self):
+        return self.hash_value
     def __call__(self, func):
         func.self = self
-        def wrapper(self, *args, **kwargs):
+        def wrapper(*args, **kwargs):
             return func(self, *args, **kwargs)
         setattr(self, func.__name__, wrapper)
-        return wrapper
+        return func
     def __str__(self):
         def Temp(v):
             if isinstance(v,(BoolHybridArray,np.ndarray,BHA_List,array.array)):
@@ -576,32 +698,137 @@ class BHA_Iterator(Iterator,metaclass=ResurrectMeta):
         return BHA_Iterator(map(operator.and_, self, other))
     def __xor__(self,other):
         return BHA_Iterator(map(operator.xor, self, other))
+    def __array__(self,dtype = None,copy = None):
+        arr = np.fromiter(self, dtype=dtype)
+        return arr.copy() if copy else arr.view()
     __rand__,__ror__,__rxor__ = __and__,__or__,__xor__
-def module_setattr(name, value):
-    if name in current_module.__dict__:
-        raise AttributeError(f"禁止修改常量 {name}")
-    current_module.__dict__[name] = value
-def module_delattr(name):
-    if name in current_module.__dict__:
-        raise AttributeError(f"禁止删除常量 {name}")
-    raise AttributeError(f"常量 {name} 不存在")
-current_module.__setattr__ = module_setattr
-current_module.__delattr__ = module_delattr
-original_builtins_setattr = builtins.__setattr__
-def protected_builtins_setattr(name, value):
-    protected_names = ["T", "F", "BHA_Bool", "BHA_List", "BoolHybridArray", "BoolHybridArr", "TruesArray", "FalsesArray"]
-    if name in protected_names:
-        print(f"警告：禁止修改内置常量 builtins.{name}！")
-        raise AttributeError(f"禁止修改内置常量 builtins.{name}")
-    original_builtins_setattr(name, value)
-def protected_builtins_delattr(name):
-    protected_names = ["T", "F", "BHA_Bool", "BHA_List", "BoolHybridArray", "BoolHybridArr", "TruesArray", "FalsesArray"]
-    if name in protected_names:
-        print(f"警告：禁止删除内置常量 builtins.{name}！")
-        raise AttributeError(f"禁止删除内置常量 builtins.{name}")
-    original_builtins_delattr(name)
-builtins.__setattr__ = protected_builtins_setattr
-builtins.__delattr__ = protected_builtins_delattr
+class ProtectedBuiltinsDict(dict,metaclass=ResurrectMeta):
+    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"],
+                 name = 'builtins', **kwargs):
+        super().__init__(*args, **kwargs)
+        if name == 'builtins':
+            super().__setattr__('__dict__',self)
+            super().__setattr__('builtins',self)
+            super().__setattr__('__builtins__',self)
+        self.name = name
+        self.protected_names = protected_names
+    def __setitem__(self, name, value):
+        if name in ["T", "F"]:
+            current_T = self.get("T")
+            current_F = self.get("F")
+            if isinstance(current_T, BHA_bool) and isinstance(current_F, BHA_bool):
+                is_swap = (name == "T" and isinstance(value, BHA_bool) and value.value == current_F.value)or(name == "F" and isinstance(value, BHA_bool) and value.value == current_T.value)
+                if is_swap:
+                    print(f"""警告：禁止交换内置常量 __{self.name}__["{name}"] 和 __builtins__["{'F' if name == 'T' else 'T'}"]！""")
+                    raise AttributeError(f"""禁止交换内置常量 __{self.name}__["{name}"] 和 __{self.name}__["{'F' if name == 'T' else 'T'}"]""")
+        if name in self.protected_names and name not in ["T", "F"]:
+            print(f"警告：禁止修改内置常量 __{self.name}__['{name}']！")
+            raise AttributeError(f"禁止修改内置常量 __{self.name}__['{name}']")
+        super().__setitem__(name, value)
+    def __delitem__(self, name):
+        if name in self.protected_names:
+            print(f"警告：禁止删除内置常量 __builtins__['{name}']！")
+            raise AttributeError(f"禁止删除内置常量 __builtins__['{name}']")
+        if name in self:
+            super().__delitem__(name)
+    def __delattr__(self, name):
+        if name in self.protected_names:
+            raise AttributeError(f'禁止删除内置常量：{self.name}.{name}')
+        else:
+            del self[name]
+    def __getattr__(self, name):
+        if name in self:
+            return self[name]
+        else:
+            raise AttributeError(f"module 'builtins' has no attribute '{name}'")
+    def __setattr__(self,name,value):
+        try:protected = self.protected_names
+        except Exception:protected = self
+        if(name in protected)and(not sys.is_finalizing())and(name != '_'):
+            raise AttributeError(f'禁止修改内置常量：{self.name}.{name}')
+        else:
+            super().__setattr__(name,value)
+    def __import__(self, name, globals=None, locals=None, fromlist=(), level=0):
+        if fromlist:
+            result = []
+            for key in fromlist:
+                if key not in self:
+                    raise AttributeError(f"'ImportableDict' object has no attribute '{key}'")
+                result.append(self[key])
+            return result[0] if len(result) == 1 else tuple(result)
+        return self
+def Ask_arr(arr):
+    if isinstance(arr,BHA_List):
+        return '\n'.join(map(Ask_arr,arr))
+    elif isinstance(arr,BoolHybridArray):
+        h = hex(int(arr))[2:]
+        h = '0'*(arr.size - len(bin(int(arr)))+2)+h
+        return h
+    else:
+        return str(arr)
+def Ask_BHA(path):
+    if '.bha' not in path.lower():
+        path += '.bha'
+    with open(path, 'a+b') as f:
+        f.seek(0)
+        file_size = os.fstat(f.fileno()).st_size
+        if not file_size:
+            return TruesArray(0)
+        if os.name == 'nt':
+            mm = mmap.mmap(f.fileno(), file_size, access=mmap.ACCESS_READ)
+        else:
+            mm = mmap.mmap(f.fileno(), file_size, flags=mmap.MAP_PRIVATE, prot=mmap.PROT_READ)
+        with mm:
+            temp = mm.read().decode('utf-8').strip()
+        temp = temp.split()
+        temp2 = lambda x:BoolHybridArr(map(int,'0'*(len(x) - len(x.lstrip('0')))+bin(int(x,base = 16))[2:]),hash_ = F)
+        temp = BHA_List(map(temp2,temp))
+        if len(temp) == 1:
+            return temp[0]
+        return temp
+def Create_BHA(path,arr):
+    if '.bha' not in path.lower():
+        path += '.bha'
+    temp = Ask_arr(arr).strip().encode('utf-8')
+    with open(path, "w+b") as f:
+        f.truncate(len(temp))
+        if not len(temp):
+            return
+        with mmap.mmap(
+            f.fileno(),
+            length=len(temp),
+            access=mmap.ACCESS_WRITE
+        ) as mm:
+            mm[:] = temp
+            mm.flush()
+def numba_opt():
+    import numba
+    sig = numba.types.Union([
+        numba.types.intp(
+            numba.types.Array(numba.types.uint32, 1, 'C'),
+            numba.types.uint32,
+            numba.types.uint32,
+            numba.types.Optional(numba.types.uint32)
+        ),
+        numba.types.intp(
+            numba.types.Array(numba.types.uint64, 1, 'C'),
+            numba.types.uint64,
+            numba.types.uint64,
+            numba.types.Optional(numba.types.uint64)
+        ),
+        numba.types.intp(
+            numba.types.Any,
+            numba.types.Any,
+            numba.types.Any,
+            numba.types.Optional(numba.types.Any)
+        )
+    ])
+    bisect.bisect_left = numba.njit(sig, cache=True)(bisect.bisect_left)
+    bisect.bisect_right = numba.njit(sig, cache=True)(bisect.bisect_right)
 builtins.np = np
 builtins.T = BHA_bool(1)
 builtins.F = BHA_bool(0)
@@ -612,6 +839,25 @@ builtins.TruesArray = TruesArray
 builtins.BoolHybridArr = BoolHybridArr
 builtins.BHA_Iterator = BHA_Iterator
 builtins.BoolHybridArray = BoolHybridArray
-builtins.builtins = builtins
 builtins.BHA_Bool.T,builtins.BHA_Bool.F = BHA_bool(1),BHA_bool(0)
-builtins.ResurrectMeta = ResurrectMeta
+builtins.ResurrectMeta = ResurrectMeta
+builtins.ProtectedBuiltinsDict = ProtectedBuiltinsDict
+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)
+original_id = builtins.id
+def fake_id(obj):
+    if isinstance(obj, BHA_bool):return Tid if obj else Fid
+    else:return original_id(obj)
+builtins.id = fake_id
+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