def parse( self, data: typing.Union[typing.AnyStr, typing.Enum] ) -> typing.Union[None, typing.Enum]: """Parse ``data`` from string. Args: data: raw data Returns: The parsed enum data. If ``data`` is *unset*, ``None`` will be returned. Warns: ZeekValueWarning: If ``date`` is not defined in the enum namespace. """ if isinstance(data, enum.Enum): return data if isinstance(data, str): data = data.encode('ascii') if data == self.unset_field: return None data_str = data.decode('ascii') item = self.enum_namespaces.get() if item is None: warnings.warn('unrecognised enum value: %s' % data_str, ZeekValueWarning) return enum.IntFlag('<unknown>', [(data_str, enum.auto())])[data_str] return item
class BlockWrapper: Flags = enum.IntFlag('BlockWrapper.Flags', ['INTERNAL', 'USED']) def __init__(self, block): self.block = block self.flags = 0 def add_flag(self, f): self.flags |= f def can_merge(self): return self.flags == self.Flags.INTERNAL def __getattr__(self, n): return getattr(self.block, n)
def convert_fields_to_struct_fields(fields, verbose=False): total_bits = 0 struct_fields = [] for identifier, op, options in fields: s_field = None if op == "&": bits = len(options) description = f"{bits}-bit bitfield" f_enum = enum.IntFlag( identifier, [(op, 1 << i) for (i, op) in enumerate(options)] ) s_field = identifier / construct.FlagsEnum( construct.BitsInteger(bits), f_enum ) elif op == "|": bits = math.ceil(math.log2(len(options))) description = f"{bits}-bit enum" if set(options) == {True, False}: s_field = identifier / construct.Flag else: f_enum = enum.IntEnum( identifier, [(op, 1 << i) for (i, op) in enumerate(options)] ) s_field = identifier / construct.Enum( construct.BitsInteger(bits), f_enum ) struct_fields.append(s_field) if verbose: print(f"{identifier:15}: {description} ({len(options)} options)") assert bits == s_field.sizeof() total_bits += bits if verbose: print(f"Total bits: {total_bits}") return (struct_fields, total_bits)
class EnumConverter(enum.IntFlag): """Mixin used for converting enums.""" @classmethod async def convert(cls, ctx, argument): try: return cls[argument.lower()] except KeyError: raise commands.BadArgument( f'{argument} is not a valid {ctx.__name__}') @classmethod def random_example(cls, ctx): return random.choice(list(cls)).name ActionFlag = enum.IntFlag('ActionFlag', list(_mod_actions), type=EnumConverter) _default_flags = (2**len(_mod_actions) - 1) & ~ActionFlag.hackban for key, value in list(_mod_actions.items()): _mod_actions[f'auto-{key}'] = value._replace(repr=f'auto-{value.repr}') class ModLogError(Exception): pass class ModLogEntry(db.Table, table_name='modlog'): id = db.Column(db.Serial, primary_key=True) channel_id = db.Column(db.BigInt) message_id = db.Column(db.BigInt) guild_id = db.Column(db.BigInt)
class TestFieldPart: """Tests class FieldPart""" @pytest.mark.parametrize('name', [b'name', 2]) def test_should_raise_error_when_name_is_not_a_string(self, name): with pytest.raises(TypeError): FieldPart(name, 2, 2) @pytest.mark.parametrize('name', [' hello', 'hello ', 'foo-bar', 'f@o']) def test_should_raise_error_when_given_name_is_not_correct(self, name): with pytest.raises(ValueError) as exc_info: FieldPart(name, 2, 2) assert ( 'FieldPart name must starts with a letter and follow standard' f' rules for declaring a variable in python but you provided {name}' ) == str(exc_info.value) @pytest.mark.parametrize('default', [4.5, '4']) def test_should_raise_error_when_default_is_not_an_integer(self, default): with pytest.raises(TypeError): FieldPart('part', default, 3) @pytest.mark.parametrize('default', [-1, 8]) def test_should_raise_error_when_default_is_not_in_valid_boundaries( self, default): with pytest.raises(ValueError) as exc_info: FieldPart('part', default, 3) assert f'default must be between 0 and 7 but you provided {default}' == str( exc_info.value) @pytest.mark.parametrize('size', [4.5, '4']) def test_should_raise_error_when_size_is_not_an_integer(self, size): with pytest.raises(TypeError): FieldPart('part', 2, size) @pytest.mark.parametrize('enumeration', [{ 'hello': 2 }, [(2, 'hello')], { 2: 3.4 }]) def test_should_raise_error_when_enumeration_is_not_correct( self, enumeration): with pytest.raises(TypeError): FieldPart('part', 2, 3, enumeration) @pytest.mark.parametrize('enumeration', [{ 1: 'MF', 2: 'DF', 4: 'reserved' }, enum.IntFlag('Flag', 'MF DF reserved')]) def test_should_correctly_instantiate_byte_part_object(self, enumeration): # these are flags present in IPV4 header :D # For more information, you can look here: https://en.wikipedia.org/wiki/IPv4 part = FieldPart('flags', 0b010, 3, enumeration) assert 'flags' == part.name assert 2 == part.default == part.value assert 3 == part.size assert {1: 'MF', 2: 'DF', 4: 'reserved'} == part.enumeration assert not part.hex # test of hex property @pytest.mark.parametrize('value', [1, 'yes']) def test_should_raise_error_when_giving_incorrect_value_to_hex_property( self, value): part = FieldPart('flags', 0b010, 3) with pytest.raises(TypeError) as exc_info: part.hex = value assert f'hex value must be a boolean but you provided {value}' == str( exc_info.value) def test_should_set_hex_property_when_giving_correct_value(self): part = FieldPart('flags', 0b010, 3) part.hex = True assert part.hex # test of value property @pytest.mark.parametrize('value', [b'value', 4.5]) def test_should_raise_error_when_given_value_is_not_of_correct_type( self, value): part = FieldPart('banana', 2, 3) with pytest.raises(TypeError) as exc_info: part.value = value assert f'{part.name} value must be a positive integer but you provided {value}' == str( exc_info.value) @pytest.mark.parametrize('value', [-1, 8]) def test_should_raise_error_when_value_is_not_valid_boundaries( self, value): part = FieldPart('banana', 2, 3) with pytest.raises(ValueError) as exc_info: part.value = value assert f'{part.name} value must be between 0 and 7 but you provided {value}' == str( exc_info.value) def test_should_set_field_part_value_when_given_value_is_correct(self): part = FieldPart('part', 2, 3) given_value = 6 part.value = given_value assert given_value == part.value # test of __repr__ method @pytest.mark.parametrize( ('enumeration', 'representation', 'hexadecimal'), [({ 1: 'MF', 4: 'reserved', 20: 'DF', 17: 'danger' }, 'FieldPart(name=flags, default=DF, value=danger)', False), (None, 'FieldPart(name=flags, default=20, value=17)', False), (None, 'FieldPart(name=flags, default=0x14, value=0x11)', True)]) def test_should_correctly_represent_field_part(self, enumeration, representation, hexadecimal): part = FieldPart('flags', 20, 6, enumeration, hex=hexadecimal) part.value = 17 assert representation == repr(part) # test of clone method def test_should_return_a_correct_copy_of_field_part_when_calling_clone_method( self): part = FieldPart('part', 2, 3) cloned_part = part.clone() assert cloned_part == part assert cloned_part is not part
import dataclasses except ImportError: dataclasses = None # type: ignore MyNamedTuple = collections.namedtuple('A', ['x', 'y']) MyTypedNamedTuple = NamedTuple('MyTypedNamedTuple', [('f1', int), ('f2', str)]) class MyEnum(enum.Enum): E1 = 5 E2 = enum.auto() E3 = 'abc' MyIntEnum = enum.IntEnum('MyIntEnum', 'I1 I2 I3') MyIntFlag = enum.IntFlag('MyIntFlag', 'F1 F2 F3') MyFlag = enum.Flag('MyFlag', 'F1 F2 F3') # pylint: disable=too-many-function-args class DefinesGetState: def __init__(self, value): self.value = value def __getstate__(self): return self.value def __eq__(self, other): return type(other) is type(self) and other.value == self.value class DefinesGetAndSetState(DefinesGetState):
def load_yaml(): global REGISTERS if REGISTERS is not None: return here = os.path.dirname(os.path.realpath(__file__)) yaml_filename = os.path.abspath( os.path.join(here, "../../data/regmap.yaml")) with open(yaml_filename, "r") as f: s = f.read() raw_regs = yaml.load(s, Loader=yaml.Loader) REGISTERS = [] for raw_name, raw_reg in raw_regs.items(): raw_modes = raw_reg.get("modes", None) if raw_modes is None or raw_modes == "None": modes = None elif isinstance(raw_modes, str): try: modes = [get_mode(raw_modes)] except ValueError: continue else: # assumed to be a list modes = [] for m in raw_modes: try: modes.append(get_mode(m)) except ValueError: pass if len(modes) == 0: continue full_name = raw_name.strip().lower() try: prefix, stripped_name = full_name.split("_", 1) except ValueError: stripped_name = full_name else: if prefix in PREFIX_TO_MODE_MAP.keys(): mode = PREFIX_TO_MODE_MAP[prefix] if mode is None: continue assert PREFIX_TO_MODE_MAP[prefix] == modes[0] and len( modes) == 1 else: stripped_name = full_name addr = raw_reg["address"] assert type(addr) == int readable, writable = [ c in raw_reg.get("access", "rw").strip().lower() for c in "rw" ] category = Category(raw_reg["category"].strip().lower()) data_type = DataType(raw_reg["type"].strip().lower()) reg = Register( full_name=full_name, stripped_name=stripped_name, addr=addr, modes=modes, readable=readable, writable=writable, category=category, data_type=data_type, ) try: reg.float_scale = float(raw_reg["scale"]) except (KeyError, ValueError): pass else: assert reg.data_type == DataType.INT32 if data_type == DataType.ENUM: enum_values = { str(k).upper(): int(d["value"]) for k, d in raw_reg["values"].items() } reg.enum = enum.IntEnum(full_name + "_enum", enum_values) if data_type == DataType.BITSET: flags = {} masks = {} for k, v in [(str(k).upper(), int(d["value"])) for k, d in raw_reg["bits"].items()]: if v == 0: continue if v & (v - 1) == 0: # is power of 2 flags[k] = v else: masks[k] = v reg.bitset_flags = enum.IntFlag(full_name + "_bitset_flags", flags) reg.bitset_masks = enum.IntEnum(full_name + "_bitset_masks", masks) REGISTERS.append(reg)
'STORED_PLAYLIST', 'PLAYLIST', 'PLAYER', 'MIXER', 'OUTPUT', 'OPTIONS', 'PARTITION', 'STICKER', 'SUBSCRIPTION', 'MESSAGE', 'CONNECT', 'IDLE', 'TIMEOUT'])} EVENTS['NONE'] = 0 EVENTS['ANY'] = EVENTS['CONNECT'] - 1 Event = enum.IntFlag('Event', EVENTS) del EVENTS Event.__doc__ = """ An enumeration of possible events for the idle request. Possible values are: - An MPD SUBSYSTEM name (in uppercase). - ANY - match any subsystem. - CONNECT - client is connected to server. - IDLE - client is idle. - TIMEOUT - flagged in the return value if a timeout ocurred. """ class RequestPassive(Request): """
def _rstrip(iterable, pred): cache = [] cache_append = cache.append for x in iterable: if pred(x): cache_append(x) else: for y in cache: yield y del cache[:] yield x PciFillFlag = enum.IntFlag( 'PciFillFlag', dict((''.join(x.capitalize() for x in k.split('_')[2:]), getattr(lib, k)) for k in dir(lib) if k.startswith('PCI_FILL_'))) PciFillFlag.All = PciFillFlag( sum(v.value for v in PciFillFlag if v.value < PciFillFlag.Rescan)) class PciCapType(enum.Enum): Normal = lib.PCI_CAP_NORMAL Extended = lib.PCI_CAP_EXTENDED PciCapId = enum.IntEnum( 'PciCapId', dict((''.join(x.capitalize() for x in k.split('_')[3:]), getattr(lib, k)) for k in dir(lib) if k.startswith('PCI_CAP_ID_')))
for b in bwrap: if prev is not None and b.can_merge(): prev.merge(b.block) else: if prev is not None: yield prev prev = b.block if prev is not None: yield prev return list(process_blocks(bwrap)) # Graph writing functions GraphDisplayFlags = enum.IntFlag('GraphDisplayFlags', ['REGISTERS', 'INSTRUCTIONS']) def block_name(b): return f"block_at_{b.starting_line()}" def rebuild_line(instr, args): args_s = ' ' + ','.join(args) if args else '' return f"<FONT COLOR=\"blue4\">{instr}</FONT>{args_s}" def write_line(f, nl, line_parts, alt=False): style = 'BGCOLOR="gray78"' if not alt else 'BGCOLOR="gray70"' print(f"""<TR> <TD {style}><FONT COLOR="gray30">{nl+1}</FONT></TD>
key_ = key.encode('utf-8') + b'\0' val_ = val.encode('utf-8') + b'\0' if lib.pci_set_param(pacc, ffi.from_buffer(key_), ffi.from_buffer(val_)) != 0: raise KeyError(key) def __delitem__(self, key: str): raise KeyError(key) def __repr__(self): return repr(dict(self.items())) PciAccessType = enum.IntFlag( 'PciAccessType', dict((''.join(x.capitalize() for x in k.split('_')[2:]), getattr(lib, k)) for k in dir(lib) if k.startswith('PCI_ACCESS_'))) PciLookupMode = enum.IntFlag( 'PciLookupMode', dict((''.join(x.capitalize() for x in k.split('_')[2:]), getattr(lib, k)) for k in dir(lib) if k.startswith('PCI_LOOKUP_'))) class Pci: def __init__(self): self._pacc = lib.pci_alloc() lib.pci_init(self._pacc) def close(self): if self._pacc is not None: