Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

[Enum] Remove automatic docstring generation (GH-94188)

This commit is contained in:
Sam Ezeh 2022-06-23 21:35:37 +01:00 committed by GitHub
parent 9a95fa9267
commit 28a2ccfff2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 4 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
Lib/enum.py
View File

@ -536,111 +536,6 @@ class EnumType(type):
# update classdict with any changes made by __init_subclass__
classdict.update(enum_class.__dict__)
#
# create a default docstring if one has not been provided
if enum_class.__doc__ is None:
if not member_names or not list(enum_class):
enum_class.__doc__ = classdict['__doc__'] = _dedent("""\
Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum):
... RED = 1
... BLUE = 2
... GREEN = 3
Access them by:
- attribute access::
>>> Color.RED
<Color.RED: 1>
- value lookup:
>>> Color(1)
<Color.RED: 1>
- name lookup:
>>> Color['RED']
<Color.RED: 1>
Enumerations can be iterated over, and know how many members they have:
>>> len(Color)
3
>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]
Methods can be added to enumerations, and members can have their own
attributes -- see the documentation for details.
""")
else:
member = list(enum_class)[0]
enum_length = len(enum_class)
cls_name = enum_class.__name__
if enum_length == 1:
list_line = 'list(%s)' % cls_name
list_repr = '[<%s.%s: %r>]' % (cls_name, member.name, member.value)
elif enum_length == 2:
member2 = list(enum_class)[1]
list_line = 'list(%s)' % cls_name
list_repr = '[<%s.%s: %r>, <%s.%s: %r>]' % (
cls_name, member.name, member.value,
cls_name, member2.name, member2.value,
)
else:
member2 = list(enum_class)[1]
member3 = list(enum_class)[2]
list_line = 'list(%s)%s' % (cls_name, ('','[:3]')[enum_length > 3])
list_repr = '[<%s.%s: %r>, <%s.%s: %r>, <%s.%s: %r>]' % (
cls_name, member.name, member.value,
cls_name, member2.name, member2.value,
cls_name, member3.name, member3.value,
)
enum_class.__doc__ = classdict['__doc__'] = _dedent("""\
A collection of name/value pairs.
Access them by:
- attribute access::
>>> %s.%s
<%s.%s: %r>
- value lookup:
>>> %s(%r)
<%s.%s: %r>
- name lookup:
>>> %s[%r]
<%s.%s: %r>
Enumerations can be iterated over, and know how many members they have:
>>> len(%s)
%r
>>> %s
%s
Methods can be added to enumerations, and members can have their own
attributes -- see the documentation for details.
"""
% (cls_name, member.name,
cls_name, member.name, member.value,
cls_name, member.value,
cls_name, member.name, member.value,
cls_name, member.name,
cls_name, member.name, member.value,
cls_name, enum_length,
list_line, list_repr,
))
#
# double check that repr and friends are not the mixin's or various
# things break (such as pickle)
# however, if the method is defined in the Enum itself, don't replace

166
Lib/test/test_enum.py
View File

@ -4054,36 +4054,6 @@ Help on class Color in module %s:
class Color(enum.Enum)
| Color(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)
|\x20\x20
| A collection of name/value pairs.
|\x20\x20
| Access them by:
|\x20\x20
| - attribute access::
|\x20\x20
| >>> Color.CYAN
| <Color.CYAN: 1>
|\x20\x20
| - value lookup:
|\x20\x20
| >>> Color(1)
| <Color.CYAN: 1>
|\x20\x20
| - name lookup:
|\x20\x20
| >>> Color['CYAN']
| <Color.CYAN: 1>
|\x20\x20
| Enumerations can be iterated over, and know how many members they have:
|\x20\x20
| >>> len(Color)
| 3
|\x20\x20
| >>> list(Color)
| [<Color.CYAN: 1>, <Color.MAGENTA: 2>, <Color.YELLOW: 3>]
|\x20\x20
| Methods can be added to enumerations, and members can have their own
| attributes -- see the documentation for details.
|\x20\x20
| Method resolution order:
| Color
| enum.Enum
@ -4329,77 +4299,13 @@ class MiscTestCase(unittest.TestCase):
def test_doc_1(self):
class Single(Enum):
ONE = 1
self.assertEqual(
Single.__doc__,
dedent("""\
A collection of name/value pairs.
Access them by:
- attribute access::
>>> Single.ONE
<Single.ONE: 1>
- value lookup:
>>> Single(1)
<Single.ONE: 1>
- name lookup:
>>> Single['ONE']
<Single.ONE: 1>
Enumerations can be iterated over, and know how many members they have:
>>> len(Single)
1
>>> list(Single)
[<Single.ONE: 1>]
Methods can be added to enumerations, and members can have their own
attributes -- see the documentation for details.
"""))
self.assertEqual(Single.__doc__, None)
def test_doc_2(self):
class Double(Enum):
ONE = 1
TWO = 2
self.assertEqual(
Double.__doc__,
dedent("""\
A collection of name/value pairs.
Access them by:
- attribute access::
>>> Double.ONE
<Double.ONE: 1>
- value lookup:
>>> Double(1)
<Double.ONE: 1>
- name lookup:
>>> Double['ONE']
<Double.ONE: 1>
Enumerations can be iterated over, and know how many members they have:
>>> len(Double)
2
>>> list(Double)
[<Double.ONE: 1>, <Double.TWO: 2>]
Methods can be added to enumerations, and members can have their own
attributes -- see the documentation for details.
"""))
self.assertEqual(Double.__doc__, None)
def test_doc_1(self):
@ -4407,39 +4313,7 @@ class MiscTestCase(unittest.TestCase):
ONE = 1
TWO = 2
THREE = 3
self.assertEqual(
Triple.__doc__,
dedent("""\
A collection of name/value pairs.
Access them by:
- attribute access::
>>> Triple.ONE
<Triple.ONE: 1>
- value lookup:
>>> Triple(1)
<Triple.ONE: 1>
- name lookup:
>>> Triple['ONE']
<Triple.ONE: 1>
Enumerations can be iterated over, and know how many members they have:
>>> len(Triple)
3
>>> list(Triple)
[<Triple.ONE: 1>, <Triple.TWO: 2>, <Triple.THREE: 3>]
Methods can be added to enumerations, and members can have their own
attributes -- see the documentation for details.
"""))
self.assertEqual(Triple.__doc__, None)
def test_doc_1(self):
class Quadruple(Enum):
@ -4447,39 +4321,7 @@ class MiscTestCase(unittest.TestCase):
TWO = 2
THREE = 3
FOUR = 4
self.assertEqual(
Quadruple.__doc__,
dedent("""\
A collection of name/value pairs.
Access them by:
- attribute access::
>>> Quadruple.ONE
<Quadruple.ONE: 1>
- value lookup:
>>> Quadruple(1)
<Quadruple.ONE: 1>
- name lookup:
>>> Quadruple['ONE']
<Quadruple.ONE: 1>
Enumerations can be iterated over, and know how many members they have:
>>> len(Quadruple)
4
>>> list(Quadruple)[:3]
[<Quadruple.ONE: 1>, <Quadruple.TWO: 2>, <Quadruple.THREE: 3>]
Methods can be added to enumerations, and members can have their own
attributes -- see the documentation for details.
"""))
self.assertEqual(Quadruple.__doc__, None)
# These are unordered here on purpose to ensure that declaration order