def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Group(key) if key not in Group._member_map_: extend_enum(Group, key, default) return Group[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Certificate(key) if key not in Certificate._member_map_: # pylint: disable=no-member extend_enum(Certificate, key, default) return Certificate[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return TOS_DEL(key) if key not in TOS_DEL._member_map_: extend_enum(TOS_DEL, key, default) return TOS_DEL[key]
def register_error_code(name, description): """Register an additional error code. For use in extensions.""" value = max(member.value for member in ErrorCode) + 1 extend_enum(ErrorCode, name, value) member = ErrorCode[name] ERROR_DESCRIPTION[member] = description return member
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return HI_ALG(key) if key not in HI_ALG._member_map_: extend_enum(HI_ALG, key, default) return HI_ALG[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return DITypes(key) if key not in DITypes._member_map_: # pylint: disable=no-member extend_enum(DITypes, key, default) return DITypes[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return ClasLvl(key) if key not in ClasLvl._member_map_: extend_enum(ClasLvl, key, default) return ClasLvl[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return RouterAlert(key) if key not in RouterAlert._member_map_: # pylint: disable=no-member extend_enum(RouterAlert, key, default) return RouterAlert[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Option(key) if key not in Option._member_map_: extend_enum(Option, key, default) return Option[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return ChksumOpt(key) if key not in ChksumOpt._member_map_: extend_enum(ChksumOpt, key, default) return ChksumOpt[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return ExtensionHeader(key) if key not in ExtensionHeader._member_map_: extend_enum(ExtensionHeader, key, default) return ExtensionHeader[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return ModeID(key) if key not in ModeID._member_map_: extend_enum(ModeID, key, default) return ModeID[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return DI_TYPE(key) if key not in DI_TYPE._member_map_: extend_enum(DI_TYPE, key, default) return DI_TYPE[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Reliability(key) if key not in Reliability._member_map_: extend_enum(Reliability, key, default) return Reliability[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return RegistrationFailure(key) if key not in RegistrationFailure._member_map_: # pylint: disable=no-member extend_enum(RegistrationFailure, key, default) return RegistrationFailure[key]
def _missing_(cls, value): """Lookup function used when value is not found.""" if not (isinstance(value, int) and 0 <= value <= 1): raise ValueError('%r is not a valid %s' % (value, cls.__name__)) extend_enum(cls, 'Unassigned [%d]' % value, value) return cls(value) super()._missing_(value)
def test_extend_enum_multivalue_with_duplicate(self): with self.assertRaises(ValueError): class Color(Enum, settings=MultiValue): red = 1, 'rojo' green = 2, 'verde' blue = 3, 'azul' extend_enum(Color, 'value', 2)
def _missing_(cls, value): """Lookup function used when value is not found.""" if not (isinstance(value, int) and 0x00 <= value <= 0xFF): raise ValueError('%r is not a valid %s' % (value, cls.__name__)) extend_enum(cls, 'Unassigned [0x%s]' % hex(value)[2:].upper().zfill(2), value) return cls(value)
def _missing_(cls, value): """Lookup function used when value is not found.""" if not (isinstance(value, int) and 0x0000 <= value <= 0xFFFF): raise ValueError('%r is not a valid %s' % (value, cls.__name__)) if 0x0001 <= value <= 0x0BB8: extend_enum( cls, 'Registered by Xerox [0x%s]' % hex(value)[2:].upper().zfill(4), value) return cls(value) if 0x0020 <= value <= 0x003F: extend_enum( cls, 'Experimental [0x%s]' % hex(value)[2:].upper().zfill(4), value) return cls(value) if 0x0BB9 <= value <= 0xFFFF: extend_enum( cls, 'Dynamically Assigned [0x%s]' % hex(value)[2:].upper().zfill(4), value) return cls(value) if 0x4000 <= value <= 0x4FFF: extend_enum( cls, 'Dynamically Assigned Socket Numbers [0x%s]' % hex(value)[2:].upper().zfill(4), value) return cls(value) if 0x8000 <= value <= 0xFFFF: extend_enum( cls, 'Statically Assigned Socket Numbers [0x%s]' % hex(value)[2:].upper().zfill(4), value) return cls(value) super()._missing_(value)
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return NATTraversal(key) if key not in NATTraversal._member_map_: # pylint: disable=no-member extend_enum(NATTraversal, key, default) return NATTraversal[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return HI_Algorithm(key) if key not in HI_Algorithm._member_map_: # pylint: disable=no-member extend_enum(HI_Algorithm, key, default) return HI_Algorithm[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return ProtectionAuthority(key) if key not in ProtectionAuthority._member_map_: # pylint: disable=no-member extend_enum(ProtectionAuthority, key, default) return ProtectionAuthority[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return PriorityLevel(key) if key not in PriorityLevel._member_map_: # pylint: disable=no-member extend_enum(PriorityLevel, key, default) return PriorityLevel[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return ECDSA_LOW_Curve(key) if key not in ECDSA_LOW_Curve._member_map_: # pylint: disable=no-member extend_enum(ECDSA_LOW_Curve, key, default) return ECDSA_LOW_Curve[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Parameter(key) if key not in Parameter._member_map_: # pylint: disable=no-member extend_enum(Parameter, key, default) return Parameter[key]
def _missing_(cls, value): """Lookup function used when value is not found.""" if not (isinstance(value, int) and 0b000 <= value <= 0b111): raise ValueError('%r is not a valid %s' % (value, cls.__name__)) extend_enum(cls, 'Unassigned [0b%s]' % bin(value)[2:].zfill(3), value) return cls(value) super()._missing_(value)
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return LinkType(key) if key not in LinkType._member_map_: extend_enum(LinkType, key, default) return LinkType[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Routing(key) if key not in Routing._member_map_: extend_enum(Routing, key, default) return Routing[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return QS_Function(key) if key not in QS_Function._member_map_: # pylint: disable=no-member extend_enum(QS_Function, key, default) return QS_Function[key]
def get(key, default=-1): """Backport support for original codes.""" if isinstance(key, int): return Sockets(key) if key not in Sockets._member_map_: extend_enum(Sockets, key, default) return Sockets[key]
def extend(namespace, name): """ Extends the DataProductType with a new, user-defined, entry :param namespace: Namespace for the new data product type :param name: Name of the new data product type """ extend_enum(DataProductType, name.upper(), VocabularyTerm(namespace, name).get_value())
mtr=material_value[6], # berekening weight: material + type + upgraded wht=material_value[1] + type_value[1] + upgraded_value[1], # berekening protection: material + type prt=material_value[2] + type_value[2], # berekening stealth: material + type + upgraded stl=material_value[3] + type_value[3] + upgraded_value[3], col=type_value[5], row=material_value[5] ) # type en sprite toepassen. # shop uitzetten voor sommige equipment items. for eqp_key, eqp_value in temp_armor_dict.items(): eqp_value['typ'] = EquipmentType.arm eqp_value['spr'] = SPRITEPATH if "+" in eqp_key or "titanium" in eqp_key: eqp_value['shp'] = False # de laatste van shop is misschien niet nodig. dit kan ook in de shop zelf gecheckt worden. scheelt een variable # Herschik de volgorde van de gecreerde dataset. # sorteer en zet in nieuwe database for eqp_key, eqp_value in sorted(temp_armor_dict.items(), key=lambda xx: xx[1]['srt']): aenum.extend_enum(ArmorDatabase, eqp_key, eqp_value) # maak eigen database leeg temp_armor_dict.clear()
hit=type_value[3] + upgraded_value[1], # berekening damage: material + type + upgraded dam=material_value[3] + type_value[4] + upgraded_value[2], col=material_value[5], row=type_value[8] ) # min_int op 0 zetten voor close weapons # min_str op 0 zetten voor range weapons for weapon_key, weapon_value in temp_weapon_dict.items(): if weapon_value['skl'] == WeaponType.mis: weapon_value['min_str'] = 0 else: weapon_value['min_int'] = 0 # Shop uitzetten voor sommige equipment items. for eqp_key, eqp_value in temp_weapon_dict.items(): eqp_value['typ'] = EquipmentType.wpn eqp_value['spr'] = SPRITEPATH if "+" in eqp_key or "titanium" in eqp_key: eqp_value['shp'] = False # de laatste van shop is misschien niet nodig. dit kan ook in de shop zelf gecheckt worden. scheelt een variable # Herschik de volgorde van de gecreerde dataset. # sorteer en zet in nieuwe database for eqp_key, eqp_value in sorted(temp_weapon_dict.items(), key=lambda xx: xx[1]['srt']): aenum.extend_enum(WeaponDatabase, eqp_key, eqp_value) # maak eigen database leeg temp_weapon_dict.clear()
# berekening defense: material + type des=material_value[3] + type_value[3], # 'def' kon niet, dus maar des gedaan. # berekening dexterity: material + type + upgraded dex=material_value[4] + type_value[4] + upgraded_value[4], # berekening stealth: material + type + upgraded stl=material_value[5] + type_value[5] + upgraded_value[5], col=material_value[7], row=type_value[7] ) # type, skill en sprite toepassen. # Shop uitzetten voor sommige equipment items. for eqp_key, eqp_value in temp_shield_dict.items(): eqp_value['typ'] = EquipmentType.sld eqp_value['skl'] = WeaponType.shd eqp_value['spr'] = SPRITEPATH if "+" in eqp_key or "titanium" in eqp_key: eqp_value['shp'] = False # de laatste van shop is misschien niet nodig. dit kan ook in de shop zelf gecheckt worden. scheelt een variable # Herschik de volgorde van de gecreerde dataset. # sorteer en zet in nieuwe database for eqp_key, eqp_value in sorted(temp_shield_dict.items(), key=lambda xx: xx[1]['srt']): aenum.extend_enum(ShieldDatabase, eqp_key, eqp_value) # maak eigen database leeg temp_shield_dict.clear()