Mailman 3 July 2016 - Python-checkins

cpython: Issue #27652: Expose ESHUTDOWN conditionally
by berker.peksag July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/77d16a5dc779 changeset: 102495:77d16a5dc779 user: Berker Peksag <berker.peksag(a)gmail.com> date: Sat Jul 30 14:14:12 2016 +0300 summary: Issue #27652: Expose ESHUTDOWN conditionally ESHUTDOWN is also exposed conditionally in Modules/errnomodule.c. Patch by Ed Schouten. files: Objects/exceptions.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-) diff --git a/Objects/exceptions.c b/Objects/exceptions.c --- a/Objects/exceptions.c +++ b/Objects/exceptions.c @@ -2604,7 +2604,9 @@ ADD_ERRNO(BlockingIOError, EWOULDBLOCK); POST_INIT(BrokenPipeError); ADD_ERRNO(BrokenPipeError, EPIPE); +#ifdef ESHUTDOWN ADD_ERRNO(BrokenPipeError, ESHUTDOWN); +#endif POST_INIT(ChildProcessError); ADD_ERRNO(ChildProcessError, ECHILD); POST_INIT(ConnectionAbortedError); -- Repository URL: https://hg.python.org/cpython

1 0

cpython: Issue #27366: Tweak PEP 487 documentation
by berker.peksag July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/8747e3455ecb changeset: 102494:8747e3455ecb user: Berker Peksag <berker.peksag(a)gmail.com> date: Sat Jul 30 14:06:15 2016 +0300 summary: Issue #27366: Tweak PEP 487 documentation * Added versionadded directives * Deleted duplicate sentence from __init_subclass__ docstring * Modernized tests files: Doc/reference/datamodel.rst | 5 ++ Lib/test/test_subclassinit.py | 44 +++++++++++----------- Objects/typeobject.c | 7 +-- 3 files changed, 30 insertions(+), 26 deletions(-) diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst --- a/Doc/reference/datamodel.rst +++ b/Doc/reference/datamodel.rst @@ -1497,6 +1497,8 @@ Called at the time the owning class *owner* is created. The descriptor has been assigned to *name*. + .. versionadded:: 3.6 + The attribute :attr:`__objclass__` is interpreted by the :mod:`inspect` module as specifying the class where this object was defined (setting this @@ -1648,6 +1650,7 @@ class defining the method. .. classmethod:: object.__init_subclass__(cls) + This method is called whenever the containing class is subclassed. *cls* is then the new subclass. If defined as a normal instance method, this method is implicitly converted to a class method. @@ -1669,6 +1672,8 @@ The default implementation ``object.__init_subclass__`` does nothing, but raises an error if it is called with any arguments. + .. versionadded:: 3.6 + .. _metaclasses: diff --git a/Lib/test/test_subclassinit.py b/Lib/test/test_subclassinit.py --- a/Lib/test/test_subclassinit.py +++ b/Lib/test/test_subclassinit.py @@ -1,11 +1,11 @@ -from unittest import TestCase, main import sys import types +import unittest -class Test(TestCase): +class Test(unittest.TestCase): def test_init_subclass(self): - class A(object): + class A: initialized = False def __init_subclass__(cls): @@ -19,7 +19,7 @@ self.assertTrue(B.initialized) def test_init_subclass_dict(self): - class A(dict, object): + class A(dict): initialized = False def __init_subclass__(cls): @@ -33,7 +33,7 @@ self.assertTrue(B.initialized) def test_init_subclass_kwargs(self): - class A(object): + class A: def __init_subclass__(cls, **kwargs): cls.kwargs = kwargs @@ -43,7 +43,7 @@ self.assertEqual(B.kwargs, dict(x=3)) def test_init_subclass_error(self): - class A(object): + class A: def __init_subclass__(cls): raise RuntimeError @@ -52,7 +52,7 @@ pass def test_init_subclass_wrong(self): - class A(object): + class A: def __init_subclass__(cls, whatever): pass @@ -61,7 +61,7 @@ pass def test_init_subclass_skipped(self): - class BaseWithInit(object): + class BaseWithInit: def __init_subclass__(cls, **kwargs): super().__init_subclass__(**kwargs) cls.initialized = cls @@ -76,7 +76,7 @@ self.assertIs(BaseWithoutInit.initialized, BaseWithoutInit) def test_init_subclass_diamond(self): - class Base(object): + class Base: def __init_subclass__(cls, **kwargs): super().__init_subclass__(**kwargs) cls.calls = [] @@ -84,7 +84,7 @@ class Left(Base): pass - class Middle(object): + class Middle: def __init_subclass__(cls, middle, **kwargs): super().__init_subclass__(**kwargs) cls.calls += [middle] @@ -107,7 +107,7 @@ self.owner = owner self.name = name - class A(object): + class A: d = Descriptor() self.assertEqual(A.d.name, "d") @@ -121,12 +121,12 @@ self.assertIs(ret.d.owner, ret) return 0 - class Descriptor(object): + class Descriptor: def __set_name__(self, owner, name): self.owner = owner self.name = name - class A(object, metaclass=Meta): + class A(metaclass=Meta): d = Descriptor() self.assertEqual(A, 0) @@ -136,7 +136,7 @@ raise RuntimeError with self.assertRaises(RuntimeError): - class A(object): + class A: d = Descriptor() def test_set_name_wrong(self): @@ -145,7 +145,7 @@ pass with self.assertRaises(TypeError): - class A(object): + class A: d = Descriptor() def test_set_name_init_subclass(self): @@ -161,7 +161,7 @@ self.meta_name = self.name return self - class A(object): + class A: def __init_subclass__(cls): cls.owner = cls.d.owner cls.name = cls.d.name @@ -179,7 +179,7 @@ pass with self.assertRaises(TypeError): - class MyClass(object, metaclass=MyMeta, otherarg=1): + class MyClass(metaclass=MyMeta, otherarg=1): pass with self.assertRaises(TypeError): @@ -193,7 +193,7 @@ super().__init__(name, bases, namespace) with self.assertRaises(TypeError): - class MyClass(object, metaclass=MyMeta, otherarg=1): + class MyClass(metaclass=MyMeta, otherarg=1): pass class MyMeta(type): @@ -204,7 +204,7 @@ super().__init__(name, bases, namespace) self.otherarg = otherarg - class MyClass(object, metaclass=MyMeta, otherarg=1): + class MyClass(metaclass=MyMeta, otherarg=1): pass self.assertEqual(MyClass.otherarg, 1) @@ -217,7 +217,7 @@ dict=namespace) with self.assertRaises(TypeError): - class MyClass(object, metaclass=MyMeta): + class MyClass(metaclass=MyMeta): pass class MyMeta(type): @@ -226,7 +226,7 @@ self.otherarg = otherarg return self - class MyClass(object, metaclass=MyMeta, otherarg=1): + class MyClass(metaclass=MyMeta, otherarg=1): pass self.assertEqual(MyClass.otherarg, 1) @@ -241,4 +241,4 @@ if __name__ == "__main__": - main() + unittest.main() diff --git a/Objects/typeobject.c b/Objects/typeobject.c --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -4341,11 +4341,10 @@ } PyDoc_STRVAR(object_init_subclass_doc, -"This method is called when a class is subclassed\n" +"This method is called when a class is subclassed.\n" "\n" -"Whenever a class is subclassed, this method is called. The default\n" -"implementation does nothing. It may be overridden to extend\n" -"subclasses.\n"); +"The default implementation does nothing. It may be\n" +"overridden to extend subclasses.\n"); /* from PEP 3101, this code implements: -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.5): Issue #27453: CPP invocation in configure must use CPPFLAGS.
by xavier.degaye July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/4cb94e561e2d changeset: 102492:4cb94e561e2d branch: 3.5 parent: 102489:57066dbf3d94 user: Xavier de Gaye <xdegaye(a)users.sourceforge.net> date: Sat Jul 30 11:28:35 2016 +0200 summary: Issue #27453: CPP invocation in configure must use CPPFLAGS. Patch by Chi Hsuan Yen. files: Misc/ACKS | 1 + Misc/NEWS | 3 +++ configure | 2 +- configure.ac | 2 +- 4 files changed, 6 insertions(+), 2 deletions(-) diff --git a/Misc/ACKS b/Misc/ACKS --- a/Misc/ACKS +++ b/Misc/ACKS @@ -1663,3 +1663,4 @@ Doug Zongker Peter Åstrand evilzero +Chi Hsuan Yen diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -145,6 +145,9 @@ Build ----- +- Issue #27453: CPP invocation in configure must use CPPFLAGS. Patch by + Chi Hsuan Yen. + - Issue #27490: Do not build pgen when cross-compiling. Patch by Thomas Perl. diff --git a/configure b/configure --- a/configure +++ b/configure @@ -5369,7 +5369,7 @@ EOF -if $CPP conftest.c >conftest.out 2>/dev/null; then +if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then PLATFORM_TRIPLET=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d ' '` { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PLATFORM_TRIPLET" >&5 $as_echo "$PLATFORM_TRIPLET" >&6; } diff --git a/configure.ac b/configure.ac --- a/configure.ac +++ b/configure.ac @@ -870,7 +870,7 @@ EOF -if $CPP conftest.c >conftest.out 2>/dev/null; then +if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then PLATFORM_TRIPLET=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d ' '` AC_MSG_RESULT([$PLATFORM_TRIPLET]) else -- Repository URL: https://hg.python.org/cpython

