gf~dZddlmZmZmZmZddlZddlZddlZ d dZ dZ dZ Gdde Z Gd d ee Zy) z) flyingcircus.BitField: Bit Field class. )divisionabsolute_importprint_functionunicode_literalsNc||*tj}|jj}|j |S)a Perform string formatting from a mapping source. Args: text (str): Text to format. source (Mapping|None): The mapping to use as source. If None, uses caller's `vars()`. Returns: result (str): The formatted text. Examples: >>> a, b, c = 1, 2, 3 >>> dd = dict(a=10, b=20, c=30) >>> fmtm('{a} + {a} = {b}') '1 + 1 = 2' >>> fmtm('{a} + {a} = {b}', dd) '10 + 10 = 20' >>> fmtm('{} + {} = {}', 2, 2, 4) # doctest:+ELLIPSIS Traceback (most recent call last): ... TypeError: ... >>> fmtm('{b} + {b} = {}', 4) # doctest:+ELLIPSIS Traceback (most recent call last): ... TypeError: ... )inspect currentframef_backf_locals format_map)textsourceframes m/var/dept/share/cheung/public_html/OutSchool/python/env/lib/python3.12/site-packages/flyingcircus/BitField.pyfmtmrs5<~$$&&& ??6 ""c#6K|r|dzdk(|dz}|ryyw)a  Get the bit values for a number (lower to higher significance). Args: value (int): The input value. Yields: result (int): The bits. Examples: >>> list(bits(100)) [False, False, True, False, False, True, True] N)values rbitsr9s( qyQ !  sc#pK|j}t|dz ddD]}||z dzdk(yw)a Get the reversed bit values for a number (higher to lower significance). Args: value (int): The input value. Yields: result (int): The bits. Examples: >>> list(bits(100)) [False, False, True, False, False, True, True] rN) bit_lengthrange)rbis rbits_rrOsF A 1q5"b !& aA%%&s46ceZdZdZy) BitFieldMetac|d}|d}t|tt|k7rttd||vrttdtj ||||S)NKEYSEMPTYz{cls_name}.KEYS must be uniquez/{cls_name}.EMPTY must not be in {cls_name}.KEYS)sortedset ValueErrorrtype__new__)mcscls_name cls_basescls_dictkeysemptys rr(zBitFieldMeta.__new__fsu! $<6#d), ,568 8 D=FGI I||C9h??rN)__name__ __module__ __qualname__r(rrrr r es @rr c&eZdZdZej ZdZdZdZ d3fd Z e fdZ e jfdZ e jdZ ed Ze d Zej$Ze d Zd Zd ZdZdZdZdZdZdZdZdZdZdZeZ eZ!dZ"dZ#dZ$dZ%d4dZ&d5dZ'dZ(dZ)d Z*e*Z+e)Z,d!Z-d"Z.e.Z/e-Z0d#Z1d$Z2d%Z3d&Z4d'Z5d(Z6d)Z7d*Z8d+Z9d,Z:e:Z;e d6d-Zd0Z?fd1Z@d2ZAxZBS)8BitFielda Generic bit-field class. The recommended usage is to subclass for specialized representations. Typically, while subclassing, `KEYS` and `EMPTY` should probably be replaced. Additionally, `FULL_REPR` and `IGNORE_INVALID` control the bit-field default behavior. In particular: - `KEYS` determines which flags to use for encoding/decoding the bit-field. **IMPORTANT!**: Items in `KEYS` must be unique. - `EMPTY` is used during encoding/decoding for marking empty/unset flags. **IMPORTANT!**: `EMPTY` must not be present in `KEYS`. - `FULL_REPR` determines whether the default decoding, including its string representation, should include empty/unset flags. - `IGNORE_INVALID` determines whether invalid input values should be ignored during encoding or rather a ValueError should be raised. Examples: >>> print(BitField(127)) BitField(abcdefg) >>> repr(BitField(127)) "BitField(0b1111111){'a': True, 'b': True, 'c': True, 'd': True, 'e': True, 'f': True, 'g': True, 'h': False, 'i': False, 'j': False, 'k': False, 'l': False, 'm': False, 'n': False, 'o': False, 'p': False, 'q': False, 'r': False, 's': False, 't': False, 'u': False, 'v': False, 'w': False, 'x': False, 'y': False, 'z': False, 'A': False, 'B': False, 'C': False, 'D': False, 'E': False, 'F': False, 'G': False, 'H': False, 'I': False, 'J': False, 'K': False, 'L': False, 'M': False, 'N': False, 'O': False, 'P': False, 'Q': False, 'R': False, 'S': False, 'T': False, 'U': False, 'V': False, 'W': False, 'X': False, 'Y': False, 'Z': False}" >>> int(BitField(12)) 12 >>> print(BitField(8) + BitField(1)) BitField(ad) >>> print(BitField('a') + BitField('d')) BitField(ad) >>> print(list(BitField(11))) ['a', 'b', 'd'] >>> print(list(reversed(BitField(11)))) ['d', 'b', 'a'] >>> class UnixPermissions(BitField): ... KEYS = 'rwx' ... EMPTY = '-' ... FULL_REPR = True >>> acl = UnixPermissions() >>> print(acl) UnixPermissions(---) >>> repr(acl) "UnixPermissions(0b0){'r': False, 'w': False, 'x': False}" >>> acl.r = True >>> print(acl) UnixPermissions(r--) >>> acl['x'] = True >>> print(acl) UnixPermissions(r-x) >>> acl.BitField = 7 >>> print(acl) UnixPermissions(rwx) >>> del acl.x >>> print(acl) UnixPermissions(rw-) >>> class RGB(BitField): ... KEYS = ['red', 'green', 'blue'] ... EMPTY = None ... FULL_REPR = True >>> rgb = RGB() >>> print(rgb) RGB([None, None, None]) >>> repr(rgb) "RGB(0b0){'red': False, 'green': False, 'blue': False}" >>> rgb.red = True >>> print(rgb) RGB(['red', None, None]) >>> rgb['blue'] = True >>> print(rgb) RGB(['red', None, 'blue']) >>> print(list(rgb)) ['red', 'blue'] >>> rgb.BitField = 7 >>> print(rgb) RGB(['red', 'green', 'blue']) >>> del rgb.blue >>> print(rgb) RGB(['red', 'green', None])  FTct|}t|| ddt|tr||_y|j ||j|j|j|_y)aR Instantiate a BitField object. Args: BitField (int|Sequence): The input bit-field. If int, the flags of the bit-field are according to the bit boolean values. If a sequence, uses `KEYS` to encode the input into the corresponding bit-field, using `from_keys()` method. The value of `EMPTY` is used to mark empty / unset bits. The value of `IGNORE_INVALID` determines whether invalid items in the sequence are ignored or will raise a ValueError. _BitFieldN) r'super __setattr__ isinstanceintr3encoder"r#IGNORE_INVALID)selfr3cls __class__s r__init__zBitField.__init__sX 4j h)+t< h $$DM KK#((CIIs/A/ACDMrc*tt| dS)Nr6)r7r3__getattribute__)r=r?s rr3zBitField.BitFieldsXt5kBBrcd|jzdz }d|cxkr|krnntt|d|yt t d)Nrrr6z]{self.__class__.__name__}() bit-field must be between 0 and {max_BitField}, not `{BitField_}`)sizer7r3r8r&r)r= BitField_ max_BitFieldr?s rr3zBitField.BitFieldsLTYY!+ )\ ) (D -k9 ET;<= =rc|`yNr6r=s rr3zBitField.BitFields Nrct|jtt|jk(}|j|jv}|xr|SrH)r$r"r%r#)r> valid_keys valid_emptys ris_validzBitField.is_valids?CHH%CHH )>> iisxx/ )k)rc>tt|jS)aN Compute the maximum lenght for the bit-field (given the class keys). Returns: result (int): The maximum length for the bit-field. Examples: >>> BitField().size 52 >>> BitField(123).size 52 >>> len(BitField(123)) 52 )lenr'r"rJs rrDz BitField.size s 4:??##rc6|jjS)a  Compute the actual lenght for the bit-field. Returns: result (int): The actual length of the bit-field. Examples: >>> BitField().active_len 0 >>> BitField(123).active_len 7 )r6rrJs r active_lenzBitField.active_len"s~~((**rc#nKt|jD]}|jd|zzdkDyw)a) Iterate forward over the bit-field values. The iteration is from the least to the most significant bit. Yields: value (bool): The next bit value. Examples: >>> print(list(BitField('ac').values())) [True, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False] >>> print(list(BitField(11).values())) [True, True, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False] rrNrrDr6r=rs rvalueszBitField.values3s8.tyy! 2A>>Q!V,1 1 2s35c#xKt|jdz ddD]}|j|z dzdkDyw)a2 Iterate backward over the bit-field values. The iteration is from the most to the least significant bit. Yields: value (bool): The previous bit value. Examples: >>> print(list(BitField('ac').values_r())) [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, True] >>> print(list(BitField(11).values_r())) [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, True, True] rrrNrTrUs rvalues_rzBitField.values_rNsA.tyy1}b"- 2ANNa'1,1 1 2s8:c#JKt|jEd{y7w)ar Iterate forward over the active bit-field values. Yields: value (bool): The next active value. Examples: >>> flags = BitField('ac') >>> print(list(flags.active_values())) [True, False, True] >>> print(list(BitField(11).active_values())) [True, True, False, True] N)rr6rJs r active_valueszBitField.active_valuesis''' #!#c#JKt|jEd{y7w)aw Iterate backward over the active bit-field values. Yields: value (bool): The previous active value. Examples: >>> flags = BitField('ac') >>> print(list(flags.active_values())) [True, False, True] >>> print(list(BitField(11).active_values())) [True, True, False, True] N)rr6rJs ractive_values_rzBitField.active_values_rzs$..)))r[c#HKt|jD]}|yw)z Yields the keys of the bit-field. Yields: key (str): The next key. Examples: >>> print(''.join((BitField(7).keys()))) abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ N)r'r"r=keys rr-z BitField.keyss$:?? CI s "c#ZKtt|jD]}|yw)a  Yields the keys of the bit-field in reversed order. Yields: key (str): The previous key. Examples: >>> print(''.join((BitField(7).keys_r()))) ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba N)reversedr'r"r_s rkeys_rzBitField.keys_rs)DJOO, CI s)+c#Ktt|jt|jD] \}}|s |yw)a$ Yields the active keys of the bit-field. Yields: key (str): The next key. Examples: >>> print(list(BitField(7).active_keys())) ['a', 'b', 'c'] >>> print(list(BitField(5).active_keys())) ['a', 'c'] Nzipr'r"rr6r=r`rs r active_keyszBitField.active_keyss>T dnn!57 JC  s ;AAc#Kttt|jd|jt |j D] \}}|s |yw)z Yields the active keys of the bit-field in reversed order. Yields: key (str): The previous key. Examples: >>> print(list(BitField(7).active_keys_r())) ['c', 'b', 'a'] Nrfrbr'r"rRrr6rgs r active_keys_rzBitField.active_keys_rsRd)9$//:;t~~&( JC  s AAAc#Ktt|j|jD] \}}||f yw)a\ Yields the key-value pairs of the bit-field. Yields: key (str): The next key. value (bool): The next value. Examples: >>> print(dict(BitField(7).items())) {'a': True, 'b': True, 'c': True, 'd': False, 'e': False, 'f': False, 'g': False, 'h': False, 'i': False, 'j': False, 'k': False, 'l': False, 'm': False, 'n': False, 'o': False, 'p': False, 'q': False, 'r': False, 's': False, 't': False, 'u': False, 'v': False, 'w': False, 'x': False, 'y': False, 'z': False, 'A': False, 'B': False, 'C': False, 'D': False, 'E': False, 'F': False, 'G': False, 'H': False, 'I': False, 'J': False, 'K': False, 'L': False, 'M': False, 'N': False, 'O': False, 'P': False, 'Q': False, 'R': False, 'S': False, 'T': False, 'U': False, 'V': False, 'W': False, 'X': False, 'Y': False, 'Z': False} N)rfr'r"rVrgs ritemszBitField.itemss:(d4joot{{}= JCu*  s=?c#Kttt|j|j D] \}}||f yw)a^ Yields the key-value pairs of the bit-field. Yields: key (str): The next key. value (bool): The next value. Examples: >>> print(dict(BitField(7).items_r())) {'Z': False, 'Y': False, 'X': False, 'W': False, 'V': False, 'U': False, 'T': False, 'S': False, 'R': False, 'Q': False, 'P': False, 'O': False, 'N': False, 'M': False, 'L': False, 'K': False, 'J': False, 'I': False, 'H': False, 'G': False, 'F': False, 'E': False, 'D': False, 'C': False, 'B': False, 'A': False, 'z': False, 'y': False, 'x': False, 'w': False, 'v': False, 'u': False, 't': False, 's': False, 'r': False, 'q': False, 'p': False, 'o': False, 'n': False, 'm': False, 'l': False, 'k': False, 'j': False, 'i': False, 'h': False, 'g': False, 'f': False, 'e': False, 'd': False, 'c': True, 'b': True, 'a': True} N)rfrbr'r"rXrgs ritems_rzBitField.items_rsB(d)4==?< JCu*  sAAc#Ktt|jt|jD]\}}|s ||fyw)ay Yields the active key-value pairs of the bit-field. Yields: key (str): The next key. value (bool): The next value. Examples: >>> print(dict(BitField(7).active_items())) {'a': True, 'b': True, 'c': True} >>> print(dict(BitField(5).active_items())) {'a': True, 'c': True} Nrergs r active_itemszBitField.active_itemssCT dnn!57 !JC5j  !s ;A Ac#Kttt|jd|jt |j D]\}}|s ||fyw)a} Yields the active key-value pairs of the bit-field. Yields: key (str): The next key. value (bool): The next value. Examples: >>> print(dict(BitField(7).active_items_r())) {'c': True, 'b': True, 'a': True} >>> print(dict(BitField(5).active_items_r())) {'c': True, 'a': True} Nrjrgs ractive_items_rzBitField.active_items_rsWd)9$//:;t~~&( !JC5j  !s AA Act|tr|jj|}|jd|zzdkDS)a Get the value at the specified key or position. Args: key (int|str): The index or key of the item. Returns: result (bool): The bit value at the given index in the bit-field. Examples: >>> flags = BitField('ac') >>> print([flags[i] for i in range(flags.active_len)]) [True, False, True] >>> print([flags[c] for c in 'abc']) [True, False, True] rrr9strr"indexr6r_s r __getitem__zBitField.__getitem__,s8" c3 ))//#&C!s(+q00rct|tr|jj|}|r|jd|zz|_y|jd|zz|_y)a Set the item at the specified position. Args: key (int|str): The index or key of the item. value (bool): The bit value to set. Returns: None. Examples: >>> flags = BitField('c') >>> flags[0] = True >>> print(flags) BitField(ac) >>> flags[0] = False >>> print(flags) BitField(c) >>> flags[1] = True >>> print(flags) BitField(bc) >>> flags[2] = False >>> print(flags) BitField(b) >>> flags['a'] = True >>> print(flags) BitField(ab) >>> flags['b'] = False >>> print(flags) BitField(a) rNrurgs r __setitem__zBitField.__setitem__BsN@ c3 ))//#&C !^^qCx8DN!^^Sk9DNrc||}d||<|S)a Unset the item at the specified position. Args: key (int|str): The index or key of the item. Returns: result (bool): The bit value before deletion. Examples: >>> flags = BitField(7) >>> print(flags) BitField(abc) >>> del flags[0] >>> print(flags) BitField(bc) >>> del flags['b'] >>> print(flags) BitField(c) Fr)r=r` bit_values r __delitem__zBitField.__delitem__js*I S rc||jvS)a Check if the specified key is present in the bit-field. Args: key (str): The key of the item. Returns: result (bool): The result of the check. Examples: >>> 'a' in BitField() True >>> 'fc' in BitField() False >>> 'a' in BitField(0) and 'a' in BitField(1) True )r"r_s r __contains__zBitField.__contains__s$diirc|||jj|S|||jj||S|||jj||S|jj|||S)a Return the index of a specific key. Args: key (str): The key of the item. start (int|None): The minimum index to look into. stop (int|None): The maximum index to look into. Returns: result (int): The index corresponding to a specific key. Examples: >>> print(BitField().index('a')) 0 >>> print(BitField().index('A')) 26 )start)stop)r"rw)r=r`rrs rrwzBitField.indexsy$ =T\99??3' '  99??3e?4 4 ]t/99??3T?2 299??3t4 4rct|jjd}|dvr|S|dvr|j|z St d)a Count the number of values (True or False). When counting the values of True, this is also known as the Hamming weight (or the Hamming distance to 0). Args: value (bool): The value to count. Returns: result (int): The number of matches found. Examples: >>> BitField().count(True) 0 >>> BitField().count(False) 52 >>> flags = BitField(127) >>> print(flags.count()) 7 >>> print(flags.count(True)) 7 >>> print(flags.count(False)) 45 1)rT)rFz&BitField only contains boolean values.)binr6countrDr&)r=roness rrzBitField.countsM64>>"((- I K j 99t# #EF Frcd|_y)NrrIrJs rclearzBitField.clears rc~t|t|k(r!|xj|jzc_|StrHr'r6NotImplementedr=others r__ior__zBitField.__ior__/ :e $ NNeoo -NK rcFt||j}||z}|S)a\ Perform bitwise-or operation between two bit-fields. Args: other (BitField): The other bit-field. Returns: result (BitField): The result of the operation. Examples: >>> a = BitField(1) >>> b = BitField(2) >>> print(a | b) BitField(ab) >>> print(a) BitField(a) >>> print(b) BitField(b) >>> print(a + b) BitField(ab) >>> print(a) BitField(a) >>> print(b) BitField(b) r'r6r=rresults r__or__zBitField.__or__&:dDNN+% rc~t|t|k(r!|xj|jzc_|StrHrrs r__iand__zBitField.__iand__ rrcFt||j}||z}|S)a_ Perform bitwise-and operation between two bit-fields. Args: other (BitField): The other bit-field. Returns: result (BitField): The result of the operation. Examples: >>> a = BitField(3) >>> b = BitField(6) >>> print(a & b) BitField(b) >>> print(a) BitField(ab) >>> print(b) BitField(bc) >>> print(a * b) BitField(b) >>> print(a) BitField(ab) >>> print(b) BitField(bc) rrs r__and__zBitField.__and__rrcTt|tr|j||StrH)r9r:fliprrs r__ixor__zBitField.__ixor__6s# eS ! IIe K rcFt||j}||z}|S)a Flip the specified bit from the bit-fields. Args: item (int): The position of the bit to flip. Returns: result (BitField): The result of the operation. Examples: >>> flags = BitField('bd') >>> flags ^= 0 >>> print(flags) BitField(abd) >>> flags ^= 0 >>> print(flags) BitField(bd) >>> print(flags ^ 0) BitField(abd) r)r=itemrs r__xor__zBitField.__xor__>s&*dDNN+$ rcft|t|k(xr|j|jk(SrHrrs r__eq__zBitField.__eq__Xs'DzT%[(NT^^u-NNrcft|t|k7xs|j|jk7SrHrrs r__ne__zBitField.__ne__\s'DzT%[(MDNNeoo,MMrc|jjdzt|jzdzt t |j zSN())r?r/rr6rvdictrmrJs r__repr__zBitField.__repr__`sD~~&&,s4>>/BBSHT$**,'() )rc|j|j}|r t|n |j}|jj dz|zdzSr)decoder6rvr#r?r/)r=r-r s r__str__zBitField.__str__esD{{4>>* s4ydjj~~&&,t3c99rcL|j|j|dd|dddS)a Decode bit-field using the specified extended keys. Extended keys include the empty token as first element. Args: ext_keys (Sequence): The extended decoding keys. The first element is used for decoding the empty bits. All the other keys follow. Returns: result (Sequence): The decoded bit-field. Examples: >>> flags = BitField(3) >>> flags % '-rwx' 'rw-' rNrTrr6)r=ext_keyss r__mod__zBitField.__mod__ks0&{{ NNHQRL(1+tTC Crc@|j|j|dddS)aQ Decode bit-field using the specified keys. Args: keys (Sequence): The decoding keys. Unset bits are ignored. Returns: result (Sequence): The decoded bit-field. Examples: >>> flags = BitField(3) >>> flags / '123' '12' NFTrr=r-s r __truediv__zBitField.__truediv__s {{4>>4udCCrcH|j|j|ddtS)ao Decode bit-field using the specified keys (and a list container). Args: keys (Sequence): The decoding keys. Unset bits are ignored. Returns: result (Sequence): The decoded bit-field. Examples: >>> flags = BitField(3) >>> flags // '123' ['1', '2'] NF)rr6listrs r __floordiv__zBitField.__floordiv__s {{4>>4udCCrc|| ||<||S)a" Flip (toggle) the item at the specified position. Args: item (int): The index of the item to access. Returns: result (bool): The value of the item after flipping. Examples: >>> flags = BitField(7) >>> print(flags[0]) True >>> print(flags.flip_slice(0)) False >>> print(flags[0]) False >>> print(flags.flip_slice(0)) True >>> print(flags[0]) True r)r=rs rrz BitField.flips.d^T Dzrc|| |j} |j| |j}|r+fdtj|t |dD}ndt |t |D}t|r||S|r2t|trdj|St||S|S)a Decode a bit-field according to the specified keys. Args: BitField (int): The input BitField. keys (Iterable): The keys to use for decoding the bit-field. empty (Any|None): The value to use for unset flags. full_repr (bool): Represent all available flags. container (bool|callable|None): Determine the container to use. If callable, must be a sequence constructor. If True, the container is inferred from the type of `KEYS`. Otherwise, the generator itself is returned. Returns: result (Sequence|generator): The keys associated to the bit-field. Examples: >>> BitField.decode(42) 'bdf' c30K|] \}}|r|nywrHr).0r`rr.s r z"BitField.decode..s&NC%'NsF) fillvaluec3,K|] \}}|s |ywrHr)rr`rs rrz"BitField.decode..sOjc5cOs ) r"r# FULL_REPR itertools zip_longestrrfcallabler9rvjoinr')r>r3r-r. full_repr containerrs ` rrzBitField.decodes8 <88D =IIE   I N%%dDNeLNF PCd8n,EOF I V$ $ $$wwv&!tDz&))Mrc,| |j}| |j}| |j}t|}|j |d}t |D]=\}}||vr||k7s|d|j |zz}(|r+ttd|S)a Encode a bit-field according to the specified keys. Args: items (Iterable): The items from the bit-field. keys (Iterable): The keys to use for decoding the bit-field. empty (Any|None): The value to use for unset flags. ignore_invalid (bool): Ignore invalid items. If False, a ValueError is raised if invalid items are present. Returns: result (int): The value associated to the items in the bit-field. Raises: ValueError: If ignore is False and invalid items are present in in the input. Examples: >>> BitField.encode('acio') 16645 rrz%Invalid input `{item}` at index: {i}.) r"r#r<r%add enumeraterwr&r) r>rmr-r.ignore_invalidrLrrrs rr;zBitField.encodes8 <88D =IIE  ! //NY u ' CGAtz!5=Q$**T"222E# @ACC  C rc|jSrHrIrJs r__int__zBitField.__int__(s ~~rc|dvrtt||S t|jj|}|t t d||S#t$rd}Y(wxYw)a Get the value of a given flag using attributes. Args: name (str): The attribute name. Returns: value (bool): The value of the flag. Examples: >>> print(BitField(1).a) True >>> print(BitField(0).a) False >>> print(BitField(1).something) Traceback (most recent call last): ... AttributeError: Unknown key `something`. >r"r#NUnknown key `{name}`.)getattrr'r"rwr&AttributeErrorrr=namers r __getattr__zBitField.__getattr__,sr( $ $4:t, , JOO))$/y$T*A%BCCAw   s$A A('A(c|dvrtt| ||y t|jj |}|ttd|||<y#t $rd}Y)wxYw)aX Set the value of a given flag using attributes. Args: name (str): The attribute name. Returns: None. Examples: >>> flags = BitField(6) >>> print(flags) BitField(bc) >>> flags.a = True >>> print(flags) BitField(abc) >>> flags.a = False >>> print(flags) BitField(bc) >>> flags.something = True Traceback (most recent call last): ... AttributeError: Unknown key `something`. >r3r6Nr) r7r3r8r'r"rwr&rr)r=rrrr?s rr8zBitField.__setattr__Mss2 , , (D -dE : JOO))$/y$T*A%BCCQ   s$A A*)A*c t|jj|}|t t d||=y#t$rd}Y'wxYw)aR Delete the value of a given flag using attributes. Args: name (str): The attribute name. Returns: None. Examples: >>> flags = BitField(6) >>> print(flags) BitField(bc) >>> del flags.a >>> print(flags) BitField(bc) >>> del flags.b >>> print(flags) BitField(c) >>> flags.something = True Traceback (most recent call last): ... AttributeError: Unknown key `something`. Nr)r'r"rwr&rrrs r __delattr__zBitField.__delattr__ssT2 T %%d+A 9 &=!>? ?Q  A s$A A A)r)NN)T)NNNT)NNN)Cr/r0r1__doc__string ascii_lettersr"r#rr<r@propertyr3setterdeleter classmethodrNrD__len__rRrVrXrZr]r-rcrhrkrmrorqrs__iter__ __reversed__rxrzr}rrwrrrr__add____iadd__rr__mul____imul__rrrrrrrrrrtogglerr;rrr8r __classcell__)r?s@rr3r3ss\z   D EIN C2CC__==** $$$llG + + 2626("*"  &$02!(!*H L1,%:P4 *58!GF!BGH!BGH!4ON) : C.D&D&4F 00f ++\B# L rr3) metaclassrH)r __future__rrrrrrrrrrr'r objectr3rrrrsT CC  !#J,&, @4 @`v`r