def test_enum_local_var_assign(converter):
class EnumType(Enum):
ENUMVALUE = 0
code = textwrap.dedent("""\
def f():
a = EnumType.ENUMVALUE""")
datamodel = DataModel(locals={'f': {'a': EnumType.ENUMVALUE}},
self_data={})
expect = textwrap.dedent("""\
procedure f is
variable a: EnumType;
begin
a := ENUMVALUE;
end procedure;""")
conv = converter(code, datamodel)
assert expect == str(conv)
python类Enum()的实例源码
def test_enum_self_var_assign(converter):
class EnumType(Enum):
ENUMVALUE = 0
code = textwrap.dedent("""\
def f():
self.a = EnumType.ENUMVALUE""")
datamodel = DataModel(locals={},
self_data={'a': EnumType.ENUMVALUE})
expect = textwrap.dedent("""\
procedure f is
begin
self.a := ENUMVALUE;
end procedure;""")
conv = converter(code, datamodel)
assert expect == str(conv)
def test_enum_in_if(converter):
class EnumType(Enum):
ENUMVALUE = 0
code = textwrap.dedent("""\
def f():
if a == EnumType.ENUMVALUE:
b""")
datamodel = DataModel(locals={'f': {'c': EnumType.ENUMVALUE}},
self_data={})
expect = textwrap.dedent("""\
procedure f is
begin
if a = ENUMVALUE then
b
end if;
end procedure;""")
conv = converter(code, datamodel)
assert expect == str(conv)
def normal_to_slv(self, var, var_name) -> str:
if type(var) == int:
return f'std_logic_vector(to_signed({var_name}, 32))'
elif type(var) == bool:
return f'bool_to_logic({var_name})'
elif type(var) == Sfix:
return f'to_slv({var_name})'
elif type(var) == ComplexSfix:
return f'to_slv({var_name}.real) & to_slv({var_name}.imag)'
elif isinstance(var, Enum):
return self.normal_to_slv(var.value, var_name)
elif isinstance(var, list):
if isinstance(var[0], bool):
return f'bool_list_to_logic({var_name})'
else:
assert 0
def is_convertible(obj):
allowed_types = [ComplexSfix, Sfix, int, bool, Const]
if type(obj) in allowed_types:
return True
elif isinstance(obj, list):
# To check whether all elements are of the same type
if len(set(map(type, obj))) == 1:
if all(type(x) in allowed_types for x in obj):
return True
elif isinstance(obj[0], HW): # list of submodules
return True
elif isinstance(obj, Enum):
return True
elif isinstance(obj, HW):
return True
return False
def adapt(self, impltype, **kw):
schema = kw.pop('schema', self.schema)
metadata = kw.pop('metadata', self.metadata)
_create_events = kw.pop('_create_events', False)
if issubclass(impltype, Enum):
if self.enum_class is not None:
args = [self.enum_class]
else:
args = self.enums
return impltype(name=self.name,
schema=schema,
metadata=metadata,
convert_unicode=self.convert_unicode,
native_enum=self.native_enum,
inherit_schema=self.inherit_schema,
validate_strings=self.validate_strings,
_create_events=_create_events,
*args,
**kw)
else:
# TODO: why would we be here?
return super(Enum, self).adapt(impltype, **kw)
def encode_tags(tags, output):
result = []
for tag in tags:
t_set = set(tag.split(' '))
assert issubclass(output, enum.Enum)
res_index = None
for idx, member in enumerate(output.__members__.values()):
if member.value == '' or member.value in t_set:
res_index = idx
assert res_index is not None
v = np.zeros(len(output), dtype=np.float32)
v[res_index] = 1.0
result.append(v)
return result
def test_attribute_deletion(self):
class Season(Enum):
SPRING = 1
SUMMER = 2
AUTUMN = 3
WINTER = 4
def spam(cls):
pass
self.assertTrue(hasattr(Season, 'spam'))
del Season.spam
self.assertFalse(hasattr(Season, 'spam'))
with self.assertRaises(AttributeError):
del Season.SPRING
with self.assertRaises(AttributeError):
del Season.DRY
with self.assertRaises(AttributeError):
del Season.SPRING.name
def test_invalid_names(self):
with self.assertRaises(ValueError):
class Wrong(Enum):
mro = 9
with self.assertRaises(ValueError):
class Wrong(Enum):
_create_= 11
with self.assertRaises(ValueError):
class Wrong(Enum):
_get_mixins_ = 9
with self.assertRaises(ValueError):
class Wrong(Enum):
_find_new_ = 1
with self.assertRaises(ValueError):
class Wrong(Enum):
_any_name_ = 9
def test_comparisons(self):
Season = self.Season
with self.assertRaises(TypeError):
Season.SPRING < Season.WINTER
with self.assertRaises(TypeError):
Season.SPRING > 4
self.assertNotEqual(Season.SPRING, 1)
class Part(Enum):
SPRING = 1
CLIP = 2
BARREL = 3
self.assertNotEqual(Season.SPRING, Part.SPRING)
with self.assertRaises(TypeError):
Season.SPRING < Part.CLIP
def test_enum_duplicates(self):
class Season(Enum):
SPRING = 1
SUMMER = 2
AUTUMN = FALL = 3
WINTER = 4
ANOTHER_SPRING = 1
lst = list(Season)
self.assertEqual(
lst,
[Season.SPRING, Season.SUMMER,
Season.AUTUMN, Season.WINTER,
])
self.assertIs(Season.FALL, Season.AUTUMN)
self.assertEqual(Season.FALL.value, 3)
self.assertEqual(Season.AUTUMN.value, 3)
self.assertIs(Season(3), Season.AUTUMN)
self.assertIs(Season(1), Season.SPRING)
self.assertEqual(Season.FALL.name, 'AUTUMN')
self.assertEqual(
[k for k,v in Season.__members__.items() if v.name != k],
['FALL', 'ANOTHER_SPRING'],
)
def test_programatic_function_string(self):
SummerMonth = Enum('SummerMonth', 'june july august')
lst = list(SummerMonth)
self.assertEqual(len(lst), len(SummerMonth))
self.assertEqual(len(SummerMonth), 3, SummerMonth)
self.assertEqual(
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
lst,
)
for i, month in enumerate('june july august'.split(), 1):
e = SummerMonth(i)
self.assertEqual(int(e.value), i)
self.assertNotEqual(e, i)
self.assertEqual(e.name, month)
self.assertIn(e, SummerMonth)
self.assertIs(type(e), SummerMonth)
def test_programatic_function_string_list(self):
SummerMonth = Enum('SummerMonth', ['june', 'july', 'august'])
lst = list(SummerMonth)
self.assertEqual(len(lst), len(SummerMonth))
self.assertEqual(len(SummerMonth), 3, SummerMonth)
self.assertEqual(
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
lst,
)
for i, month in enumerate('june july august'.split(), 1):
e = SummerMonth(i)
self.assertEqual(int(e.value), i)
self.assertNotEqual(e, i)
self.assertEqual(e.name, month)
self.assertIn(e, SummerMonth)
self.assertIs(type(e), SummerMonth)
def test_programatic_function_iterable(self):
SummerMonth = Enum(
'SummerMonth',
(('june', 1), ('july', 2), ('august', 3))
)
lst = list(SummerMonth)
self.assertEqual(len(lst), len(SummerMonth))
self.assertEqual(len(SummerMonth), 3, SummerMonth)
self.assertEqual(
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
lst,
)
for i, month in enumerate('june july august'.split(), 1):
e = SummerMonth(i)
self.assertEqual(int(e.value), i)
self.assertNotEqual(e, i)
self.assertEqual(e.name, month)
self.assertIn(e, SummerMonth)
self.assertIs(type(e), SummerMonth)
def evaluate(self, query: MutableMapping[str, Any], context: PipelineContext = None) -> True:
try:
value = query[self.key]
for type in self.types:
if issubclass(type, Enum) and isinstance(value, str):
value = type(value)
if isinstance(value, type):
query[self.key] = value
return True
raise WrongValueTypeError("{key} must be of type {type} in query!".format(key=self.key, type=self))
except KeyError:
if self.child:
self.child.evaluate(query, context)
return True
def json_ready_header(header):
# type: (MessageHeader) -> Dict[str, Any]
"""Create a JSON-serializable representation of a :class:`aws_encryption_sdk.structures.MessageHeader`.
http://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/message-format.html#header-structure
:param header: header for which to create a JSON-serializable representation
:type header: aws_encryption_sdk.structures.MessageHeader
:rtype: dict
"""
dict_header = attr.asdict(header)
del dict_header['content_aad_length']
dict_header['version'] = str(float(dict_header['version'].value))
dict_header['algorithm'] = dict_header['algorithm'].name
for key, value in dict_header.items():
if isinstance(value, Enum):
dict_header[key] = value.value
dict_header['message_id'] = unicode_b64_encode(dict_header['message_id'])
dict_header['encrypted_data_keys'] = sorted(
list(dict_header['encrypted_data_keys']),
key=lambda x: six.b(x['key_provider']['provider_id']) + x['key_provider']['key_info']
)
for data_key in dict_header['encrypted_data_keys']:
data_key['key_provider']['provider_id'] = unicode_b64_encode(six.b(data_key['key_provider']['provider_id']))
data_key['key_provider']['key_info'] = unicode_b64_encode(data_key['key_provider']['key_info'])
data_key['encrypted_data_key'] = unicode_b64_encode(data_key['encrypted_data_key'])
return dict_header
def set_effect(self, effect: Enum, *args) -> bool:
if self._driver.has_quirk(Quirks.EXTENDED_FX_CMDS):
if effect.name in ExtendedFX.__members__:
return self._set_effect_extended(ExtendedFX[effect.name], *args)
return False
return self._set_effect_basic(effect, *args)
def trait_as_dict(trait: TraitType) -> dict:
"""
Convert a trait to a dict for sending over D-Bus or the like
:param trait: the trait to be converted
:return: dict representing this trait
"""
cls = trait.__class__
tdict = {}
for k, v in vars(trait).items():
if k.startswith('__') or k == 'this_class':
continue
if hasattr(cls, k) and getattr(cls, k) == v:
continue
if isinstance(v, Iterable) and len(v) == 0:
continue
if k.startswith('_'):
tdict[k[1:]] = v
else:
tdict[k] = v
if isinstance(trait, UseEnum):
cls = CaselessStrEnum
tdict['values'] = tuple(trait.enum_class.__members__.keys())
if 'enum_class' in tdict:
del tdict['enum_class']
for k, v in tdict.items():
if isinstance(v, TraitType):
tdict[k] = trait_as_dict(v)
if isinstance(v, enum.Enum):
tdict[k] = v.name
if isinstance(v, type):
tdict[k] = '%s.%s' % (v.__module__, v.__name__)
tdict['__class__'] = (cls.__module__, cls.__name__)
return tdict
def add_traits_to_argparse(obj: HasTraits, parser: ArgumentParser,
prefix: str=None):
"""
Add all traits from the given object to the argparse context.
:param obj: an instance of HasTraits
:param parser: argparse parser
:param prefix: string to prefix keys with
"""
for key, trait in obj.traits().items():
if trait.get_metadata('config') is not True:
continue
argname = '--%s' % key
if prefix is not None:
argname = '--%s.%s' % (prefix, key)
if isinstance(trait, Container):
parser.add_argument(argname, nargs='+', help=trait.info_text)
elif isinstance(trait, Enum):
parser.add_argument(argname, type=str.lower,
choices=[x.lower() for x in trait.values],
help=trait.info_text)
else:
argtype = str
if hasattr(trait, 'default_value'):
argtype = type(trait.default_value)
parser.add_argument(argname, type=argtype, help=trait.info_text)
def CRC32(data):
""" Help function for 32bit CRC calculation
:param data: Tha data blob as byte array
:return: CRC Value
"""
return zlib.crc32(data) & 0xFFFFFFFF
# ----------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
# Customized Enum Class
# ----------------------------------------------------------------------------------------------------------------------
