Mailman 3 November 2018 - Python-Dev

PEP 574 -- Pickle protocol 5 with out-of-band data
by Antoine Pitrou Nov. 5, 2018

Nov. 5, 2018

Hi, I'd like to submit this PEP for discussion. It is quite specialized and the main target audience of the proposed changes is users and authors of applications/libraries transferring large amounts of data (read: the scientific computing & data science ecosystems). https://www.python.org/dev/peps/pep-0574/ The PEP text is also inlined below. Regards Antoine. PEP: 574 Title: Pickle protocol 5 with out-of-band data Version: $Revision$ Last-Modified: $Date$ Author: Antoine Pitrou <solipsis(a)pitrou.net> Status: Draft Type: Standards Track Content-Type: text/x-rst Created: 23-Mar-2018 Post-History: Resolution: Abstract ======== This PEP proposes to standardize a new pickle protocol version, and accompanying APIs to take full advantage of it: 1. A new pickle protocol version (5) to cover the extra metadata needed for out-of-band data buffers. 2. A new ``PickleBuffer`` type for ``__reduce_ex__`` implementations to return out-of-band data buffers. 3. A new ``buffer_callback`` parameter when pickling, to handle out-of-band data buffers. 4. A new ``buffers`` parameter when unpickling to provide out-of-band data buffers. The PEP guarantees unchanged behaviour for anyone not using the new APIs. Rationale ========= The pickle protocol was originally designed in 1995 for on-disk persistency of arbitrary Python objects. The performance of a 1995-era storage medium probably made it irrelevant to focus on performance metrics such as use of RAM bandwidth when copying temporary data before writing it to disk. Nowadays the pickle protocol sees a growing use in applications where most of the data isn't ever persisted to disk (or, when it is, it uses a portable format instead of Python-specific). Instead, pickle is being used to transmit data and commands from one process to another, either on the same machine or on multiple machines. Those applications will sometimes deal with very large data (such as Numpy arrays or Pandas dataframes) that need to be transferred around. For those applications, pickle is currently wasteful as it imposes spurious memory copies of the data being serialized. As a matter of fact, the standard ``multiprocessing`` module uses pickle for serialization, and therefore also suffers from this problem when sending large data to another process. Third-party Python libraries, such as Dask [#dask]_, PyArrow [#pyarrow]_ and IPyParallel [#ipyparallel]_, have started implementing alternative serialization schemes with the explicit goal of avoiding copies on large data. Implementing a new serialization scheme is difficult and often leads to reduced generality (since many Python objects support pickle but not the new serialization scheme). Falling back on pickle for unsupported types is an option, but then you get back the spurious memory copies you wanted to avoid in the first place. For example, ``dask`` is able to avoid memory copies for Numpy arrays and built-in containers thereof (such as lists or dicts containing Numpy arrays), but if a large Numpy array is an attribute of a user-defined object, ``dask`` will serialize the user-defined object as a pickle stream, leading to memory copies. The common theme of these third-party serialization efforts is to generate a stream of object metadata (which contains pickle-like information about the objects being serialized) and a separate stream of zero-copy buffer objects for the payloads of large objects. Note that, in this scheme, small objects such as ints, etc. can be dumped together with the metadata stream. Refinements can include opportunistic compression of large data depending on its type and layout, like ``dask`` does. This PEP aims to make ``pickle`` usable in a way where large data is handled as a separate stream of zero-copy buffers, letting the application handle those buffers optimally. Example ======= To keep the example simple and avoid requiring knowledge of third-party libraries, we will focus here on a bytearray object (but the issue is conceptually the same with more sophisticated objects such as Numpy arrays). Like most objects, the bytearray object isn't immediately understood by the pickle module and must therefore specify its decomposition scheme. Here is how a bytearray object currently decomposes for pickling:: >>> b.__reduce_ex__(4) (<class 'bytearray'>, (b'abc',), None) This is because the ``bytearray.__reduce_ex__`` implementation reads morally as follows:: class bytearray: def __reduce_ex__(self, protocol): if protocol == 4: return type(self), bytes(self), None # Legacy code for earlier protocols omitted In turn it produces the following pickle code:: >>> pickletools.dis(pickletools.optimize(pickle.dumps(b, protocol=4))) 0: \x80 PROTO 4 2: \x95 FRAME 30 11: \x8c SHORT_BINUNICODE 'builtins' 21: \x8c SHORT_BINUNICODE 'bytearray' 32: \x93 STACK_GLOBAL 33: C SHORT_BINBYTES b'abc' 38: \x85 TUPLE1 39: R REDUCE 40: . STOP (the call to ``pickletools.optimize`` above is only meant to make the pickle stream more readable by removing the MEMOIZE opcodes) We can notice several things about the bytearray's payload (the sequence of bytes ``b'abc'``): * ``bytearray.__reduce_ex__`` produces a first copy by instantiating a new bytes object from the bytearray's data. * ``pickle.dumps`` produces a second copy when inserting the contents of that bytes object into the pickle stream, after the SHORT_BINBYTES opcode. * Furthermore, when deserializing the pickle stream, a temporary bytes object is created when the SHORT_BINBYTES opcode is encountered (inducing a data copy). What we really want is something like the following: * ``bytearray.__reduce_ex__`` produces a *view* of the bytearray's data. * ``pickle.dumps`` doesn't try to copy that data into the pickle stream but instead passes the buffer view to its caller (which can decide on the most efficient handling of that buffer). * When deserializing, ``pickle.loads`` takes the pickle stream and the buffer view separately, and passes the buffer view directly to the bytearray constructor. We see that several conditions are required for the above to work: * ``__reduce__`` or ``__reduce_ex__`` must be able to return *something* that indicates a serializable no-copy buffer view. * The pickle protocol must be able to represent references to such buffer views, instructing the unpickler that it may have to get the actual buffer out of band. * The ``pickle.Pickler`` API must provide its caller with a way to receive such buffer views while serializing. * The ``pickle.Unpickler`` API must similarly allow its caller to provide the buffer views required for deserialization. * For compatibility, the pickle protocol must also be able to contain direct serializations of such buffer views, such that current uses of the ``pickle`` API don't have to be modified if they are not concerned with memory copies. Producer API ============ We are introducing a new type ``pickle.PickleBuffer`` which can be instantiated from any buffer-supporting object, and is specifically meant to be returned from ``__reduce__`` implementations:: class bytearray: def __reduce_ex__(self, protocol): if protocol == 5: return type(self), PickleBuffer(self), None # Legacy code for earlier protocols omitted ``PickleBuffer`` is a simple wrapper that doesn't have all the memoryview semantics and functionality, but is specifically recognized by the ``pickle`` module if protocol 5 or higher is enabled. It is an error to try to serialize a ``PickleBuffer`` with pickle protocol version 4 or earlier. Only the raw *data* of the ``PickleBuffer`` will be considered by the ``pickle`` module. Any type-specific *metadata* (such as shapes or datatype) must be returned separately by the type's ``__reduce__`` implementation, as is already the case. PickleBuffer objects -------------------- The ``PickleBuffer`` class supports a very simple Python API. Its constructor takes a single PEP 3118-compatible object [#pep-3118]_. ``PickleBuffer`` objects themselves support the buffer protocol, so consumers can call ``memoryview(...)`` on them to get additional information about the underlying buffer (such as the original type, shape, etc.). On the C side, a simple API will be provided to create and inspect PickleBuffer objects: ``PyObject *PyPickleBuffer_FromObject(PyObject *obj)`` Create a ``PickleBuffer`` object holding a view over the PEP 3118-compatible *obj*. ``PyPickleBuffer_Check(PyObject *obj)`` Return whether *obj* is a ``PickleBuffer`` instance. ``const Py_buffer *PyPickleBuffer_GetBuffer(PyObject *picklebuf)`` Return a pointer to the internal ``Py_buffer`` owned by the ``PickleBuffer`` instance. ``PickleBuffer`` can wrap any kind of buffer, including non-contiguous buffers. It's up to consumers to decide how best to handle different kinds of buffers (for example, some consumers may find it acceptable to make a contiguous copy of non-contiguous buffers). Consumer API ============ ``pickle.Pickler.__init__`` and ``pickle.dumps`` are augmented with an additional ``buffer_callback`` parameter:: class Pickler: def __init__(self, file, protocol=None, ..., buffer_callback=None): """ If *buffer_callback* is not None, then it is called with a list of out-of-band buffer views when deemed necessary (this could be once every buffer, or only after a certain size is reached, or once at the end, depending on implementation details). The callback should arrange to store or transmit those buffers without changing their order. If *buffer_callback* is None (the default), buffer views are serialized into *file* as part of the pickle stream. It is an error if *buffer_callback* is not None and *protocol* is None or smaller than 5. """ def pickle.dumps(obj, protocol=None, *, ..., buffer_callback=None): """ See above for *buffer_callback*. """ ``pickle.Unpickler.__init__`` and ``pickle.loads`` are augmented with an additional ``buffers`` parameter:: class Unpickler: def __init__(file, *, ..., buffers=None): """ If *buffers* is not None, it should be an iterable of buffer-enabled objects that is consumed each time the pickle stream references an out-of-band buffer view. Such buffers have been given in order to the *buffer_callback* of a Pickler object. If *buffers* is None (the default), then the buffers are taken from the pickle stream, assuming they are serialized there. It is an error for *buffers* to be None if the pickle stream was produced with a non-None *buffer_callback*. """ def pickle.loads(data, *, ..., buffers=None): """ See above for *buffers*. """ Protocol changes ================ Three new opcodes are introduced: * ``BYTEARRAY`` creates a bytearray from the data following it in the pickle stream and pushes it on the stack (just like ``BINBYTES8`` does for bytes objects); * ``NEXT_BUFFER`` fetches a buffer from the ``buffers`` iterable and pushes it on the stack. * ``READONLY_BUFFER`` makes a readonly view of the top of the stack. When pickling encounters a ``PickleBuffer``, there can be four cases: * If a ``buffer_callback`` is given and the ``PickleBuffer`` is writable, the ``PickleBuffer`` is given to the callback and a ``NEXT_BUFFER`` opcode is appended to the pickle stream. * If a ``buffer_callback`` is given and the ``PickleBuffer`` is readonly, the ``PickleBuffer`` is given to the callback and a ``NEXT_BUFFER`` opcode is appended to the pickle stream, followed by a ``READONLY_BUFFER`` opcode. * If no ``buffer_callback`` is given and the ``PickleBuffer`` is writable, it is serialized into the pickle stream as if it were a ``bytearray`` object. * If no ``buffer_callback`` is given and the ``PickleBuffer`` is readonly, it is serialized into the pickle stream as if it were a ``bytes`` object. The distinction between readonly and writable buffers is explained below (see "Mutability"). Caveats ======= Mutability ---------- PEP 3118 buffers [#pep-3118]_ can be readonly or writable. Some objects, such as Numpy arrays, need to be backed by a mutable buffer for full operation. Pickle consumers that use the ``buffer_callback`` and ``buffers`` arguments will have to be careful to recreate mutable buffers. When doing I/O, this implies using buffer-passing API variants such as ``readinto`` (which are also often preferrable for performance). Data sharing ------------ If you pickle and then unpickle an object in the same process, passing out-of-band buffer views, then the unpickled object may be backed by the same buffer as the original pickled object. For example, it might be reasonable to implement reduction of a Numpy array as follows (crucial metadata such as shapes is omitted for simplicity):: class ndarray: def __reduce_ex__(self, protocol): if protocol == 5: return numpy.frombuffer, (PickleBuffer(self), self.dtype) # Legacy code for earlier protocols omitted Then simply passing the PickleBuffer around from ``dumps`` to ``loads`` will produce a new Numpy array sharing the same underlying memory as the original Numpy object (and, incidentally, keeping it alive):: >>> import numpy as np >>> a = np.zeros(10) >>> a[0] 0.0 >>> buffers = [] >>> data = pickle.dumps(a, protocol=5, buffer_callback=buffers.extend) >>> b = pickle.loads(data, buffers=buffers) >>> b[0] = 42 >>> a[0] 42.0 This won't happen with the traditional ``pickle`` API (i.e. without passing ``buffers`` and ``buffer_callback`` parameters), because then the buffer view is serialized inside the pickle stream with a copy. Alternatives ============ The ``pickle`` persistence interface is a way of storing references to designated objects in the pickle stream while handling their actual serialization out of band. For example, one might consider the following for zero-copy serialization of bytearrays:: class MyPickle(pickle.Pickler): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.buffers = [] def persistent_id(self, obj): if type(obj) is not bytearray: return None else: index = len(self.buffers) self.buffers.append(obj) return ('bytearray', index) class MyUnpickle(pickle.Unpickler): def __init__(self, *args, buffers, **kwargs): super().__init__(*args, **kwargs) self.buffers = buffers def persistent_load(self, pid): type_tag, index = pid if type_tag == 'bytearray': return self.buffers[index] else: assert 0 # unexpected type This mechanism has two drawbacks: * Each ``pickle`` consumer must reimplement ``Pickler`` and ``Unpickler`` subclasses, with custom code for each type of interest. Essentially, N pickle consumers end up each implementing custom code for M producers. This is difficult (especially for sophisticated types such as Numpy arrays) and poorly scalable. * Each object encountered by the pickle module (even simple built-in objects such as ints and strings) triggers a call to the user's ``persistent_id()`` method, leading to a possible performance drop compared to nominal. Open questions ============== Should ``buffer_callback`` take a single buffers or a sequence of buffers? * Taking a single buffer would allow returning a boolean indicating whether the given buffer is serialized in-band or out-of-band. * Taking a sequence of buffers is potentially more efficient by reducing function call overhead. Related work ============ Dask.distributed implements a custom zero-copy serialization with fallback to pickle [#dask-serialization]_. PyArrow implements zero-copy component-based serialization for a few selected types [#pyarrow-serialization]_. PEP 554 proposes hosting multiple interpreters in a single process, with provisions for transferring buffers between interpreters as a communication scheme [#pep-554]_. Acknowledgements ================ Thanks to the following people for early feedback: Nick Coghlan, Olivier Grisel, Stefan Krah, MinRK, Matt Rocklin, Eric Snow. References ========== .. [#dask] Dask.distributed -- A lightweight library for distributed computing in Python https://distributed.readthedocs.io/ .. [#dask-serialization] Dask.distributed custom serialization https://distributed.readthedocs.io/en/latest/serialization.html .. [#ipyparallel] IPyParallel -- Using IPython for parallel computing https://ipyparallel.readthedocs.io/ .. [#pyarrow] PyArrow -- A cross-language development platform for in-memory data https://arrow.apache.org/docs/python/ .. [#pyarrow-serialization] PyArrow IPC and component-based serialization https://arrow.apache.org/docs/python/ipc.html#component-based-serialization .. [#pep-3118] PEP 3118 -- Revising the buffer protocol https://www.python.org/dev/peps/pep-3118/ .. [#pep-554] PEP 554 -- Multiple Interpreters in the Stdlib https://www.python.org/dev/peps/pep-0554/ Copyright ========= This document has been placed into the public domain.

11 18

PEP 543-conform TLS library
by Mathias Laurin Nov. 4, 2018

Nov. 4, 2018

Hello Python Dev, I posted the following to python-ideas but here may be a more suitable place. I apologize if cross posting bothers anyone. I have implemented an (I believe) PEP 543-conform TLS library and released TLS support in the latest version yesterday: https://github.com/Synss/python-mbedtls/tree/0.13.0 https://pypi.org/project/python-mbedtls/0.13.0/ As far as I know, I am the first one to follow PEP 543. So one point is that the API works. However, I have a couple of questions regarding the PEP: - I do not know what to do in `TLSWrappedBuffer.do_handshake()`. The full TLS handshake requires writing to the server, reading back, etc., (ClientHello, ServerHello, KeyExchange, etc.), which cannot be accomplished in a single buffer. For now, I am doing the handshake in `TLSWrappedSocket.do_handshake()`: I set the BIO to using the socket directly, then perform the handshake on the socket thus entirely bypassing the TLSWrappedBuffer. Once this is done, I swap the BIO to using the buffer and go on encrypting and decrypting from the buffer. That is, the encrypted communication is buffered. - The PEP sometimes mentions an "input buffer" and an "output buffer", and some other times just "the buffer". I believe that both implementations are possible. That is, with two different buffers for input and output, or a single one. I have implemented it with a single circular buffer (that is a stream after all). What the PEP is expecting is nonetheless not clear to me. So, can anybody clarify these two points from the PEP? Or should I just address Cory Benfield (who does not seem very active anymore lately) and Christian Heimes directly? Cheers, Mathias

3 2

Summary of Python tracker Issues
by Python tracker Nov. 2, 2018

Nov. 2, 2018

ACTIVITY SUMMARY (2018-10-26 - 2018-11-02) Python tracker at https://bugs.python.org/ To view or respond to any of the issues listed below, click on the issue. Do NOT respond to this message. Issues counts and deltas: open 6828 ( +5) closed 40071 (+66) total 46899 (+71) Open issues with patches: 2720 Issues opened (41) ================== #35034: Add closing and iteration to threading.Queue https://bugs.python.org/issue35034 reopened by hemflit #35078: Allow customization of CSS class name of a month in calendar m https://bugs.python.org/issue35078 opened by thatiparthy #35081: Move internal headers to Include/internal/ https://bugs.python.org/issue35081 opened by vstinner #35082: Mock.__dir__ lists deleted attributes https://bugs.python.org/issue35082 opened by mariocj89 #35083: Fix documentation for __instancecheck__ https://bugs.python.org/issue35083 opened by joydiamond #35084: binascii.Error: Incorrect padding https://bugs.python.org/issue35084 opened by Tester #35091: Objects/listobject.c: gallop functions rely on signed integer https://bugs.python.org/issue35091 opened by izbyshev #35097: IDLE add doc subsection for editor windows https://bugs.python.org/issue35097 opened by terry.reedy #35099: Improve the IDLE - console differences doc https://bugs.python.org/issue35099 opened by terry.reedy #35100: urllib.parse.unquote_to_bytes: needs "escape plus" option https://bugs.python.org/issue35100 opened by Henry Zhu #35101: inspect.findsource breaks on class frame objects https://bugs.python.org/issue35101 opened by orlnub123 #35103: format_exception() doesn't work with PyErr_Fetch https://bugs.python.org/issue35103 opened by tomasheran #35104: IDLE: On macOS, Command-M minimizes & opens "Open Module..." https://bugs.python.org/issue35104 opened by taleinat #35105: Document that CPython accepts "invalid" identifiers https://bugs.python.org/issue35105 opened by vstinner #35107: untokenize() fails on tokenize output when a newline is missin https://bugs.python.org/issue35107 opened by gregory.p.smith #35108: inspect.getmembers passes exceptions from object's properties https://bugs.python.org/issue35108 opened by rominf #35109: Doctest in CI uses python binary built from master causing Dep https://bugs.python.org/issue35109 opened by xtreak #35111: Make Custom Object Classes JSON Serializable https://bugs.python.org/issue35111 opened by andrewchap #35113: inspect.getsource returns incorrect source for classes when cl https://bugs.python.org/issue35113 opened by xtreak #35114: ssl.RAND_status docs describe it as returning True/False; actu https://bugs.python.org/issue35114 opened by josh.r #35118: Add peek() or first() method in queue https://bugs.python.org/issue35118 opened by Windson Yang #35120: SSH tunnel support to ftp lib https://bugs.python.org/issue35120 opened by msharma #35121: Cookie domain check returns incorrect results https://bugs.python.org/issue35121 opened by 西田雄治 #35122: Process not exiting on unhandled exception when using multipro https://bugs.python.org/issue35122 opened by akhi singhania #35123: Add style guide for sentinel usage https://bugs.python.org/issue35123 opened by madman bob #35124: Add style guide for unit tests https://bugs.python.org/issue35124 opened by madman bob #35125: asyncio shield: remove inner callback on outer cancellation https://bugs.python.org/issue35125 opened by mainro #35126: Mistake in FAQ about converting number to string. https://bugs.python.org/issue35126 opened by grottrumsel #35127: pyurandom() fails if user does not have an entropy device https://bugs.python.org/issue35127 opened by pehdrah #35131: Cannot access to customized paths within .pth file https://bugs.python.org/issue35131 opened by Valentin Zhao #35132: python-gdb error: Python Exception <class 'RuntimeError'> Type https://bugs.python.org/issue35132 opened by Dylan Cali #35133: Bugs in concatenating string literals on different lines https://bugs.python.org/issue35133 opened by serhiy.storchaka #35134: Move !Py_LIMITED_API to Include/pycapi/ https://bugs.python.org/issue35134 opened by vstinner #35136: test_ssl fails in AMD64 FreeBSD CURRENT Shared 3.6 buildbot https://bugs.python.org/issue35136 opened by pablogsal #35138: timeit documentation should have example with function argumen https://bugs.python.org/issue35138 opened by davidak #35140: encoding problem: coding:gbk cause syntaxError https://bugs.python.org/issue35140 opened by anmikf #35143: Annotations future requires unparse, but not accessible from P https://bugs.python.org/issue35143 opened by kayhayen #35144: TemporaryDirectory can't be cleaned up if there are unsearchab https://bugs.python.org/issue35144 opened by lilydjwg #35145: sqlite3: "select *" should autoconvert datetime fields https://bugs.python.org/issue35145 opened by jondo #35147: _Py_NO_RETURN is always empty on GCC https://bugs.python.org/issue35147 opened by izbyshev #35148: cannot activate a venv environment on a Swiss German windows https://bugs.python.org/issue35148 opened by Martin Bijl-Schwab Most recent 15 issues with no replies (15) ========================================== #35148: cannot activate a venv environment on a Swiss German windows https://bugs.python.org/issue35148 #35143: Annotations future requires unparse, but not accessible from P https://bugs.python.org/issue35143 #35132: python-gdb error: Python Exception <class 'RuntimeError'> Type https://bugs.python.org/issue35132 #35131: Cannot access to customized paths within .pth file https://bugs.python.org/issue35131 #35127: pyurandom() fails if user does not have an entropy device https://bugs.python.org/issue35127 #35125: asyncio shield: remove inner callback on outer cancellation https://bugs.python.org/issue35125 #35114: ssl.RAND_status docs describe it as returning True/False; actu https://bugs.python.org/issue35114 #35103: format_exception() doesn't work with PyErr_Fetch https://bugs.python.org/issue35103 #35100: urllib.parse.unquote_to_bytes: needs "escape plus" option https://bugs.python.org/issue35100 #35082: Mock.__dir__ lists deleted attributes https://bugs.python.org/issue35082 #35063: Checking for abstractmethod implementation fails to consider M https://bugs.python.org/issue35063 #35061: Specify libffi.so soname for ctypes https://bugs.python.org/issue35061 #35048: Can't reassign __class__ despite the assigned class having ide https://bugs.python.org/issue35048 #35018: Sax parser provides no user access to lexical handlers https://bugs.python.org/issue35018 #35009: argparse throws UnicodeEncodeError for printing help with unic https://bugs.python.org/issue35009 Most recent 15 issues waiting for review (15) ============================================= #35147: _Py_NO_RETURN is always empty on GCC https://bugs.python.org/issue35147 #35138: timeit documentation should have example with function argumen https://bugs.python.org/issue35138 #35134: Move !Py_LIMITED_API to Include/pycapi/ https://bugs.python.org/issue35134 #35133: Bugs in concatenating string literals on different lines https://bugs.python.org/issue35133 #35125: asyncio shield: remove inner callback on outer cancellation https://bugs.python.org/issue35125 #35121: Cookie domain check returns incorrect results https://bugs.python.org/issue35121 #35118: Add peek() or first() method in queue https://bugs.python.org/issue35118 #35101: inspect.findsource breaks on class frame objects https://bugs.python.org/issue35101 #35097: IDLE add doc subsection for editor windows https://bugs.python.org/issue35097 #35091: Objects/listobject.c: gallop functions rely on signed integer https://bugs.python.org/issue35091 #35082: Mock.__dir__ lists deleted attributes https://bugs.python.org/issue35082 #35081: Move internal headers to Include/internal/ https://bugs.python.org/issue35081 #35078: Allow customization of CSS class name of a month in calendar m https://bugs.python.org/issue35078 #35077: Make TypeError message less ambiguous https://bugs.python.org/issue35077 #35065: Reading received data from a closed TCP stream using `StreamRe https://bugs.python.org/issue35065 Top 10 most discussed issues (10) ================================= #35081: Move internal headers to Include/internal/ https://bugs.python.org/issue35081 19 msgs #35070: test_posix fails on macOS 10.14 Mojave https://bugs.python.org/issue35070 14 msgs #34160: ElementTree not preserving attribute order https://bugs.python.org/issue34160 13 msgs #35059: Convert Py_INCREF() and PyObject_INIT() to inlined functions https://bugs.python.org/issue35059 13 msgs #35084: binascii.Error: Incorrect padding https://bugs.python.org/issue35084 12 msgs #1154351: add get_current_dir_name() to os module https://bugs.python.org/issue1154351 10 msgs #35140: encoding problem: coding:gbk cause syntaxError https://bugs.python.org/issue35140 8 msgs #35077: Make TypeError message less ambiguous https://bugs.python.org/issue35077 7 msgs #19376: document that strptime() does not support the Feb 29 if the fo https://bugs.python.org/issue19376 6 msgs #35052: Coverity scan: copy/paste error in Lib/xml/dom/minidom.py https://bugs.python.org/issue35052 6 msgs Issues closed (64) ================== #9263: Try to print repr() when an C-level assert fails (in the garba https://bugs.python.org/issue9263 closed by vstinner #27200: make doctest in CPython has failures https://bugs.python.org/issue27200 closed by mdk #27741: datetime.datetime.strptime functionality description incorrect https://bugs.python.org/issue27741 closed by vstinner #28015: configure --with-lto builds fail when CC=clang on Linux, requi https://bugs.python.org/issue28015 closed by vstinner #29174: 'NoneType' object is not callable in subprocess.py https://bugs.python.org/issue29174 closed by vstinner #31544: gettext.Catalog title is not flagged as a class https://bugs.python.org/issue31544 closed by serhiy.storchaka #31680: Expose curses library name and version on Python level https://bugs.python.org/issue31680 closed by serhiy.storchaka #31880: subprocess process interaction with IDLEX GUI causes pygnuplot https://bugs.python.org/issue31880 closed by roger.serwy #32804: urllib.retrieve documentation doesn't mention context paramete https://bugs.python.org/issue32804 closed by xiang.zhang #33138: Improve standard error for uncopyable types https://bugs.python.org/issue33138 closed by serhiy.storchaka #33236: MagicMock().__iter__.return_value is different from MagicMock( https://bugs.python.org/issue33236 closed by michael.foord #33237: Improve AttributeError message for partially initialized modul https://bugs.python.org/issue33237 closed by serhiy.storchaka #33331: Clean modules in the reversed order https://bugs.python.org/issue33331 closed by serhiy.storchaka #33710: Deprecate gettext.lgettext() https://bugs.python.org/issue33710 closed by serhiy.storchaka #33826: enable discovery of class source code in IPython interactively https://bugs.python.org/issue33826 closed by t-vi #33940: datetime.strptime have no directive to convert date values wit https://bugs.python.org/issue33940 closed by belopolsky #34198: Additional encoding options to tkinter.filedialog https://bugs.python.org/issue34198 closed by narito #34576: [EASY doc] http.server, SimpleHTTPServer: warn users on securi https://bugs.python.org/issue34576 closed by orsenthil #34794: Memory leak in Tkinter https://bugs.python.org/issue34794 closed by serhiy.storchaka #34866: CGI DOS vulnerability via long post list https://bugs.python.org/issue34866 closed by vstinner #34876: Python3.8 changes how decorators are traced https://bugs.python.org/issue34876 closed by serhiy.storchaka #34945: regression with ./python -m test and pdb https://bugs.python.org/issue34945 closed by pablogsal #35007: Minor change to weakref docs https://bugs.python.org/issue35007 closed by mdk #35042: Use the role :pep: for the PEP \d+ https://bugs.python.org/issue35042 closed by mdk #35047: Better error messages in unittest.mock https://bugs.python.org/issue35047 closed by vstinner #35054: Add more index entries for symbols https://bugs.python.org/issue35054 closed by serhiy.storchaka #35062: io.IncrementalNewlineDecoder assign out-of-range value to bitw https://bugs.python.org/issue35062 closed by xiang.zhang #35064: COUNT_ALLOCS build export inc_count() and dec_count() function https://bugs.python.org/issue35064 closed by pablogsal #35067: Use vswhere instead of _distutils_findvs https://bugs.python.org/issue35067 closed by steve.dower #35068: [2.7] Possible crashes due to incorrect error handling in pyex https://bugs.python.org/issue35068 closed by serhiy.storchaka #35074: source install [3.7.1] on debian jessie https://bugs.python.org/issue35074 closed by xtreak #35075: Doc: pprint example uses dead URL https://bugs.python.org/issue35075 closed by inada.naoki #35076: FAIL: test_min_max_version (test.test_ssl.ContextTests) with l https://bugs.python.org/issue35076 closed by terry.reedy #35079: difflib.SequenceMatcher.get_matching_blocks omits common strin https://bugs.python.org/issue35079 closed by terry.reedy #35080: The tests for the `dis` module can be too rigid when changing https://bugs.python.org/issue35080 closed by Maxime Belanger #35085: FileNotFoundError: [Errno 2] No such file or directory: https://bugs.python.org/issue35085 closed by steven.daprano #35086: tkinter docs: errors in A Simple Hello World Program https://bugs.python.org/issue35086 closed by serhiy.storchaka #35087: IDLE: update idlelib help files for current doc build https://bugs.python.org/issue35087 closed by terry.reedy #35088: Update idlelib.help.copy_string docstring https://bugs.python.org/issue35088 closed by terry.reedy #35089: Remove typing.io and typing.re from documentation https://bugs.python.org/issue35089 closed by levkivskyi #35090: Potential division by zero and integer overflow in allocator w https://bugs.python.org/issue35090 closed by vstinner #35092: test_socket fails in MacOS High Sierra when running with -Werr https://bugs.python.org/issue35092 closed by ned.deily #35093: IDLE: document the help document viewer https://bugs.python.org/issue35093 closed by terry.reedy #35094: Improved algorithms for random.sample https://bugs.python.org/issue35094 closed by rhettinger #35095: Implement pathlib.Path.append_bytes and pathlib.Path.append_te https://bugs.python.org/issue35095 closed by pablogsal #35096: Change _PY_VERSION to derive from sys.version_info in sysconfi https://bugs.python.org/issue35096 closed by ned.deily #35098: Deleting __new__ does not restore previous behavior https://bugs.python.org/issue35098 closed by josh.r #35102: Struct pack() https://bugs.python.org/issue35102 closed by mark.dickinson #35106: Add documentation for `type.__subclasses__` to docs.python.org https://bugs.python.org/issue35106 closed by joydiamond #35110: Fix more spaces around hyphens and dashes https://bugs.python.org/issue35110 closed by serhiy.storchaka #35112: SpooledTemporaryFile and seekable() method https://bugs.python.org/issue35112 closed by nubirstein #35115: UUID objects can't be casted by `hex()` https://bugs.python.org/issue35115 closed by fcurella #35116: Doc/library entries for cgi.FieldStorage max_num_fields https://bugs.python.org/issue35116 closed by vstinner #35117: set.discard should return True or False based on if element ex https://bugs.python.org/issue35117 closed by rhettinger #35119: Customizing module attribute access example raises RecursionEr https://bugs.python.org/issue35119 closed by levkivskyi #35128: warning.warn messages with spacing issues https://bugs.python.org/issue35128 closed by scorphus #35129: Different behaviour comparing versions (distutils.version.Loos https://bugs.python.org/issue35129 closed by eric.araujo #35130: add same file name to zipfile ,result two files and same md5 https://bugs.python.org/issue35130 closed by serhiy.storchaka #35135: pip install --download option does not exist https://bugs.python.org/issue35135 closed by zach.ware #35137: Exception in isinstance when __class__ property raises https://bugs.python.org/issue35137 closed by brett.cannon #35139: Statically linking pyexpat in Modules/Setup fails to compile o https://bugs.python.org/issue35139 closed by benjamin.peterson #35141: encoding problem: gbk https://bugs.python.org/issue35141 closed by xtreak #35142: html.entities.html5 should require a trailing semicolon https://bugs.python.org/issue35142 closed by serhiy.storchaka #35146: Bad Regular Expression Broke re.findall() https://bugs.python.org/issue35146 closed by steven.daprano

1 0