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()