1 0

cpython (merge 3.5 -> default): (merge from 3.5) Issue #27453: CPP invocation in configure must use CPPFLAGS.
by xavier.degaye July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/92b3ce7ca95c changeset: 102493:92b3ce7ca95c parent: 102491:ecc7bff738e0 parent: 102492:4cb94e561e2d user: Xavier de Gaye <xdegaye(a)users.sourceforge.net> date: Sat Jul 30 11:36:32 2016 +0200 summary: (merge from 3.5) Issue #27453: CPP invocation in configure must use CPPFLAGS. Patch by Chi Hsuan Yen. files: Misc/NEWS | 3 +++ configure | 2 +- configure.ac | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -88,6 +88,9 @@ Build ----- +- Issue #27453: CPP invocation in configure must use CPPFLAGS. Patch by + Chi Hsuan Yen. + - Issue #27490: Do not build pgen when cross-compiling. Patch by Thomas Perl. diff --git a/configure b/configure --- a/configure +++ b/configure @@ -5370,7 +5370,7 @@ EOF -if $CPP conftest.c >conftest.out 2>/dev/null; then +if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then PLATFORM_TRIPLET=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d ' '` { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PLATFORM_TRIPLET" >&5 $as_echo "$PLATFORM_TRIPLET" >&6; } diff --git a/configure.ac b/configure.ac --- a/configure.ac +++ b/configure.ac @@ -870,7 +870,7 @@ EOF -if $CPP conftest.c >conftest.out 2>/dev/null; then +if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then PLATFORM_TRIPLET=`grep -v '^#' conftest.out | grep -v '^ *$' | tr -d ' '` AC_MSG_RESULT([$PLATFORM_TRIPLET]) else -- Repository URL: https://hg.python.org/cpython

