aboutsummaryrefslogtreecommitdiffstats
path: root/venv/Lib/site-packages/aenum/test_v3.py
diff options
context:
space:
mode:
Diffstat (limited to 'venv/Lib/site-packages/aenum/test_v3.py')
-rw-r--r--venv/Lib/site-packages/aenum/test_v3.py1982
1 files changed, 0 insertions, 1982 deletions
diff --git a/venv/Lib/site-packages/aenum/test_v3.py b/venv/Lib/site-packages/aenum/test_v3.py
deleted file mode 100644
index 62453df1..00000000
--- a/venv/Lib/site-packages/aenum/test_v3.py
+++ /dev/null
@@ -1,1982 +0,0 @@
-from . import EnumMeta, Enum, IntEnum, Flag, IntFlag, StrEnum, UniqueEnum, AutoEnum, AddValueEnum
-from . import NamedTuple, TupleSize, MagicValue, AddValue, NoAlias, Unique, MultiValue
-from . import AutoNumberEnum,MultiValueEnum, OrderedEnum, unique, skip, extend_enum, auto
-from . import StdlibEnumMeta, StdlibEnum, StdlibIntEnum, StdlibFlag, StdlibIntFlag, StdlibStrEnum
-from . import pyver, PY3_3, PY3_4, PY3_5, PY3_6, PY3_11
-from . import add_stdlib_integration, remove_stdlib_integration
-
-from collections import OrderedDict
-from datetime import timedelta
-from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
-from unittest import TestCase, main
-
-import os
-import sys
-import tempfile
-import textwrap
-import unittest
-
-try:
- import pyparsing
-except (ImportError, SyntaxError):
- pyparsing = None
-
-try:
- RecursionError
-except NameError:
- # python3.4
- RecursionError = RuntimeError
-
-class TestEnumV3(TestCase):
-
- def setUp(self):
- class Season(Enum):
- SPRING = 1
- SUMMER = 2
- AUTUMN = 3
- WINTER = 4
- self.Season = Season
-
- class Konstants(float, Enum):
- E = 2.7182818
- PI = 3.1415926
- TAU = 2 * PI
- self.Konstants = Konstants
-
- class Grades(IntEnum):
- A = 5
- B = 4
- C = 3
- D = 2
- F = 0
- self.Grades = Grades
-
- class Directional(str, Enum):
- EAST = 'east'
- WEST = 'west'
- NORTH = 'north'
- SOUTH = 'south'
- self.Directional = Directional
-
- from datetime import date
- class Holiday(date, Enum):
- NEW_YEAR = 2013, 1, 1
- IDES_OF_MARCH = 2013, 3, 15
- self.Holiday = Holiday
-
- @unittest.skipUnless(StdlibEnumMeta, 'Stdlib enum not available')
- def test_stdlib_inheritence(self):
- # 3.4
- self.assertTrue(issubclass(self.Season, StdlibEnum))
- self.assertTrue(isinstance(self.Season.SPRING, StdlibEnum))
- #
- if pyver >= PY3_6:
- class AFlag(Flag):
- one = 1
- self.assertTrue(issubclass(AFlag, StdlibEnum))
- self.assertTrue(isinstance(AFlag.one, StdlibEnum))
- self.assertTrue(issubclass(AFlag, StdlibFlag))
- self.assertTrue(isinstance(AFlag.one, StdlibFlag))
- #
- class AnIntFlag(IntFlag):
- one = 1
- self.assertTrue(issubclass(AnIntFlag, StdlibEnum))
- self.assertTrue(isinstance(AnIntFlag.one, StdlibEnum))
- self.assertTrue(issubclass(AnIntFlag, StdlibFlag))
- self.assertTrue(isinstance(AnIntFlag.one, StdlibFlag))
- self.assertTrue(issubclass(AnIntFlag, StdlibIntFlag))
- self.assertTrue(isinstance(AnIntFlag.one, StdlibIntFlag))
- #
- if pyver >= PY3_11:
- class AStrEnum(StrFlag):
- one = '1'
- self.assertTrue(issubclass(AStrEnum, StdlibEnum))
- self.assertTrue(isinstance(AStrEnum.one, StdlibEnum))
- self.assertTrue(issubclass(AStrEnum, StdlibStrEnum))
- self.assertTrue(isinstance(AStrEnum.one, StdlibStrEnum))
-
- @unittest.skipUnless(StdlibEnumMeta, 'Stdlib enum not available')
- def test_stdlib_bad_getattribute(self):
- class BadEnumType(StdlibEnumMeta):
- def __getattribute__(cls, name):
- obj = super().__getattribute__(name)
- if isinstance(obj, cls):
- obj.deprecate()
- return obj
- with self.assertRaisesRegex(RecursionError, 'endless recursion'):
- class BaseEnum(StdlibEnum):
- pass
- class BadEnum(BaseEnum, metaclass=BadEnumType):
- FOO = 'bar'
- try:
- remove_stdlib_integration()
- class OkayEnum(StdlibEnum, metaclass=BadEnumType):
- FOO = 'bar'
- finally:
- add_stdlib_integration()
-
- @unittest.skipUnless(pyver >= PY3_5, '__qualname__ requires python 3.5 or greater')
- def test_pickle_enum_function_with_qualname(self):
- Theory = Enum('Theory', 'rule law supposition', qualname='spanish_inquisition')
- globals()['spanish_inquisition'] = Theory
- test_pickle_dump_load(self.assertTrue, Theory.rule)
- test_pickle_dump_load(self.assertTrue, Theory)
-
- def test_auto_init(self):
- class Planet(Enum, init='mass radius'):
- MERCURY = (3.303e+23, 2.4397e6)
- VENUS = (4.869e+24, 6.0518e6)
- EARTH = (5.976e+24, 6.37814e6)
- MARS = (6.421e+23, 3.3972e6)
- JUPITER = (1.9e+27, 7.1492e7)
- SATURN = (5.688e+26, 6.0268e7)
- URANUS = (8.686e+25, 2.5559e7)
- NEPTUNE = (1.024e+26, 2.4746e7)
- @property
- def surface_gravity(self):
- # universal gravitational constant (m3 kg-1 s-2)
- G = 6.67300E-11
- return G * self.mass / (self.radius * self.radius)
- self.assertEqual(round(Planet.EARTH.surface_gravity, 2), 9.80)
- self.assertEqual(Planet.EARTH.value, (5.976e+24, 6.37814e6))
-
- def test_auto_init_with_value(self):
- class Color(Enum, init='value, rgb'):
- RED = 1, (1, 0, 0)
- BLUE = 2, (0, 1, 0)
- GREEN = 3, (0, 0, 1)
- self.assertEqual(Color.RED.value, 1)
- self.assertEqual(Color.BLUE.value, 2)
- self.assertEqual(Color.GREEN.value, 3)
- self.assertEqual(Color.RED.rgb, (1, 0, 0))
- self.assertEqual(Color.BLUE.rgb, (0, 1, 0))
- self.assertEqual(Color.GREEN.rgb, (0, 0, 1))
-
- def test_auto_turns_off(self):
- with self.assertRaises(NameError):
- class Color(Enum, settings=MagicValue):
- red
- green
- blue
- def hello(self):
- print('Hello! My serial is %s.' % self.value)
- rose
- with self.assertRaises(NameError):
- class Color(Enum, settings=MagicValue):
- red
- green
- blue
- def __init__(self, *args):
- pass
- rose
-
- def test_magic(self):
- class Color(Enum, settings=MagicValue):
- red, green, blue
- self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
- self.assertEqual(Color.red.value, 1)
-
- def test_ignore_not_overridden(self):
- with self.assertRaisesRegex(TypeError, 'object is not callable'):
- class Color(Flag):
- _ignore_ = 'irrelevent'
- _settings_ = MagicValue
- @property
- def shade(self):
- print('I am light', self.name.lower())
-
- def test_magic_start(self):
- class Color(Enum, settings=MagicValue, start=0):
- red, green, blue
- self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
- self.assertEqual(Color.red.value, 0)
-
- def test_dir_on_class(self):
- Season = self.Season
- self.assertEqual(
- set(dir(Season)),
- set(['__class__', '__doc__', '__members__', '__module__',
- 'SPRING', 'SUMMER', 'AUTUMN', 'WINTER',
- '__init_subclass__', '__name__', '__getitem__', '__len__',
- '__contains__', '__iter__', '__qualname__',
- ]))
-
- def test_dir_on_item(self):
- Season = self.Season
- self.assertEqual(
- set(dir(Season.WINTER)),
- set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value', 'values']),
- )
-
- def test_dir_with_added_behavior(self):
- class Test(Enum):
- this = 'that'
- these = 'those'
- def wowser(self):
- return ("Wowser! I'm %s!" % self.name)
- self.assertEqual(
- set(dir(Test)),
- set([
- '__class__', '__doc__', '__members__', '__module__', 'this', 'these',
- '__init_subclass__', '__name__', '__getitem__', '__len__',
- '__contains__', '__iter__', '__qualname__',
- ]))
- self.assertEqual(
- set(dir(Test.this)),
- set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value', 'values', 'wowser']),
- )
-
- def test_dir_on_sub_with_behavior_on_super(self):
- # see issue22506
- class SuperEnum(Enum):
- def invisible(self):
- return "did you see me?"
- class SubEnum(SuperEnum):
- sample = 5
- self.assertEqual(
- set(dir(SubEnum.sample)),
- set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value', 'values', 'invisible']),
- )
-
- def test_members_are_always_ordered(self):
- class AlwaysOrdered(Enum):
- first = 1
- second = 2
- third = 3
- self.assertTrue(type(AlwaysOrdered.__members__) is OrderedDict)
-
- def test_comparisons(self):
- def bad_compare():
- Season.SPRING > 4
- Season = self.Season
- self.assertNotEqual(Season.SPRING, 1)
- self.assertRaises(TypeError, bad_compare)
-
- class Part(Enum):
- SPRING = 1
- CLIP = 2
- BARREL = 3
-
- self.assertNotEqual(Season.SPRING, Part.SPRING)
- def bad_compare():
- Season.SPRING < Part.CLIP
- self.assertRaises(TypeError, bad_compare)
-
- def test_duplicate_name(self):
- with self.assertRaises(TypeError):
- class Color1(Enum):
- red = 1
- green = 2
- blue = 3
- red = 4
-
- with self.assertRaises(TypeError):
- class Color2(Enum):
- red = 1
- green = 2
- blue = 3
- def red(self):
- return 'red'
-
- with self.assertRaises(TypeError):
- class Color3(Enum):
- @property
- def red(self):
- return 'redder'
- red = 1
- green = 2
- blue = 3
-
- def test_duplicate_value_with_unique(self):
- with self.assertRaises(ValueError):
- class Color(Enum, settings=Unique):
- red = 1
- green = 2
- blue = 3
- rojo = 1
-
- def test_duplicate_value_with_noalias(self):
- class Color(Enum, settings=NoAlias):
- red = 1
- green = 2
- blue = 3
- rojo = 1
- self.assertFalse(Color.red is Color.rojo)
- self.assertEqual(Color.red.value, 1)
- self.assertEqual(Color.rojo.value, 1)
- self.assertEqual(len(Color), 4)
- self.assertEqual(list(Color), [Color.red, Color.green, Color.blue, Color.rojo])
-
- def test_noalias_value_lookup(self):
- class Color(Enum, settings=NoAlias):
- red = 1
- green = 2
- blue = 3
- rojo = 1
- self.assertRaises(TypeError, Color, 2)
-
- def test_multivalue(self):
- class Color(Enum, settings=MultiValue):
- red = 1, 'red'
- green = 2, 'green'
- blue = 3, 'blue'
- self.assertEqual(Color.red.value, 1)
- self.assertIs(Color('green'), Color.green)
- self.assertEqual(Color.blue.values, (3, 'blue'))
-
- def test_multivalue_with_duplicate_values(self):
- with self.assertRaises(ValueError):
- class Color(Enum, settings=MultiValue):
- red = 1, 'red'
- green = 2, 'green'
- blue = 3, 'blue', 'red'
-
- def test_multivalue_with_duplicate_values_and_noalias(self):
- with self.assertRaises(TypeError):
- class Color(Enum, settings=(MultiValue, NoAlias)):
- red = 1, 'red'
- green = 2, 'green'
- blue = 3, 'blue', 'red'
-
- def test_multivalue_and_auto(self):
- with self.assertRaisesRegex(TypeError, r'MultiValue and MagicValue are mutually exclusive'):
- class Color(Enum, settings=(MultiValue, MagicValue)):
- red
- green = 3, 'green'
- blue
-
- def test_autonumber_and_init(self):
- class Field(IntEnum, settings=AddValue, init='__doc__'):
- TYPE = "Char, Date, Logical, etc."
- START = "Field offset in record"
- self.assertEqual(Field.TYPE, 1)
- self.assertEqual(Field.START, 2)
- self.assertEqual(Field.TYPE.__doc__, 'Char, Date, Logical, etc.')
- self.assertEqual(Field.START.__doc__, 'Field offset in record')
- self.assertFalse(hasattr(Field, '_order_'))
-
- def test_autovalue_and_init(self):
- class Field(IntEnum, init='value __doc__'):
- TYPE = "Char, Date, Logical, etc."
- START = "Field offset in record"
- self.assertEqual(Field.TYPE, 1)
- self.assertEqual(Field.START.__doc__, 'Field offset in record')
-
- def test_autonumber_and_start(self):
- class Field(IntEnum, init='__doc__', settings=AddValue, start=0):
- TYPE = "Char, Date, Logical, etc."
- START = "Field offset in record"
- self.assertEqual(Field.TYPE, 0)
- self.assertEqual(Field.START, 1)
- self.assertEqual(Field.TYPE.__doc__, 'Char, Date, Logical, etc.')
- self.assertEqual(Field.START.__doc__, 'Field offset in record')
-
- def test_autonumber_and_init_and_some_values(self):
- class Field(IntEnum, init='value __doc__'):
- TYPE = "Char, Date, Logical, etc."
- START = "Field offset in record"
- BLAH = 5, "test blah"
- BELCH = 'test belch'
- self.assertEqual(Field.TYPE, 1)
- self.assertEqual(Field.START, 2)
- self.assertEqual(Field.BLAH, 5)
- self.assertEqual(Field.BELCH, 6)
- self.assertEqual(Field.TYPE.__doc__, 'Char, Date, Logical, etc.')
- self.assertEqual(Field.START.__doc__, 'Field offset in record')
- self.assertEqual(Field.BLAH.__doc__, 'test blah')
- self.assertEqual(Field.BELCH.__doc__, 'test belch')
-
- def test_autonumber_with_irregular_values(self):
- class Point(AutoNumberEnum, init='x y'):
- first = 7, 9
- second = 11, 13
- self.assertEqual(Point.first.value, 1)
- self.assertEqual(Point.first.x, 7)
- self.assertEqual(Point.first.y, 9)
- self.assertEqual(Point.second.value, 2)
- self.assertEqual(Point.second.x, 11)
- self.assertEqual(Point.second.y, 13)
- with self.assertRaisesRegex(TypeError, '.*number of fields provided do not match init ...x., .y.. != .3, 11, 13..'):
- class Point(AutoNumberEnum, init='x y'):
- first = 7, 9
- second = 3, 11, 13
- class Color(AutoNumberEnum, init='__doc__'):
- # interactions between AutoNumberEnum and _generate_next_value_ may not be pretty
- red = ()
- green = 'red'
- blue = ()
- self.assertTrue(Color.red.__doc__, 1)
- self.assertEqual(Color.green.__doc__, 'red')
- self.assertTrue(Color.blue.__doc__, 2)
-
- def test_autonumber_and_property(self):
- with self.assertRaises(TypeError):
- class Color(AutoEnum):
- _ignore_ = ()
- red = ()
- green = ()
- blue = ()
- @property
- def cap_name(self) -> str:
- return self.name.title()
-
- def test_autoenum(self):
- class Color(AutoEnum):
- red
- green
- blue
- self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
- self.assertEqual([m.value for m in Color], [1, 2, 3])
- self.assertEqual([m.name for m in Color], ['red', 'green', 'blue'])
-
- def test_autoenum_with_str(self):
- class Color(AutoEnum):
- def _generate_next_value_(name, start, count, last_values):
- return name
- red
- green
- blue
- self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
- self.assertEqual([m.value for m in Color], ['red', 'green', 'blue'])
- self.assertEqual([m.name for m in Color], ['red', 'green', 'blue'])
-
- def test_autoenum_and_default_ignore(self):
- class Color(AutoEnum):
- red
- green
- blue
- @property
- def cap_name(self):
- return self.name.title()
- self.assertEqual(Color.blue.cap_name, 'Blue')
-
- def test_autonumber_and_overridden_ignore(self):
- with self.assertRaises(TypeError):
- class Color(AutoEnum):
- _ignore_ = 'staticmethod'
- red
- green
- blue
- @property
- def cap_name(self) -> str:
- return self.name.title()
-
- def test_autonumber_and_multiple_assignment(self):
- class Color(AutoEnum):
- _ignore_ = 'property'
- red
- green
- blue = cyan
- @property
- def cap_name(self) -> str:
- return self.name.title()
- self.assertEqual(Color.blue.cap_name, 'Cyan')
-
- def test_multivalue_and_autonumber_inherited(self):
- class Measurement(int, Enum, settings=(MultiValue, AddValue), start=0):
- one = "20110721"
- two = "20120911"
- three = "20110518"
- M = Measurement
- self.assertEqual(M.one, 0)
- self.assertTrue(M.one is M(0) is M('20110721'))
-
- def test_combine_new_settings_with_old_settings(self):
- class Auto(Enum, settings=Unique):
- pass
- with self.assertRaises(ValueError):
- class AutoUnique(Auto, settings=MagicValue):
- BLAH
- BLUH
- ICK = 1
-
- def test_timedelta(self):
- class Period(timedelta, Enum):
- '''
- different lengths of time
- '''
- _init_ = 'value period'
- _settings_ = NoAlias
- _ignore_ = 'Period i'
- Period = vars()
- for i in range(31):
- Period['day_%d' % i] = i, 'day'
- for i in range(15):
- Period['week_%d' % i] = i*7, 'week'
- for i in range(12):
- Period['month_%d' % i] = i*30, 'month'
- OneDay = day_1
- OneWeek = week_1
- self.assertFalse(hasattr(Period, '_ignore_'))
- self.assertFalse(hasattr(Period, 'Period'))
- self.assertFalse(hasattr(Period, 'i'))
- self.assertTrue(isinstance(Period.day_1, timedelta))
-
- def test_extend_enum_plain(self):
- class Color(UniqueEnum):
- red = 1
- green = 2
- blue = 3
- extend_enum(Color, 'brown', 4)
- self.assertEqual(Color.brown.name, 'brown')
- self.assertEqual(Color.brown.value, 4)
- self.assertTrue(Color.brown in Color)
- self.assertEqual(len(Color), 4)
-
- def test_extend_enum_shadow(self):
- class Color(UniqueEnum):
- red = 1
- green = 2
- blue = 3
- extend_enum(Color, 'value', 4)
- self.assertEqual(Color.value.name, 'value')
- self.assertEqual(Color.value.value, 4)
- self.assertTrue(Color.value in Color)
- self.assertEqual(len(Color), 4)
- self.assertEqual(Color.red.value, 1)
-
- def test_extend_enum_generate(self):
- class Foo(AutoEnum):
- def _generate_next_value_(name, start, count, values, *args, **kwds):
- return name
- a
- b
- #
- extend_enum(Foo, 'c')
- self.assertEqual(Foo.a.value, 'a')
- self.assertEqual(Foo.b.value, 'b')
- self.assertEqual(Foo.c.value, 'c')
-
- def test_extend_enum_unique_with_duplicate(self):
- with self.assertRaises(ValueError):
- class Color(Enum, settings=Unique):
- red = 1
- green = 2
- blue = 3
- extend_enum(Color, 'value', 1)
-
- 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 test_extend_enum_noalias_with_duplicate(self):
- class Color(Enum, settings=NoAlias):
- red = 1
- green = 2
- blue = 3
- extend_enum(Color, 'value', 3, )
- self.assertRaises(TypeError, Color, 3)
- self.assertFalse(Color.value is Color.blue)
- self.assertTrue(Color.value.value, 3)
-
- def test_no_duplicates(self):
- def bad_duplicates():
- class Color(UniqueEnum):
- red = 1
- green = 2
- blue = 3
- class Color(UniqueEnum):
- red = 1
- green = 2
- blue = 3
- grene = 2
- self.assertRaises(ValueError, bad_duplicates)
-
- def test_no_duplicates_kinda(self):
- class Silly(UniqueEnum):
- one = 1
- two = 'dos'
- name = 3
- class Sillier(IntEnum, UniqueEnum):
- single = 1
- name = 2
- triple = 3
- value = 4
-
- def test_auto_number(self):
- class Color(Enum, settings=MagicValue):
- red
- blue
- green
-
- self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
- self.assertEqual(Color.red.value, 1)
- self.assertEqual(Color.blue.value, 2)
- self.assertEqual(Color.green.value, 3)
-
- def test_auto_name(self):
- class Color(Enum, settings=MagicValue):
- def _generate_next_value_(name, start, count, last):
- return name
- red
- blue
- green
-
- self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
- self.assertEqual(Color.red.value, 'red')
- self.assertEqual(Color.blue.value, 'blue')
- self.assertEqual(Color.green.value, 'green')
-
- def test_auto_name_inherit(self):
- class AutoNameEnum(Enum):
- def _generate_next_value_(name, start, count, last):
- return name
- class Color(AutoNameEnum, settings=MagicValue):
- red
- blue
- green
-
- self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
- self.assertEqual(Color.red.value, 'red')
- self.assertEqual(Color.blue.value, 'blue')
- self.assertEqual(Color.green.value, 'green')
-
- def test_auto_garbage(self):
- class Color(Enum):
- _settings_ = MagicValue
- red = 'red'
- blue
- self.assertEqual(Color.blue.value, 1)
-
- def test_auto_garbage_corrected(self):
- class Color(Enum, settings=MagicValue):
- red = 'red'
- blue = 2
- green
-
- self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
- self.assertEqual(Color.red.value, 'red')
- self.assertEqual(Color.blue.value, 2)
- self.assertEqual(Color.green.value, 3)
-
- def test_duplicate_auto(self):
- class Dupes(Enum, settings=MagicValue):
- first = primero
- second
- third
- self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
-
- def test_order_as_function(self):
- # first with _init_
- class TestSequence(Enum):
- _init_ = 'value, sequence'
- _order_ = lambda member: member.sequence
- item_id = 'An$(1,6)', 0 # Item Code
- company_id = 'An$(7,2)', 1 # Company Code
- warehouse_no = 'An$(9,4)', 2 # Warehouse Number
- company = 'Hn$(13,6)', 3 # 4 SPACES + COMPANY
- key_type = 'Cn$(19,3)', 4 # Key Type = '1**'
- available = 'Zn$(1,1)', 5 # Available?
- contract_item = 'Bn(2,1)', 6 # Contract Item?
- sales_category = 'Fn', 7 # Sales Category
- gl_category = 'Rn$(5,1)', 8 # G/L Category
- warehouse_category = 'Sn$(6,1)', 9 # Warehouse Category
- inv_units = 'Qn$(7,2)', 10 # Inv Units
- for i, member in enumerate(TestSequence):
- self.assertEqual(i, member.sequence)
- ts = TestSequence
- self.assertEqual(ts.item_id.name, 'item_id')
- self.assertEqual(ts.item_id.value, 'An$(1,6)')
- self.assertEqual(ts.item_id.sequence, 0)
- self.assertEqual(ts.company_id.name, 'company_id')
- self.assertEqual(ts.company_id.value, 'An$(7,2)')
- self.assertEqual(ts.company_id.sequence, 1)
- self.assertEqual(ts.warehouse_no.name, 'warehouse_no')
- self.assertEqual(ts.warehouse_no.value, 'An$(9,4)')
- self.assertEqual(ts.warehouse_no.sequence, 2)
- self.assertEqual(ts.company.name, 'company')
- self.assertEqual(ts.company.value, 'Hn$(13,6)')
- self.assertEqual(ts.company.sequence, 3)
- self.assertEqual(ts.key_type.name, 'key_type')
- self.assertEqual(ts.key_type.value, 'Cn$(19,3)')
- self.assertEqual(ts.key_type.sequence, 4)
- self.assertEqual(ts.available.name, 'available')
- self.assertEqual(ts.available.value, 'Zn$(1,1)')
- self.assertEqual(ts.available.sequence, 5)
- self.assertEqual(ts.contract_item.name, 'contract_item')
- self.assertEqual(ts.contract_item.value, 'Bn(2,1)')
- self.assertEqual(ts.contract_item.sequence, 6)
- self.assertEqual(ts.sales_category.name, 'sales_category')
- self.assertEqual(ts.sales_category.value, 'Fn')
- self.assertEqual(ts.sales_category.sequence, 7)
- self.assertEqual(ts.gl_category.name, 'gl_category')
- self.assertEqual(ts.gl_category.value, 'Rn$(5,1)')
- self.assertEqual(ts.gl_category.sequence, 8)
- self.assertEqual(ts.warehouse_category.name, 'warehouse_category')
- self.assertEqual(ts.warehouse_category.value, 'Sn$(6,1)')
- self.assertEqual(ts.warehouse_category.sequence, 9)
- self.assertEqual(ts.inv_units.name, 'inv_units')
- self.assertEqual(ts.inv_units.value, 'Qn$(7,2)')
- self.assertEqual(ts.inv_units.sequence, 10)
- # and then without
- class TestSequence(Enum):
- _order_ = lambda member: member.value[1]
- item_id = 'An$(1,6)', 0 # Item Code
- company_id = 'An$(7,2)', 1 # Company Code
- warehouse_no = 'An$(9,4)', 2 # Warehouse Number
- company = 'Hn$(13,6)', 3 # 4 SPACES + COMPANY
- key_type = 'Cn$(19,3)', 4 # Key Type = '1**'
- available = 'Zn$(1,1)', 5 # Available?
- contract_item = 'Bn(2,1)', 6 # Contract Item?
- sales_category = 'Fn', 7 # Sales Category
- gl_category = 'Rn$(5,1)', 8 # G/L Category
- warehouse_category = 'Sn$(6,1)', 9 # Warehouse Category
- inv_units = 'Qn$(7,2)', 10 # Inv Units
- for i, member in enumerate(TestSequence):
- self.assertEqual(i, member.value[1])
- ts = TestSequence
- self.assertEqual(ts.item_id.name, 'item_id')
- self.assertEqual(ts.item_id.value, ('An$(1,6)', 0))
- self.assertEqual(ts.company_id.name, 'company_id')
- self.assertEqual(ts.company_id.value, ('An$(7,2)', 1))
- self.assertEqual(ts.warehouse_no.name, 'warehouse_no')
- self.assertEqual(ts.warehouse_no.value, ('An$(9,4)', 2))
- self.assertEqual(ts.company.name, 'company')
- self.assertEqual(ts.company.value, ('Hn$(13,6)', 3))
- self.assertEqual(ts.key_type.name, 'key_type')
- self.assertEqual(ts.key_type.value, ('Cn$(19,3)', 4))
- self.assertEqual(ts.available.name, 'available')
- self.assertEqual(ts.available.value, ('Zn$(1,1)', 5))
- self.assertEqual(ts.contract_item.name, 'contract_item')
- self.assertEqual(ts.contract_item.value, ('Bn(2,1)', 6))
- self.assertEqual(ts.sales_category.name, 'sales_category')
- self.assertEqual(ts.sales_category.value, ('Fn', 7))
- self.assertEqual(ts.gl_category.name, 'gl_category')
- self.assertEqual(ts.gl_category.value, ('Rn$(5,1)', 8))
- self.assertEqual(ts.warehouse_category.name, 'warehouse_category')
- self.assertEqual(ts.warehouse_category.value, ('Sn$(6,1)', 9))
- self.assertEqual(ts.inv_units.name, 'inv_units')
- self.assertEqual(ts.inv_units.value, ('Qn$(7,2)', 10))
- # then with _init_ but without value
- with self.assertRaises(TypeError):
- class TestSequence(Enum):
- _init_ = 'sequence'
- _order_ = lambda member: member.sequence
- item_id = 'An$(1,6)', 0 # Item Code
- company_id = 'An$(7,2)', 1 # Company Code
- warehouse_no = 'An$(9,4)', 2 # Warehouse Number
- company = 'Hn$(13,6)', 3 # 4 SPACES + COMPANY
- key_type = 'Cn$(19,3)', 4 # Key Type = '1**'
- available = 'Zn$(1,1)', 5 # Available?
- contract_item = 'Bn(2,1)', 6 # Contract Item?
- sales_category = 'Fn', 7 # Sales Category
- gl_category = 'Rn$(5,1)', 8 # G/L Category
- warehouse_category = 'Sn$(6,1)', 9 # Warehouse Category
- inv_units = 'Qn$(7,2)', 10 # Inv Units
- # finally, out of order so Python 3 barfs
- with self.assertRaises(TypeError):
- class TestSequence(Enum):
- _init_ = 'sequence'
- _order_ = lambda member: member.sequence
- item_id = 'An$(1,6)', 0 # Item Code
- warehouse_no = 'An$(9,4)', 2 # Warehouse Number
- company = 'Hn$(13,6)', 3 # 4 SPACES + COMPANY
- company_id = 'An$(7,2)', 1 # Company Code
- inv_units = 'Qn$(7,2)', 10 # Inv Units
- available = 'Zn$(1,1)', 5 # Available?
- contract_item = 'Bn(2,1)', 6 # Contract Item?
- sales_category = 'Fn', 7 # Sales Category
- key_type = 'Cn$(19,3)', 4 # Key Type = '1**'
- gl_category = 'Rn$(5,1)', 8 # G/L Category
- warehouse_category = 'Sn$(6,1)', 9 # Warehouse Category
-
- if pyver >= PY3_3:
- def test_missing(self):
- class Color(Enum):
- red = 1
- green = 2
- blue = 3
- @classmethod
- def _missing_(cls, item):
- if item == 'three':
- return cls.blue
- elif item == 'bad return':
- # trigger internal error
- return 5
- elif item == 'error out':
- raise ZeroDivisionError
- else:
- # trigger not found
- return None
- self.assertIs(Color('three'), Color.blue)
- self.assertRaises(ValueError, Color, 7)
- try:
- Color('bad return')
- except TypeError as exc:
- self.assertTrue(isinstance(exc.__cause__, ValueError))
- else:
- raise Exception('Exception not raised.')
- try:
- Color('error out')
- except ZeroDivisionError as exc:
- self.assertTrue(isinstance(exc.__cause__, ValueError))
- else:
- raise Exception('Exception not raised.')
-
- def test_enum_of_types(self):
- """Support using Enum to refer to types deliberately."""
- class MyTypes(Enum):
- i = int
- f = float
- s = str
- self.assertEqual(MyTypes.i.value, int)
- self.assertEqual(MyTypes.f.value, float)
- self.assertEqual(MyTypes.s.value, str)
- class Foo:
- pass
- class Bar:
- pass
- class MyTypes2(Enum):
- a = Foo
- b = Bar
- self.assertEqual(MyTypes2.a.value, Foo)
- self.assertEqual(MyTypes2.b.value, Bar)
- class SpamEnumNotInner:
- pass
- class SpamEnum(Enum):
- spam = SpamEnumNotInner
- self.assertEqual(SpamEnum.spam.value, SpamEnumNotInner)
-
- def test_nested_classes_in_enum_do_not_create_members(self):
- """Support locally-defined nested classes."""
- # manually set __qualname__ to remove testing framework noise
- class Outer(Enum):
- __qualname__ = "Outer"
- a = 1
- b = 2
- class Inner(Enum):
- __qualname__ = "Outer.Inner"
- foo = 10
- bar = 11
- self.assertTrue(isinstance(Outer.Inner, type))
- self.assertEqual(Outer.a.value, 1)
- self.assertEqual(Outer.Inner.foo.value, 10)
- self.assertEqual(
- list(Outer.Inner),
- [Outer.Inner.foo, Outer.Inner.bar],
- )
- self.assertEqual(
- list(Outer),
- [Outer.a, Outer.b],
- )
-
- if pyver == PY3_4:
- def test_class_nested_enum_and_pickle_protocol_four(self):
- # would normally just have this directly in the class namespace
- class NestedEnum(Enum):
- twigs = 'common'
- shiny = 'rare'
-
- self.__class__.NestedEnum = NestedEnum
- self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
- test_pickle_exception(
- self.assertRaises, PicklingError, self.NestedEnum.twigs,
- protocol=(0, 3))
- test_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs,
- protocol=(4, HIGHEST_PROTOCOL))
-
- elif pyver >= PY3_5:
- def test_class_nested_enum_and_pickle_protocol_four(self):
- # would normally just have this directly in the class namespace
- class NestedEnum(Enum):
- twigs = 'common'
- shiny = 'rare'
-
- self.__class__.NestedEnum = NestedEnum
- self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
- test_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs,
- protocol=(0, HIGHEST_PROTOCOL))
-
- if pyver >= PY3_4:
- def test_enum_injection(self):
- class Color(Enum):
- _order_ = 'BLACK WHITE'
- BLACK = Color('black', '#000')
- WHITE = Color('white', '#fff')
-
- def __init__(self, label, hex):
- self.label = label
- self.hex = hex
-
- self.assertEqual([Color.BLACK, Color.WHITE], list(Color))
- self.assertEqual(Color.WHITE.hex, '#fff')
- self.assertEqual(Color.BLACK.label, 'black')
-
- def test_subclasses_with_getnewargs_ex(self):
- class NamedInt(int):
- __qualname__ = 'NamedInt' # needed for pickle protocol 4
- def __new__(cls, *args):
- _args = args
- if len(args) < 2:
- raise TypeError("name and value must be specified")
- name, args = args[0], args[1:]
- self = int.__new__(cls, *args)
- self._intname = name
- self._args = _args
- return self
- def __getnewargs_ex__(self):
- return self._args, {}
- @property
- def __name__(self):
- return self._intname
- def __repr__(self):
- # repr() is updated to include the name and type info
- return "{}({!r}, {})".format(type(self).__name__,
- self.__name__,
- int.__repr__(self))
- def __str__(self):
- # str() is unchanged, even if it relies on the repr() fallback
- base = int
- base_str = base.__str__
- if base_str.__objclass__ is object:
- return base.__repr__(self)
- return base_str(self)
- # for simplicity, we only define one operator that
- # propagates expressions
- def __add__(self, other):
- temp = int(self) + int( other)
- if isinstance(self, NamedInt) and isinstance(other, NamedInt):
- return NamedInt(