| import collections.abc | |
| import pickle | |
| import sys | |
| import typing | |
| import warnings | |
| from contextlib import contextmanager | |
| from unittest import TestCase, main | |
| from mypy_extensions import TypedDict, i64, i32, i16, i8, u64, u32, u16, u8 | |
| class BaseTestCase(TestCase): | |
| def assertIsSubclass(self, cls, class_or_tuple, msg=None): | |
| if not issubclass(cls, class_or_tuple): | |
| message = '%r is not a subclass of %r' % (cls, class_or_tuple) | |
| if msg is not None: | |
| message += ' : %s' % msg | |
| raise self.failureException(message) | |
| def assertNotIsSubclass(self, cls, class_or_tuple, msg=None): | |
| if issubclass(cls, class_or_tuple): | |
| message = '%r is a subclass of %r' % (cls, class_or_tuple) | |
| if msg is not None: | |
| message += ' : %s' % msg | |
| raise self.failureException(message) | |
| with warnings.catch_warnings(): | |
| warnings.simplefilter("ignore", category=DeprecationWarning) | |
| Label = TypedDict('Label', [('label', str)]) | |
| class Point2D(TypedDict): | |
| x: int | |
| y: int | |
| class LabelPoint2D(Point2D, Label): ... | |
| class Options(TypedDict, total=False): | |
| log_level: int | |
| log_path: str | |
| class TypedDictTests(BaseTestCase): | |
| @contextmanager | |
| def assert_typeddict_deprecated(self): | |
| with self.assertWarnsRegex( | |
| DeprecationWarning, "mypy_extensions.TypedDict is deprecated" | |
| ): | |
| yield | |
| def test_basics_iterable_syntax(self): | |
| with self.assert_typeddict_deprecated(): | |
| Emp = TypedDict('Emp', {'name': str, 'id': int}) | |
| self.assertIsSubclass(Emp, dict) | |
| self.assertIsSubclass(Emp, typing.MutableMapping) | |
| self.assertNotIsSubclass(Emp, collections.abc.Sequence) | |
| jim = Emp(name='Jim', id=1) | |
| self.assertIs(type(jim), dict) | |
| self.assertEqual(jim['name'], 'Jim') | |
| self.assertEqual(jim['id'], 1) | |
| self.assertEqual(Emp.__name__, 'Emp') | |
| self.assertEqual(Emp.__module__, __name__) | |
| self.assertEqual(Emp.__bases__, (dict,)) | |
| self.assertEqual(Emp.__annotations__, {'name': str, 'id': int}) | |
| self.assertEqual(Emp.__total__, True) | |
| def test_basics_keywords_syntax(self): | |
| with self.assert_typeddict_deprecated(): | |
| Emp = TypedDict('Emp', name=str, id=int) | |
| self.assertIsSubclass(Emp, dict) | |
| self.assertIsSubclass(Emp, typing.MutableMapping) | |
| self.assertNotIsSubclass(Emp, collections.abc.Sequence) | |
| jim = Emp(name='Jim', id=1) # type: ignore # mypy doesn't support keyword syntax yet | |
| self.assertIs(type(jim), dict) | |
| self.assertEqual(jim['name'], 'Jim') | |
| self.assertEqual(jim['id'], 1) | |
| self.assertEqual(Emp.__name__, 'Emp') | |
| self.assertEqual(Emp.__module__, __name__) | |
| self.assertEqual(Emp.__bases__, (dict,)) | |
| self.assertEqual(Emp.__annotations__, {'name': str, 'id': int}) | |
| self.assertEqual(Emp.__total__, True) | |
| def test_typeddict_errors(self): | |
| with self.assert_typeddict_deprecated(): | |
| Emp = TypedDict('Emp', {'name': str, 'id': int}) | |
| self.assertEqual(TypedDict.__module__, 'mypy_extensions') | |
| jim = Emp(name='Jim', id=1) | |
| with self.assertRaises(TypeError): | |
| isinstance({}, Emp) # type: ignore | |
| with self.assertRaises(TypeError): | |
| isinstance(jim, Emp) # type: ignore | |
| with self.assertRaises(TypeError): | |
| issubclass(dict, Emp) # type: ignore | |
| with self.assertRaises(TypeError), self.assert_typeddict_deprecated(): | |
| TypedDict('Hi', x=()) | |
| with self.assertRaises(TypeError), self.assert_typeddict_deprecated(): | |
| TypedDict('Hi', [('x', int), ('y', ())]) | |
| with self.assertRaises(TypeError): | |
| TypedDict('Hi', [('x', int)], y=int) | |
| def test_py36_class_syntax_usage(self): | |
| self.assertEqual(LabelPoint2D.__name__, 'LabelPoint2D') # noqa | |
| self.assertEqual(LabelPoint2D.__module__, __name__) # noqa | |
| self.assertEqual(LabelPoint2D.__annotations__, {'x': int, 'y': int, 'label': str}) # noqa | |
| self.assertEqual(LabelPoint2D.__bases__, (dict,)) # noqa | |
| self.assertEqual(LabelPoint2D.__total__, True) # noqa | |
| self.assertNotIsSubclass(LabelPoint2D, typing.Sequence) # noqa | |
| not_origin = Point2D(x=0, y=1) # noqa | |
| self.assertEqual(not_origin['x'], 0) | |
| self.assertEqual(not_origin['y'], 1) | |
| other = LabelPoint2D(x=0, y=1, label='hi') # noqa | |
| self.assertEqual(other['label'], 'hi') | |
| def test_py36_class_usage_emits_deprecations(self): | |
| with self.assert_typeddict_deprecated(): | |
| class Foo(TypedDict): | |
| bar: int | |
| def test_pickle(self): | |
| global EmpD # pickle wants to reference the class by name | |
| with self.assert_typeddict_deprecated(): | |
| EmpD = TypedDict('EmpD', name=str, id=int) | |
| jane = EmpD({'name': 'jane', 'id': 37}) | |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): | |
| z = pickle.dumps(jane, proto) | |
| jane2 = pickle.loads(z) | |
| self.assertEqual(jane2, jane) | |
| self.assertEqual(jane2, {'name': 'jane', 'id': 37}) | |
| ZZ = pickle.dumps(EmpD, proto) | |
| EmpDnew = pickle.loads(ZZ) | |
| self.assertEqual(EmpDnew({'name': 'jane', 'id': 37}), jane) | |
| def test_optional(self): | |
| with self.assert_typeddict_deprecated(): | |
| EmpD = TypedDict('EmpD', name=str, id=int) | |
| self.assertEqual(typing.Optional[EmpD], typing.Union[None, EmpD]) | |
| self.assertNotEqual(typing.List[EmpD], typing.Tuple[EmpD]) | |
| def test_total(self): | |
| with self.assert_typeddict_deprecated(): | |
| D = TypedDict('D', {'x': int}, total=False) | |
| self.assertEqual(D(), {}) | |
| self.assertEqual(D(x=1), {'x': 1}) | |
| self.assertEqual(D.__total__, False) | |
| self.assertEqual(Options(), {}) # noqa | |
| self.assertEqual(Options(log_level=2), {'log_level': 2}) # noqa | |
| self.assertEqual(Options.__total__, False) # noqa | |
| native_int_types = [i64, i32, i16, i8, u64, u32, u16, u8] | |
| class MypycNativeIntTests(TestCase): | |
| def test_construction(self): | |
| for native_int in native_int_types: | |
| self.assert_same(native_int(), 0) | |
| self.assert_same(native_int(0), 0) | |
| self.assert_same(native_int(1), 1) | |
| self.assert_same(native_int(-3), -3) | |
| self.assert_same(native_int(2**64), 2**64) | |
| self.assert_same(native_int(-2**64), -2**64) | |
| self.assert_same(native_int(1.234), 1) | |
| self.assert_same(native_int(2.634), 2) | |
| self.assert_same(native_int(-1.234), -1) | |
| self.assert_same(native_int(-2.634), -2) | |
| self.assert_same(native_int("0"), 0) | |
| self.assert_same(native_int("123"), 123) | |
| self.assert_same(native_int("abc", 16), 2748) | |
| self.assert_same(native_int("-101", base=2), -5) | |
| def test_isinstance(self): | |
| for native_int in native_int_types: | |
| assert isinstance(0, native_int) | |
| assert isinstance(1234, native_int) | |
| assert isinstance(True, native_int) | |
| assert not isinstance(1.0, native_int) | |
| def test_docstring(self): | |
| for native_int in native_int_types: | |
| # Just check that a docstring exists | |
| assert native_int.__doc__ | |
| def assert_same(self, x, y): | |
| assert type(x) is type(y) | |
| assert x == y | |
| class DeprecationTests(TestCase): | |
| def test_no_return_deprecation(self): | |
| del sys.modules["mypy_extensions"] | |
| with self.assertWarnsRegex( | |
| DeprecationWarning, "'mypy_extensions.NoReturn' is deprecated" | |
| ): | |
| import mypy_extensions | |
| mypy_extensions.NoReturn | |
| del sys.modules["mypy_extensions"] | |
| with self.assertWarnsRegex( | |
| DeprecationWarning, "'mypy_extensions.NoReturn' is deprecated" | |
| ): | |
| from mypy_extensions import NoReturn # noqa: F401 | |
| if __name__ == '__main__': | |
| main() |