1 0

cpython: Issue #27366: Implement PEP 487
by nick.coghlan July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/ecc7bff738e0 changeset: 102491:ecc7bff738e0 user: Nick Coghlan <ncoghlan(a)gmail.com> date: Sat Jul 30 16:26:03 2016 +1000 summary: Issue #27366: Implement PEP 487 - __init_subclass__ called when new subclasses defined - __set_name__ called when descriptors are part of a class definition files: Doc/reference/datamodel.rst | 43 +++- Doc/whatsnew/3.6.rst | 20 + Lib/test/test_builtin.py | 20 +- Lib/test/test_descrtut.py | 1 + Lib/test/test_pydoc.py | 3 +- Lib/test/test_subclassinit.py | 244 ++++++++++++++++++++++ Misc/ACKS | 1 + Misc/NEWS | 4 + Objects/typeobject.c | 99 ++++++++- 9 files changed, 411 insertions(+), 24 deletions(-) diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst --- a/Doc/reference/datamodel.rst +++ b/Doc/reference/datamodel.rst @@ -1492,6 +1492,12 @@ Called to delete the attribute on an instance *instance* of the owner class. +.. method:: object.__set_name__(self, owner, name) + + Called at the time the owning class *owner* is created. The + descriptor has been assigned to *name*. + + The attribute :attr:`__objclass__` is interpreted by the :mod:`inspect` module as specifying the class where this object was defined (setting this appropriately can assist in runtime introspection of dynamic class attributes). @@ -1629,11 +1635,46 @@ * *__class__* assignment works only if both classes have the same *__slots__*. -.. _metaclasses: +.. _class-customization: Customizing class creation -------------------------- +Whenever a class inherits from another class, *__init_subclass__* is +called on that class. This way, it is possible to write classes which +change the behavior of subclasses. This is closely related to class +decorators, but where class decorators only affect the specific class they're +applied to, ``__init_subclass__`` solely applies to future subclasses of the +class defining the method. + +.. classmethod:: object.__init_subclass__(cls) + This method is called whenever the containing class is subclassed. + *cls* is then the new subclass. If defined as a normal instance method, + this method is implicitly converted to a class method. + + Keyword arguments which are given to a new class are passed to + the parent's class ``__init_subclass__``. For compatibility with + other classes using ``__init_subclass__``, one should take out the + needed keyword arguments and pass the others over to the base + class, as in:: + + class Philosopher: + def __init_subclass__(cls, default_name, **kwargs): + super().__init_subclass__(**kwargs) + cls.default_name = default_name + + class AustralianPhilosopher(Philosopher, default_name="Bruce"): + pass + + The default implementation ``object.__init_subclass__`` does + nothing, but raises an error if it is called with any arguments. + + +.. _metaclasses: + +Metaclasses +^^^^^^^^^^^ + By default, classes are constructed using :func:`type`. The class body is executed in a new namespace and the class name is bound locally to the result of ``type(name, bases, namespace)``. diff --git a/Doc/whatsnew/3.6.rst b/Doc/whatsnew/3.6.rst --- a/Doc/whatsnew/3.6.rst +++ b/Doc/whatsnew/3.6.rst @@ -110,6 +110,26 @@ See :pep:`498` and the main documentation at :ref:`f-strings`. +PEP 487: Simpler customization of class creation +------------------------------------------------ + +Upon subclassing a class, the ``__init_subclass__`` classmethod (if defined) is +called on the base class. This makes it straightforward to write classes that +customize initialization of future subclasses without introducing the +complexity of a full custom metaclass. + +The descriptor protocol has also been expanded to include a new optional method, +``__set_name__``. Whenever a new class is defined, the new method will be called +on all descriptors included in the definition, providing them with a reference +to the class being defined and the name given to the descriptor within the +class namespace. + +Also see :pep:`487` and the updated class customization documentation at +:ref:`class-customization` and :ref:`descriptors`. + +(Contributed by Martin Teichmann in :issue:`27366`) + + PYTHONMALLOC environment variable --------------------------------- diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -1699,21 +1699,11 @@ self.assertEqual(x.spam(), 'spam42') self.assertEqual(x.to_bytes(2, 'little'), b'\x2a\x00') - def test_type_new_keywords(self): - class B: - def ham(self): - return 'ham%d' % self - C = type.__new__(type, - name='C', - bases=(B, int), - dict={'spam': lambda self: 'spam%s' % self}) - self.assertEqual(C.__name__, 'C') - self.assertEqual(C.__qualname__, 'C') - self.assertEqual(C.__module__, __name__) - self.assertEqual(C.__bases__, (B, int)) - self.assertIs(C.__base__, int) - self.assertIn('spam', C.__dict__) - self.assertNotIn('ham', C.__dict__) + def test_type_nokwargs(self): + with self.assertRaises(TypeError): + type('a', (), {}, x=5) + with self.assertRaises(TypeError): + type('a', (), dict={}) def test_type_name(self): for name in 'A', '\xc4', '\U0001f40d', 'B.A', '42', '': diff --git a/Lib/test/test_descrtut.py b/Lib/test/test_descrtut.py --- a/Lib/test/test_descrtut.py +++ b/Lib/test/test_descrtut.py @@ -182,6 +182,7 @@ '__iadd__', '__imul__', '__init__', + '__init_subclass__', '__iter__', '__le__', '__len__', diff --git a/Lib/test/test_pydoc.py b/Lib/test/test_pydoc.py --- a/Lib/test/test_pydoc.py +++ b/Lib/test/test_pydoc.py @@ -638,8 +638,9 @@ del expected['__doc__'] del expected['__class__'] # inspect resolves descriptors on type into methods, but vars doesn't, - # so we need to update __subclasshook__. + # so we need to update __subclasshook__ and __init_subclass__. expected['__subclasshook__'] = TestClass.__subclasshook__ + expected['__init_subclass__'] = TestClass.__init_subclass__ methods = pydoc.allmethods(TestClass) self.assertDictEqual(methods, expected) diff --git a/Lib/test/test_subclassinit.py b/Lib/test/test_subclassinit.py new file mode 100644 --- /dev/null +++ b/Lib/test/test_subclassinit.py @@ -0,0 +1,244 @@ +from unittest import TestCase, main +import sys +import types + + +class Test(TestCase): + def test_init_subclass(self): + class A(object): + initialized = False + + def __init_subclass__(cls): + super().__init_subclass__() + cls.initialized = True + + class B(A): + pass + + self.assertFalse(A.initialized) + self.assertTrue(B.initialized) + + def test_init_subclass_dict(self): + class A(dict, object): + initialized = False + + def __init_subclass__(cls): + super().__init_subclass__() + cls.initialized = True + + class B(A): + pass + + self.assertFalse(A.initialized) + self.assertTrue(B.initialized) + + def test_init_subclass_kwargs(self): + class A(object): + def __init_subclass__(cls, **kwargs): + cls.kwargs = kwargs + + class B(A, x=3): + pass + + self.assertEqual(B.kwargs, dict(x=3)) + + def test_init_subclass_error(self): + class A(object): + def __init_subclass__(cls): + raise RuntimeError + + with self.assertRaises(RuntimeError): + class B(A): + pass + + def test_init_subclass_wrong(self): + class A(object): + def __init_subclass__(cls, whatever): + pass + + with self.assertRaises(TypeError): + class B(A): + pass + + def test_init_subclass_skipped(self): + class BaseWithInit(object): + def __init_subclass__(cls, **kwargs): + super().__init_subclass__(**kwargs) + cls.initialized = cls + + class BaseWithoutInit(BaseWithInit): + pass + + class A(BaseWithoutInit): + pass + + self.assertIs(A.initialized, A) + self.assertIs(BaseWithoutInit.initialized, BaseWithoutInit) + + def test_init_subclass_diamond(self): + class Base(object): + def __init_subclass__(cls, **kwargs): + super().__init_subclass__(**kwargs) + cls.calls = [] + + class Left(Base): + pass + + class Middle(object): + def __init_subclass__(cls, middle, **kwargs): + super().__init_subclass__(**kwargs) + cls.calls += [middle] + + class Right(Base): + def __init_subclass__(cls, right="right", **kwargs): + super().__init_subclass__(**kwargs) + cls.calls += [right] + + class A(Left, Middle, Right, middle="middle"): + pass + + self.assertEqual(A.calls, ["right", "middle"]) + self.assertEqual(Left.calls, []) + self.assertEqual(Right.calls, []) + + def test_set_name(self): + class Descriptor: + def __set_name__(self, owner, name): + self.owner = owner + self.name = name + + class A(object): + d = Descriptor() + + self.assertEqual(A.d.name, "d") + self.assertIs(A.d.owner, A) + + def test_set_name_metaclass(self): + class Meta(type): + def __new__(cls, name, bases, ns): + ret = super().__new__(cls, name, bases, ns) + self.assertEqual(ret.d.name, "d") + self.assertIs(ret.d.owner, ret) + return 0 + + class Descriptor(object): + def __set_name__(self, owner, name): + self.owner = owner + self.name = name + + class A(object, metaclass=Meta): + d = Descriptor() + self.assertEqual(A, 0) + + def test_set_name_error(self): + class Descriptor: + def __set_name__(self, owner, name): + raise RuntimeError + + with self.assertRaises(RuntimeError): + class A(object): + d = Descriptor() + + def test_set_name_wrong(self): + class Descriptor: + def __set_name__(self): + pass + + with self.assertRaises(TypeError): + class A(object): + d = Descriptor() + + def test_set_name_init_subclass(self): + class Descriptor: + def __set_name__(self, owner, name): + self.owner = owner + self.name = name + + class Meta(type): + def __new__(cls, name, bases, ns): + self = super().__new__(cls, name, bases, ns) + self.meta_owner = self.owner + self.meta_name = self.name + return self + + class A(object): + def __init_subclass__(cls): + cls.owner = cls.d.owner + cls.name = cls.d.name + + class B(A, metaclass=Meta): + d = Descriptor() + + self.assertIs(B.owner, B) + self.assertEqual(B.name, 'd') + self.assertIs(B.meta_owner, B) + self.assertEqual(B.name, 'd') + + def test_errors(self): + class MyMeta(type): + pass + + with self.assertRaises(TypeError): + class MyClass(object, metaclass=MyMeta, otherarg=1): + pass + + with self.assertRaises(TypeError): + types.new_class("MyClass", (object,), + dict(metaclass=MyMeta, otherarg=1)) + types.prepare_class("MyClass", (object,), + dict(metaclass=MyMeta, otherarg=1)) + + class MyMeta(type): + def __init__(self, name, bases, namespace, otherarg): + super().__init__(name, bases, namespace) + + with self.assertRaises(TypeError): + class MyClass(object, metaclass=MyMeta, otherarg=1): + pass + + class MyMeta(type): + def __new__(cls, name, bases, namespace, otherarg): + return super().__new__(cls, name, bases, namespace) + + def __init__(self, name, bases, namespace, otherarg): + super().__init__(name, bases, namespace) + self.otherarg = otherarg + + class MyClass(object, metaclass=MyMeta, otherarg=1): + pass + + self.assertEqual(MyClass.otherarg, 1) + + def test_errors_changed_pep487(self): + # These tests failed before Python 3.6, PEP 487 + class MyMeta(type): + def __new__(cls, name, bases, namespace): + return super().__new__(cls, name=name, bases=bases, + dict=namespace) + + with self.assertRaises(TypeError): + class MyClass(object, metaclass=MyMeta): + pass + + class MyMeta(type): + def __new__(cls, name, bases, namespace, otherarg): + self = super().__new__(cls, name, bases, namespace) + self.otherarg = otherarg + return self + + class MyClass(object, metaclass=MyMeta, otherarg=1): + pass + + self.assertEqual(MyClass.otherarg, 1) + + def test_type(self): + t = type('NewClass', (object,), {}) + self.assertIsInstance(t, type) + self.assertEqual(t.__name__, 'NewClass') + + with self.assertRaises(TypeError): + type(name='NewClass', bases=(object,), dict={}) + + +if __name__ == "__main__": + main() diff --git a/Misc/ACKS b/Misc/ACKS --- a/Misc/ACKS +++ b/Misc/ACKS @@ -1475,6 +1475,7 @@ Julian Taylor Monty Taylor Anatoly Techtonik +Martin Teichmann Gustavo Temple Mikhail Terekhov Victor Terrón diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -31,6 +31,10 @@ - Issue #27514: Make having too many statically nested blocks a SyntaxError instead of SystemError. +- Issue #27366: Implemented PEP 487 (Simpler customization of class creation). + Upon subclassing, the __init_subclass__ classmethod is called on the base + class. Descriptors are initialized with __set_name__ after class creation. + Library ------- diff --git a/Objects/typeobject.c b/Objects/typeobject.c --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -53,10 +53,12 @@ _Py_IDENTIFIER(__getattribute__); _Py_IDENTIFIER(__getitem__); _Py_IDENTIFIER(__hash__); +_Py_IDENTIFIER(__init_subclass__); _Py_IDENTIFIER(__len__); _Py_IDENTIFIER(__module__); _Py_IDENTIFIER(__name__); _Py_IDENTIFIER(__new__); +_Py_IDENTIFIER(__set_name__); _Py_IDENTIFIER(__setitem__); _Py_IDENTIFIER(builtins); @@ -2027,6 +2029,8 @@ static int object_init(PyObject *, PyObject *, PyObject *); static int update_slot(PyTypeObject *, PyObject *); static void fixup_slot_dispatchers(PyTypeObject *); +static int set_names(PyTypeObject *); +static int init_subclass(PyTypeObject *, PyObject *); /* * Helpers for __dict__ descriptor. We don't want to expose the dicts @@ -2202,7 +2206,8 @@ assert(args != NULL && PyTuple_Check(args)); assert(kwds == NULL || PyDict_Check(kwds)); - if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds) != 0) { + if (kwds != NULL && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 && + PyDict_Check(kwds) && PyDict_Size(kwds) != 0) { PyErr_SetString(PyExc_TypeError, "type.__init__() takes no keyword arguments"); return -1; @@ -2269,7 +2274,6 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) { PyObject *name, *bases = NULL, *orig_dict, *dict = NULL; - static char *kwlist[] = {"name", "bases", "dict", 0}; PyObject *qualname, *slots = NULL, *tmp, *newslots; PyTypeObject *type = NULL, *base, *tmptype, *winner; PyHeapTypeObject *et; @@ -2296,7 +2300,7 @@ /* SF bug 475327 -- if that didn't trigger, we need 3 arguments. but PyArg_ParseTupleAndKeywords below may give a msg saying type() needs exactly 3. */ - if (nargs + nkwds != 3) { + if (nargs != 3) { PyErr_SetString(PyExc_TypeError, "type() takes 1 or 3 arguments"); return NULL; @@ -2304,10 +2308,8 @@ } /* Check arguments: (name, bases, dict) */ - if (!PyArg_ParseTupleAndKeywords(args, kwds, "UO!O!:type", kwlist, - &name, - &PyTuple_Type, &bases, - &PyDict_Type, &orig_dict)) + if (!PyArg_ParseTuple(args, "UO!O!:type", &name, &PyTuple_Type, &bases, + &PyDict_Type, &orig_dict)) return NULL; /* Determine the proper metatype to deal with this: */ @@ -2587,6 +2589,20 @@ Py_DECREF(tmp); } + /* Special-case __init_subclass__: if it's a plain function, + make it a classmethod */ + tmp = _PyDict_GetItemId(dict, &PyId___init_subclass__); + if (tmp != NULL && PyFunction_Check(tmp)) { + tmp = PyClassMethod_New(tmp); + if (tmp == NULL) + goto error; + if (_PyDict_SetItemId(dict, &PyId___init_subclass__, tmp) < 0) { + Py_DECREF(tmp); + goto error; + } + Py_DECREF(tmp); + } + /* Add descriptors for custom slots from __slots__, or for __dict__ */ mp = PyHeapType_GET_MEMBERS(et); slotoffset = base->tp_basicsize; @@ -2667,6 +2683,12 @@ et->ht_cached_keys = _PyDict_NewKeysForClass(); } + if (set_names(type) < 0) + goto error; + + if (init_subclass(type, kwds) < 0) + goto error; + Py_DECREF(dict); return (PyObject *)type; @@ -4312,6 +4334,19 @@ "NotImplemented, the normal algorithm is used. Otherwise, it\n" "overrides the normal algorithm (and the outcome is cached).\n"); +static PyObject * +object_init_subclass(PyObject *cls, PyObject *arg) +{ + Py_RETURN_NONE; +} + +PyDoc_STRVAR(object_init_subclass_doc, +"This method is called when a class is subclassed\n" +"\n" +"Whenever a class is subclassed, this method is called. The default\n" +"implementation does nothing. It may be overridden to extend\n" +"subclasses.\n"); + /* from PEP 3101, this code implements: @@ -4416,6 +4451,8 @@ PyDoc_STR("helper for pickle")}, {"__subclasshook__", object_subclasshook, METH_CLASS | METH_VARARGS, object_subclasshook_doc}, + {"__init_subclass__", object_init_subclass, METH_CLASS | METH_NOARGS, + object_init_subclass_doc}, {"__format__", object_format, METH_VARARGS, PyDoc_STR("default object formatter")}, {"__sizeof__", object_sizeof, METH_NOARGS, @@ -6925,6 +6962,54 @@ } } +/* Call __set_name__ on all descriptors in a newly generated type */ +static int +set_names(PyTypeObject *type) +{ + PyObject *key, *value, *tmp; + Py_ssize_t i = 0; + + while (PyDict_Next(type->tp_dict, &i, &key, &value)) { + if (PyObject_HasAttr(value, _PyUnicode_FromId(&PyId___set_name__))) { + tmp = PyObject_CallMethodObjArgs( + value, _PyUnicode_FromId(&PyId___set_name__), + type, key, NULL); + if (tmp == NULL) + return -1; + else + Py_DECREF(tmp); + } + } + + return 0; +} + +/* Call __init_subclass__ on the parent of a newly generated type */ +static int +init_subclass(PyTypeObject *type, PyObject *kwds) +{ + PyObject *super, *func, *tmp, *tuple; + + super = PyObject_CallFunctionObjArgs((PyObject *) &PySuper_Type, + type, type, NULL); + func = _PyObject_GetAttrId(super, &PyId___init_subclass__); + Py_DECREF(super); + + if (func == NULL) + return -1; + + tuple = PyTuple_New(0); + tmp = PyObject_Call(func, tuple, kwds); + Py_DECREF(tuple); + Py_DECREF(func); + + if (tmp == NULL) + return -1; + + Py_DECREF(tmp); + return 0; +} + /* recurse_down_subclasses() and update_subclasses() are mutually recursive functions to call a callback for all subclasses, but refraining from recursing into subclasses that define 'name'. */ -- Repository URL: https://hg.python.org/cpython

1 0

cpython (merge 3.5 -> default): Merge from 3.5
by berker.peksag July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/520c0d391f00 changeset: 102490:520c0d391f00 parent: 102488:cd7520756215 parent: 102489:57066dbf3d94 user: Berker Peksag <berker.peksag(a)gmail.com> date: Sat Jul 30 03:48:12 2016 +0300 summary: Merge from 3.5 files: Doc/library/typing.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst --- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -86,7 +86,7 @@ ``UserId`` wherever an ``int`` might be expected, but will prevent you from accidentally creating a ``UserId`` in an invalid way:: - # `output` is of type `int`, not `UserId` + # 'output' is of type 'int', not 'UserId' output = UserId(23413) + UserId(54341) Note that these checks are enforced only by the static type checker. At runtime -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.5): Silence another "default role used" warning in typing.rst
by berker.peksag July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/57066dbf3d94 changeset: 102489:57066dbf3d94 branch: 3.5 parent: 102486:4ecea1ea11bf user: Berker Peksag <berker.peksag(a)gmail.com> date: Sat Jul 30 03:47:52 2016 +0300 summary: Silence another "default role used" warning in typing.rst This should make ware-docs green again. files: Doc/library/typing.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst --- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -86,7 +86,7 @@ ``UserId`` wherever an ``int`` might be expected, but will prevent you from accidentally creating a ``UserId`` in an invalid way:: - # `output` is of type `int`, not `UserId` + # 'output' is of type 'int', not 'UserId' output = UserId(23413) + UserId(54341) Note that these checks are enforced only by the static type checker. At runtime -- Repository URL: https://hg.python.org/cpython

1 0

cpython: Fix "default role used" warning in shlex.rst
by berker.peksag July 30, 2016

July 30, 2016

https://hg.python.org/cpython/rev/cd7520756215 changeset: 102488:cd7520756215 user: Berker Peksag <berker.peksag(a)gmail.com> date: Sat Jul 30 03:40:38 2016 +0300 summary: Fix "default role used" warning in shlex.rst files: Doc/library/shlex.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/library/shlex.rst b/Doc/library/shlex.rst --- a/Doc/library/shlex.rst +++ b/Doc/library/shlex.rst @@ -99,7 +99,7 @@ :ref:`improved-shell-compatibility` for more information. .. versionchanged:: 3.6 - The `punctuation_chars` parameter was added. + The *punctuation_chars* parameter was added. .. seealso:: -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.5): Expand documentation about type aliases and NewType in the typing module.
by guido.van.rossum July 29, 2016

July 29, 2016

https://hg.python.org/cpython/rev/fd0dce6d33e7 changeset: 102484:fd0dce6d33e7 branch: 3.5 parent: 102480:8ba0000c90be user: Guido van Rossum <guido(a)python.org> date: Fri Jul 29 15:38:14 2016 -0700 summary: Expand documentation about type aliases and NewType in the typing module. By Michael Lee. files: Doc/library/typing.rst | 97 +++++++++++++++++++++++++++++- 1 files changed, 96 insertions(+), 1 deletions(-) diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst --- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -29,10 +29,105 @@ Type aliases ------------ -A type alias is defined by assigning the type to the alias:: +A type alias is defined by assigning the type to the alias. In this example, +``Vector`` and ``List[float]`` will be treated as interchangeable synonyms:: + from typing import List Vector = List[float] + def scale(scalar: float, vector: Vector) -> Vector: + return [scalar * num for num in vector] + + # typechecks; a list of floats qualifies as a Vector. + new_vector = scale(2.0, [1.0, -4.2, 5.4]) + +Type aliases are useful for simplifying complex type signatures. For example:: + + from typing import Dict, Tuple, List + + ConnectionOptions = Dict[str, str] + Address = Tuple[str, int] + Server = Tuple[Address, ConnectionOptions] + + def broadcast_message(message: str, servers: List[Server]) -> None: + ... + + # The static type checker will treat the previous type signature as + # being exactly equivalent to this one. + def broadcast_message( + message: str, + servers: List[Tuple[Tuple[str, int], Dict[str, str]]]) -> None: + ... + +NewType +------- + +Use the ``NewType`` helper function to create distinct types:: + + from typing import NewType + + UserId = NewType('UserId', int) + some_id = UserId(524313) + +The static type checker will treat the new type as if it were a subclass +of the original type. This is useful in helping catch logical errors:: + + def get_user_name(user_id: UserId) -> str: + ... + + # typechecks + user_a = get_user_name(UserId(42351)) + + # does not typecheck; an int is not a UserId + user_b = get_user_name(-1) + +You may still perform all ``int`` operations on a variable of type ``UserId``, +but the result will always be of type ``int``. This lets you pass in a +``UserId`` wherever an ``int`` might be expected, but will prevent you from +accidentally creating a ``UserId`` in an invalid way:: + + # `output` is of type `int`, not `UserId` + output = UserId(23413) + UserId(54341) + +Note that these checks are enforced only by the static type checker. At runtime +the statement ``Derived = NewType('Derived', Base)`` will make ``Derived`` a +function that immediately returns whatever parameter you pass it. That means +the expression ``Derived(some_value)`` does not create a new class or introduce +any overhead beyond that of a regular function call. + +More precisely, the expression ``some_value is Derived(some_value)`` is always +true at runtime. + +This also means that it is not possible to create a subtype of ``Derived`` +since it is an identity function at runtime, not an actual type. Similarly, it +is not possible to create another ``NewType`` based on a ``Derived`` type:: + + from typing import NewType + + UserId = NewType('UserId', int) + + # Fails at runtime and does not typecheck + class AdminUserId(UserId): pass + + # Also does not typecheck + ProUserId = NewType('ProUserId', UserId) + +See :pep:`484` for more details. + +.. note:: + + Recall that the use of a type alias declares two types to be *equivalent* to + one another. Doing ``Alias = Original`` will make the static type checker + treat ``Alias`` as being *exactly equivalent* to ``Original`` in all cases. + This is useful when you want to simplify complex type signatures. + + In contrast, ``NewType`` declares one type to be a *subtype* of another. + Doing ``Derived = NewType('Derived', Original)`` will make the static type + checker treat ``Derived`` as a *subclass* of ``Original``, which means a + value of type ``Original`` cannot be used in places where a value of type + ``Derived`` is expected. This is useful when you want to prevent logic + errors with minimal runtime cost. + Callable -------- -- Repository URL: https://hg.python.org/cpython

1 0

cpython (merge 3.5 -> default): Fix whitespace.
by guido.van.rossum July 29, 2016

July 29, 2016

https://hg.python.org/cpython/rev/5b624984e77a changeset: 102487:5b624984e77a parent: 102485:15a35a8da24b parent: 102486:4ecea1ea11bf user: Guido van Rossum <guido(a)dropbox.com> date: Fri Jul 29 15:41:35 2016 -0700 summary: Fix whitespace. files: Doc/library/typing.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst --- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -68,7 +68,7 @@ UserId = NewType('UserId', int) some_id = UserId(524313) - + The static type checker will treat the new type as if it were a subclass of the original type. This is useful in helping catch logical errors:: -- Repository URL: https://hg.python.org/cpython

1 0