--- /dev/null
+# Two-trick pony for OSX and other case insensitive file systems:
+# Ignore ./python binary on Unix but still look into ./Python/ directory.
+/python
+!/Python/
+*.cover
+*.o
+*.orig
+*.pyc
+*.pyd
+*.pyo
+*.rej
+*.swp
+*~
+*.gc??
+*.profclang?
+*.profraw
+*.dyn
+.gdb_history
+Doc/build/
+Doc/venv/
+Lib/distutils/command/*.pdb
+Lib/lib2to3/*.pickle
+Lib/test/data/*
+Makefile
+Makefile.pre
+Misc/python.pc
+Misc/python-config.sh
+Modules/Setup
+Modules/Setup.config
+Modules/Setup.local
+Modules/config.c
+Modules/ld_so_aix
+Programs/_freeze_importlib
+Programs/_testembed
+PC/python_nt*.h
+PC/pythonnt_rc*.h
+PC/*/*.exe
+PC/*/*.exp
+PC/*/*.lib
+PC/*/*.bsc
+PC/*/*.dll
+PC/*/*.pdb
+PC/*/*.user
+PC/*/*.ncb
+PC/*/*.suo
+PC/*/Win32-temp-*
+PC/*/x64-temp-*
+PC/*/amd64
+PCbuild/*.user
+PCbuild/*.suo
+PCbuild/*.*sdf
+PCbuild/*-pgi
+PCbuild/*-pgo
+PCbuild/.vs/
+PCbuild/amd64/
+PCbuild/obj/
+PCBuild/win32/
+.purify
+Parser/pgen
+__pycache__
+autom4te.cache
+build/
+buildno
+config.cache
+config.log
+config.status
+config.status.lineno
+core
+db_home
+.hg/
+ipch/
+libpython*.a
+libpython*.so*
+libpython*.dylib
+platform
+pybuilddir.txt
+pyconfig.h
+python-config
+python-config.py
+python.bat
+python.exe
+python-gdb.py
+python.exe-gdb.py
+reflog.txt
+.svn/
+tags
+TAGS
+.coverage
+coverage/
+externals/
+htmlcov/
+Tools/msi/obj
+Tools/ssl/amd64
+Tools/ssl/win32
+.vs/
+.vscode/
#
# You can set these variables from the command line.
-PYTHON = python
+PYTHON = python3
SPHINXBUILD = sphinx-build
PAPER =
SOURCES =
DISTVERSION = $(shell $(PYTHON) tools/extensions/patchlevel.py)
-ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees -D latex_paper_size=$(PAPER) \
+ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees -D latex_elements.papersize=$(PAPER) \
$(SPHINXOPTS) . build/$(BUILDER) $(SOURCES)
.PHONY: help build html htmlhelp latex text changes linkcheck \
cp -pPR build/epub/Python.epub dist/python-$(DISTVERSION)-docs.epub
check:
- $(PYTHON) tools/rstlint.py -i tools -i venv
+ $(PYTHON) tools/rstlint.py -i tools -i venv -i README.rst
serve:
../Tools/scripts/serve.py build/html
~~~~~~~~~~~~~~~~~~~~~~~~~~~
This directory contains the reStructuredText (reST) sources to the Python
-documentation. You don't need to build them yourself, prebuilt versions are
-available at <https://docs.python.org/dev/download.html>.
+documentation. You don't need to build them yourself, `prebuilt versions are
+available <https://docs.python.org/dev/download.html>`_.
Documentation on authoring Python documentation, including information about
-both style and markup, is available in the "Documenting Python" chapter of the
-developers guide <https://docs.python.org/devguide/documenting.html>.
+both style and markup, is available in the "`Documenting Python
+<https://docs.python.org/devguide/documenting.html>`_" chapter of the
+developers guide.
Building the docs
=================
-You need to have Sphinx <http://sphinx-doc.org/> installed; it is the toolset
+You need to have `Sphinx <http://sphinx-doc.org/>`_ installed; it is the toolset
used to build the docs. It is not included in this tree, but maintained
-separately and available from PyPI <https://pypi.python.org/pypi/Sphinx>.
+separately and `available from PyPI <https://pypi.python.org/pypi/Sphinx>`_.
Using make
Contributing
============
-Bugs in the content should be reported to the Python bug tracker at
-https://bugs.python.org.
+Bugs in the content should be reported to the
+`Python bug tracker <https://bugs.python.org>`_.
-Bugs in the toolset should be reported in the Sphinx bug tracker at
-https://www.bitbucket.org/birkenfeld/sphinx/issues/.
+Bugs in the toolset should be reported in the
+`Sphinx bug tracker <https://github.com/sphinx-doc/sphinx/issues>`_.
You can also send a mail to the Python Documentation Team at docs@python.org,
and we will process your request as soon as possible.
by code that needs to save and restore the error indicator temporarily, e.g.::
{
- PyObject **type, **value, **traceback;
+ PyObject *type, *value, *traceback;
PyErr_Fetch(&type, &value, &traceback);
/* ... code that might produce other errors ... */
The :attr:`ml_flags` field is a bitfield which can include the following flags.
The individual flags indicate either a calling convention or a binding
convention. Of the calling convention flags, only :const:`METH_VARARGS` and
-:const:`METH_KEYWORDS` can be combined (but note that :const:`METH_KEYWORDS`
-alone is equivalent to ``METH_VARARGS | METH_KEYWORDS``). Any of the calling
-convention flags can be combined with a binding flag.
+:const:`METH_KEYWORDS` can be combined. Any of the calling convention flags
+can be combined with a binding flag.
.. data:: METH_VARARGS
Methods with these flags must be of type :c:type:`PyCFunctionWithKeywords`.
The function expects three parameters: *self*, *args*, and a dictionary of
- all the keyword arguments. The flag is typically combined with
+ all the keyword arguments. The flag must be combined with
:const:`METH_VARARGS`, and the parameters are typically processed using
:c:func:`PyArg_ParseTupleAndKeywords`.
This field is deprecated. When it is defined, it should point to a function
that acts the same as the :c:member:`~PyTypeObject.tp_getattro` function, but taking a C string
- instead of a Python string object to give the attribute name. The signature is
- the same as for :c:func:`PyObject_GetAttrString`.
+ instead of a Python string object to give the attribute name. The signature is ::
+
+ PyObject * tp_getattr(PyObject *o, char *attr_name);
This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattro`: a subtype
inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
This field is deprecated. When it is defined, it should point to a function
that acts the same as the :c:member:`~PyTypeObject.tp_setattro` function, but taking a C string
- instead of a Python string object to give the attribute name. The signature is
- the same as for :c:func:`PyObject_SetAttrString`, but setting
- *v* to *NULL* to delete an attribute must be supported.
+ instead of a Python string object to give the attribute name. The signature is ::
+
+ PyObject * tp_setattr(PyObject *o, char *attr_name, PyObject *v);
+ The *v* argument is set to *NULL* to delete the attribute.
This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattro`: a subtype
inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
.. versionadded:: 3.2
-UCS4 Support
-""""""""""""
-
-.. versionadded:: 3.3
-
-.. XXX are these meant to be public?
-
-.. c:function:: size_t Py_UCS4_strlen(const Py_UCS4 *u)
- Py_UCS4* Py_UCS4_strcpy(Py_UCS4 *s1, const Py_UCS4 *s2)
- Py_UCS4* Py_UCS4_strncpy(Py_UCS4 *s1, const Py_UCS4 *s2, size_t n)
- Py_UCS4* Py_UCS4_strcat(Py_UCS4 *s1, const Py_UCS4 *s2)
- int Py_UCS4_strcmp(const Py_UCS4 *s1, const Py_UCS4 *s2)
- int Py_UCS4_strncmp(const Py_UCS4 *s1, const Py_UCS4 *s2, size_t n)
- Py_UCS4* Py_UCS4_strchr(const Py_UCS4 *s, Py_UCS4 c)
- Py_UCS4* Py_UCS4_strrchr(const Py_UCS4 *s, Py_UCS4 c)
-
- These utility functions work on strings of :c:type:`Py_UCS4` characters and
- otherwise behave like the C standard library functions with the same name.
-
-
.. _builtincodecs:
Built-in Codecs
* :const:`Py_True` or :const:`Py_False` for successful comparisons
* :const:`Py_NotImplemented` in case the type combination is unknown
- Note that :const:`Py_EQ` and :const:`Py_NE` comparisons can cause a
- :exc:`UnicodeWarning` in case the conversion of the arguments to Unicode fails
- with a :exc:`UnicodeDecodeError`.
-
Possible values for *op* are :const:`Py_GT`, :const:`Py_GE`, :const:`Py_EQ`,
:const:`Py_NE`, :const:`Py_LT`, and :const:`Py_LE`.
set to *NULL*.
-.. c:function:: PyObject* PyEval_EvalCodeEx(PyObject *co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, PyObject **defs, int defcount, PyObject *closure)
+.. c:function:: PyObject* PyEval_EvalCodeEx(PyObject *co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure)
Evaluate a precompiled code object, given a particular environment for its
evaluation. This environment consists of a dictionary of global variables,
a mapping object of local variables, arrays of arguments, keywords and
- defaults, and a closure tuple of cells.
+ defaults, a dictionary of default values for :ref:`keyword-only\
+ <keyword-only_parameter>` arguments and a closure tuple of cells.
.. c:type:: PyFrameObject
needs_sphinx = '1.2'
# Ignore any .rst files in the venv/ directory.
-exclude_patterns = ['venv/*']
+exclude_patterns = ['venv/*', 'README.rst']
# Options for HTML output
# Options for LaTeX output
# ------------------------
+# Get LaTeX to handle Unicode correctly
+latex_elements = {'inputenc': r'\usepackage[utf8x]{inputenc}', 'utf8extra': ''}
+
+# Additional stuff for the LaTeX preamble.
+latex_elements['preamble'] = r'''
+\authoraddress{
+ \strong{Python Software Foundation}\\
+ Email: \email{docs@python.org}
+}
+\let\Verbatim=\OriginalVerbatim
+\let\endVerbatim=\endOriginalVerbatim
+'''
+
# The paper size ('letter' or 'a4').
-latex_paper_size = 'a4'
+latex_elements['papersize'] = 'a4'
# The font size ('10pt', '11pt' or '12pt').
-latex_font_size = '10pt'
+latex_elements['font_size'] = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, document class [howto/manual]).
for fn in os.listdir('howto')
if fn.endswith('.rst') and fn != 'index.rst')
-# Additional stuff for the LaTeX preamble.
-latex_preamble = r'''
-\authoraddress{
- \strong{Python Software Foundation}\\
- Email: \email{docs@python.org}
-}
-\let\Verbatim=\OriginalVerbatim
-\let\endVerbatim=\endOriginalVerbatim
-'''
-
# Documents to append as an appendix to all manuals.
latex_appendices = ['glossary', 'about', 'license', 'copyright']
-# Get LaTeX to handle Unicode correctly
-latex_elements = {'inputenc': r'\usepackage[utf8x]{inputenc}', 'utf8extra': ''}
-
# Options for Epub output
# -----------------------
Each section describing a repository defines three variables:
- *repository*, that defines the url of the PyPI server. Defaults to
- ``https://www.python.org/pypi``.
+ ``https://upload.pypi.org/legacy/``.
- *username*, which is the registered username on the PyPI server.
- *password*, that will be used to authenticate. If omitted the user
will be prompt to type it when needed.
The latest Python source distribution is always available from python.org, at
https://www.python.org/downloads/. The latest development sources can be obtained
-via anonymous Mercurial access at https://hg.python.org/cpython.
+at https://github.com/python/cpython/.
The source distribution is a gzipped tar file containing the complete C source,
Sphinx-formatted documentation, Python library modules, example programs, and
newsgroups and on the Python home page at https://www.python.org/; an RSS feed of
news is available.
-You can also access the development version of Python through Mercurial. See
-https://docs.python.org/devguide/faq.html for details.
+You can also access the development version of Python through Git. See
+`The Python Developer's Guide <https://docs.python.org/devguide/>`_ for details.
How do I submit bug reports and patches for Python?
The older PyGtk bindings for the `Gtk+ 2 toolkit <http://www.gtk.org>`_ have
been implemented by James Henstridge; see <http://www.pygtk.org>.
+Kivy
+----
+
+`Kivy <https://kivy.org/>`_ is a cross-platform GUI library supporting both
+desktop operating systems (Windows, macOS, Linux) and mobile devices (Android,
+iOS). It is written in Python and Cython, and can use a range of windowing
+backends.
+
+Kivy is free and open source software distributed under the MIT license.
+
FLTK
----
--> Options --> Tabs`, and for file type "Default" set "Tab size" and "Indent
size" to 4, and select the "Insert spaces" radio button.
-If you suspect mixed tabs and spaces are causing problems in leading whitespace,
-run Python with the :option:`-t` switch or run ``Tools/Scripts/tabnanny.py`` to
-check a directory tree in batch mode.
+Python raises :exc:`IndentationError` or :exc:`TabError` if mixed tabs
+and spaces are causing problems in leading whitespace.
+You may also run the :mod:`tabnanny` module to check a directory tree
+in batch mode.
How do I check for a keypress without blocking?
+.. highlightlang:: c
+
**********************
Argument Clinic How-To
**********************
========================
Argument Clinic ships with CPython; you'll find it in ``Tools/clinic/clinic.py``.
-If you run that script, specifying a C file as an argument::
+If you run that script, specifying a C file as an argument:
+
+.. code-block:: shell-session
- % python3 Tools/clinic/clinic.py foo.c
+ $ python3 Tools/clinic/clinic.py foo.c
Argument Clinic will scan over the file looking for lines that
-look exactly like this::
+look exactly like this:
+
+.. code-block:: none
/*[clinic input]
When it finds one, it reads everything up to a line that looks
-exactly like this::
+exactly like this:
+
+.. code-block:: none
[clinic start generated code]*/
When Argument Clinic parses one of these blocks, it
generates output. This output is rewritten into the C file
immediately after the block, followed by a comment containing a checksum.
-The Argument Clinic block now looks like this::
+The Argument Clinic block now looks like this:
+
+.. code-block:: none
/*[clinic input]
... clinic input goes here ...
Write a pickled representation of obj to the open file.
[clinic start generated code]*/
-12. Save and close the file, then run ``Tools/clinic/clinic.py`` on it.
- With luck everything worked and your block now has output! Reopen
- the file in your text editor to see::
-
- /*[clinic input]
- module _pickle
- class _pickle.Pickler "PicklerObject *" "&Pickler_Type"
- [clinic start generated code]*/
- /*[clinic end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+12. Save and close the file, then run ``Tools/clinic/clinic.py`` on
+ it. With luck everything worked---your block now has output, and
+ a ``.c.h`` file has been generated! Reopen the file in your
+ text editor to see::
/*[clinic input]
_pickle.Pickler.dump
Write a pickled representation of obj to the open file.
[clinic start generated code]*/
- PyDoc_STRVAR(_pickle_Pickler_dump__doc__,
- "Write a pickled representation of obj to the open file.\n"
- "\n"
- ...
static PyObject *
- _pickle_Pickler_dump_impl(PicklerObject *self, PyObject *obj)
- /*[clinic end generated code: checksum=3bd30745bf206a48f8b576a1da3d90f55a0a4187]*/
+ _pickle_Pickler_dump(PicklerObject *self, PyObject *obj)
+ /*[clinic end generated code: output=87ecad1261e02ac7 input=552eb1c0f52260d9]*/
Obviously, if Argument Clinic didn't produce any output, it's because
it found an error in your input. Keep fixing your errors and retrying
until Argument Clinic processes your file without complaint.
+ For readability, most of the glue code has been generated to a ``.c.h``
+ file. You'll need to include that in your original ``.c`` file,
+ typically right after the clinic module block::
+
+ #include "clinic/_pickle.c.h"
+
13. Double-check that the argument-parsing code Argument Clinic generated
looks basically the same as the existing code.
value), then the generated code will propagate the error. Otherwise it will
encode the value you return like normal.
-Currently Argument Clinic supports only a few return converters::
+Currently Argument Clinic supports only a few return converters:
+
+.. code-block:: none
bool
int
#endif /* HAVE_FUNCTIONNAME */
And then in the ``PyMethodDef`` structure at the bottom the existing code
-will have::
+will have:
+
+.. code-block:: none
#ifdef HAVE_FUNCTIONNAME
{'functionname', ... },
because that could be deactivated by the ``#ifdef``. (That's the whole point!)
In this situation, Argument Clinic writes the extra code to the "buffer" destination.
-This may mean that you get a complaint from Argument Clinic::
+This may mean that you get a complaint from Argument Clinic:
+
+.. code-block:: none
Warning in file "Modules/posixmodule.c" on line 12357:
Destination buffer 'buffer' not empty at end of file, emptying.
to run Python blocks lets you use Python as a Python preprocessor!
Since Python comments are different from C comments, Argument Clinic
-blocks embedded in Python files look slightly different. They look like this::
+blocks embedded in Python files look slightly different. They look like this:
+
+.. code-block:: python3
#/*[python input]
#print("def foo(): pass")
-------------------------
There might be situations when it is desirable to have logging messages rendered
-in an audible rather than a visible format. This is easy to do if you have text-
-to-speech (TTS) functionality available in your system, even if it doesn't have
+in an audible rather than a visible format. This is easy to do if you have
+text-to-speech (TTS) functionality available in your system, even if it doesn't have
a Python binding. Most TTS systems have a command line program you can run, and
this can be invoked from a handler using :mod:`subprocess`. It's assumed here
that TTS command line programs won't expect to interact with users or take a
please see :ref:`cporting-howto`.
If you would like to read one core Python developer's take on why Python 3
- came into existence, you can read Nick Coghlan's `Python 3 Q & A`_.
+ came into existence, you can read Nick Coghlan's `Python 3 Q & A`_ or
+ Brett Cannon's `Why Python 3 exists`_.
For help with porting, you can email the python-porting_ mailing list with
questions.
#. Make sure you have good test coverage (coverage.py_ can help;
``pip install coverage``)
#. Learn the differences between Python 2 & 3
-#. Use Modernize_ or Futurize_ to update your code (``pip install modernize`` or
- ``pip install future``, respectively)
+#. Use Futurize_ (or Modernize_) to update your code (e.g. ``pip install future``)
#. Use Pylint_ to help make sure you don't regress on your Python 3 support
(``pip install pylint``)
#. Use caniusepython3_ to find out which of your dependencies are blocking your
#. Once your dependencies are no longer blocking you, use continuous integration
to make sure you stay compatible with Python 2 & 3 (tox_ can help test
against multiple versions of Python; ``pip install tox``)
-
-If you are dropping support for Python 2 entirely, then after you learn the
-differences between Python 2 & 3 you can run 2to3_ over your code and skip the
-rest of the steps outlined above.
+#. Consider using optional static type checking to make sure your type usage
+ works in both Python 2 & 3 (e.g. use mypy_ to check your typing under both
+ Python 2 & Python 3).
Details
**today**! Even if your dependencies are not supporting Python 3 yet that does
not mean you can't modernize your code **now** to support Python 3. Most changes
required to support Python 3 lead to cleaner code using newer practices even in
-Python 2.
+Python 2 code.
Another key point is that modernizing your Python 2 code to also support
Python 3 is largely automated for you. While you might have to make some API
overall transformation should not feel foreign to you.
But you should aim for only supporting Python 2.7. Python 2.6 is no longer
-supported and thus is not receiving bugfixes. This means **you** will have to
-work around any issues you come across with Python 2.6. There are also some
+freely supported and thus is not receiving bugfixes. This means **you** will have
+to work around any issues you come across with Python 2.6. There are also some
tools mentioned in this HOWTO which do not support Python 2.6 (e.g., Pylint_),
and this will become more commonplace as time goes on. It will simply be easier
for you if you only support the versions of Python that you have to support.
+
Make sure you specify the proper version support in your ``setup.py`` file
--------------------------------------------------------------------------
also specify each major/minor version of Python that you do support, e.g.
``Programming Language :: Python :: 2.7``.
+
Have good test coverage
-----------------------
thumb is that if you want to be confident enough in your test suite that any
failures that appear after having tools rewrite your code are actual bugs in the
tools and not in your code. If you want a number to aim for, try to get over 80%
-coverage (and don't feel bad if you can't easily get past 90%). If you
-don't already have a tool to measure test coverage then coverage.py_ is
-recommended.
+coverage (and don't feel bad if you find it hard to get better than 90%
+coverage). If you don't already have a tool to measure test coverage then
+coverage.py_ is recommended.
+
Learn the differences between Python 2 & 3
-------------------------------------------
Once you feel like you know what is different in Python 3 compared to Python 2,
it's time to update your code! You have a choice between two tools in porting
-your code automatically: Modernize_ and Futurize_. Which tool you choose will
+your code automatically: Futurize_ and Modernize_. Which tool you choose will
depend on how much like Python 3 you want your code to be. Futurize_ does its
best to make Python 3 idioms and practices exist in Python 2, e.g. backporting
the ``bytes`` type from Python 3 so that you have semantic parity between the
major versions of Python. Modernize_,
on the other hand, is more conservative and targets a Python 2/3 subset of
-Python, relying on six_ to help provide compatibility.
+Python, directly relying on six_ to help provide compatibility. As Python 3 is
+the future, it might be best to consider Futurize to begin adjusting to any new
+practices that Python 3 introduces which you are not accustomed to yet.
Regardless of which tool you choose, they will update your code to run under
Python 3 while staying compatible with the version of Python 2 you started with.
though, there are only a couple of things to watch out for which can be
considered large issues that may be hard to debug if not watched for.
+
Division
++++++++
code would begin to fail (e.g. a user-defined class that uses ``/`` to
signify some operation but not ``//`` for the same thing or at all).
+
Text versus binary data
+++++++++++++++++++++++
pronounced, Python 3 did what most languages created in the age of the internet
have done and made text and binary data distinct types that cannot blindly be
mixed together (Python predates widespread access to the internet). For any code
-that only deals with text or only binary data, this separation doesn't pose an
+that deals only with text or only binary data, this separation doesn't pose an
issue. But for code that has to deal with both, it does mean you might have to
now care about when you are using text compared to binary data, which is why
this cannot be entirely automated.
(it is **highly** recommended you don't design APIs that can take both due to
the difficulty of keeping the code working; as stated earlier it is difficult to
do well). In Python 2 this means making sure the APIs that take text can work
-with ``unicode`` in Python 2 and those that work with binary data work with the
-``bytes`` type from Python 3 and thus a subset of ``str`` in Python 2 (which the
-``bytes`` type in Python 2 is an alias for). Usually the biggest issue is
-realizing which methods exist for which types in Python 2 & 3 simultaneously
+with ``unicode`` and those that work with binary data work with the
+``bytes`` type from Python 3 (which is a subset of ``str`` in Python 2 and acts
+as an alias for ``bytes`` type in Python 2). Usually the biggest issue is
+realizing which methods exist on which types in Python 2 & 3 simultaneously
(for text that's ``unicode`` in Python 2 and ``str`` in Python 3, for binary
that's ``str``/``bytes`` in Python 2 and ``bytes`` in Python 3). The following
table lists the **unique** methods of each data type across Python 2 & 3
(e.g., the ``decode()`` method is usable on the equivalent binary data type in
-either Python 2 or 3, but it can't be used by the text data type consistently
+either Python 2 or 3, but it can't be used by the textual data type consistently
between Python 2 and 3 because ``str`` in Python 3 doesn't have the method). Do
note that as of Python 3.5 the ``__mod__`` method was added to the bytes type.
having to keep track of what type of data you are working with.
The next issue is making sure you know whether the string literals in your code
-represent text or binary data. At minimum you should add a ``b`` prefix to any
-literal that presents binary data. For text you should either use the
-``from __future__ import unicode_literals`` statement or add a ``u`` prefix to
-the text literal.
+represent text or binary data. You should add a ``b`` prefix to any
+literal that presents binary data. For text you should add a ``u`` prefix to
+the text literal. (there is a :mod:`__future__` import to force all unspecified
+literals to be Unicode, but usage has shown it isn't as effective as adding a
+``b`` or ``u`` prefix to all literals explicitly)
As part of this dichotomy you also need to be careful about opening files.
Unless you have been working on Windows, there is a chance you have not always
binary reading). Under Python 3, binary files and text files are clearly
distinct and mutually incompatible; see the :mod:`io` module for details.
Therefore, you **must** make a decision of whether a file will be used for
-binary access (allowing binary data to be read and/or written) or text access
+binary access (allowing binary data to be read and/or written) or textual access
(allowing text data to be read and/or written). You should also use :func:`io.open`
for opening files instead of the built-in :func:`open` function as the :mod:`io`
module is consistent from Python 2 to 3 while the built-in :func:`open` function
-is not (in Python 3 it's actually :func:`io.open`).
+is not (in Python 3 it's actually :func:`io.open`). Do not bother with the
+outdated practice of using :func:`codecs.open` as that's only necessary for
+keeping compatibility with Python 2.5.
The constructors of both ``str`` and ``bytes`` have different semantics for the
same arguments between Python 2 & 3. Passing an integer to ``bytes`` in Python 2
#. Make sure that your code that works with text also works with ``unicode`` and
code for binary data works with ``bytes`` in Python 2 (see the table above
for what methods you cannot use for each type)
-#. Mark all binary literals with a ``b`` prefix, use a ``u`` prefix or
- :mod:`__future__` import statement for text literals
+#. Mark all binary literals with a ``b`` prefix, textual literals with a ``u``
+ prefix
#. Decode binary data to text as soon as possible, encode text as binary data as
late as possible
#. Open files using :func:`io.open` and make sure to specify the ``b`` mode when
appropriate
-#. Be careful when indexing binary data
+#. Be careful when indexing into binary data
Use feature detection instead of version detection
++++++++++++++++++++++++++++++++++++++++++++++++++
+
Inevitably you will have code that has to choose what to do based on what
version of Python is running. The best way to do this is with feature detection
of whether the version of Python you're running under supports what you need.
-If for some reason that doesn't work then you should make the version check is
+If for some reason that doesn't work then you should make the version check be
against Python 2 and not Python 3. To help explain this, let's look at an
example.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
- from __future__ import unicode_literals
You can also run Python 2 with the ``-3`` flag to be warned about various
compatibility issues your code triggers during execution. If you turn warnings
into errors with ``-Werror`` then you can make sure that you don't accidentally
miss a warning.
-
You can also use the Pylint_ project and its ``--py3k`` flag to lint your code
to receive warnings when your code begins to deviate from Python 3
compatibility. This also prevents you from having to run Modernize_ or Futurize_
project was created to help you determine which projects
-- directly or indirectly -- are blocking you from supporting Python 3. There
is both a command-line tool as well as a web interface at
-https://caniusepython3.com .
+https://caniusepython3.com.
The project also provides code which you can integrate into your test suite so
that you will have a failing test when you no longer have dependencies blocking
you from using Python 3. This allows you to avoid having to manually check your
dependencies and to be notified quickly when you can start running on Python 3.
+
Update your ``setup.py`` file to denote Python 3 compatibility
--------------------------------------------------------------
Once your code works under Python 3, you should update the classifiers in
your ``setup.py`` to contain ``Programming Language :: Python :: 3`` and to not
-specify sole Python 2 support. This will tell
-anyone using your code that you support Python 2 **and** 3. Ideally you will
-also want to add classifiers for each major/minor version of Python you now
-support.
+specify sole Python 2 support. This will tell anyone using your code that you
+support Python 2 **and** 3. Ideally you will also want to add classifiers for
+each major/minor version of Python you now support.
+
Use continuous integration to stay compatible
---------------------------------------------
you typically run your tests under while developing.
-Dropping Python 2 support completely
-====================================
-
-If you are able to fully drop support for Python 2, then the steps required
-to transition to Python 3 simplify greatly.
-
-#. Update your code to only support Python 2.7
-#. Make sure you have good test coverage (coverage.py_ can help)
-#. Learn the differences between Python 2 & 3
-#. Use 2to3_ to rewrite your code to run only under Python 3
+Consider using optional static type checking
+--------------------------------------------
-After this your code will be fully Python 3 compliant but in a way that is not
-supported by Python 2. You should also update the classifiers in your
-``setup.py`` to contain ``Programming Language :: Python :: 3 :: Only``.
+Another way to help port your code is to use a static type checker like
+mypy_ or pytype_ on your code. These tools can be used to analyze your code as
+if it's being run under Python 2, then you can run the tool a second time as if
+your code is running under Python 3. By running a static type checker twice like
+this you can discover if you're e.g. misusing binary data type in one version
+of Python compared to another. If you add optional type hints to your code you
+can also explicitly state whether your APIs use textual or binary data, helping
+to make sure everything functions as expected in both versions of Python.
.. _2to3: https://docs.python.org/3/library/2to3.html
.. _importlib: https://docs.python.org/3/library/importlib.html#module-importlib
.. _importlib2: https://pypi.python.org/pypi/importlib2
.. _Modernize: https://python-modernize.readthedocs.org/en/latest/
+.. _mypy: http://mypy-lang.org/
.. _Porting to Python 3: http://python3porting.com/
.. _Pylint: https://pypi.python.org/pypi/pylint
+
.. _Python 3 Q & A: https://ncoghlan-devs-python-notes.readthedocs.org/en/latest/python3/questions_and_answers.html
+.. _pytype: https://github.com/google/pytype
.. _python-future: http://python-future.org/
.. _python-porting: https://mail.python.org/mailman/listinfo/python-porting
.. _six: https://pypi.python.org/pypi/six
.. _tox: https://pypi.python.org/pypi/tox
.. _trove classifier: https://pypi.python.org/pypi?%3Aaction=list_classifiers
+
.. _"What's New": https://docs.python.org/3/whatsnew/index.html
+
+.. _Why Python 3 exists: http://www.snarky.ca/why-python-3-exists
This document was reviewed and revised by John Lee.
.. [#] Google for example.
-.. [#] Browser sniffing is a very bad practise for website design - building
+.. [#] Browser sniffing is a very bad practice for website design - building
sites using web standards is much more sensible. Unfortunately a lot of
sites still send different versions to different browsers.
.. [#] The user agent for MSIE 6 is
Extension("noddy2", ["noddy2.c"]),
Extension("noddy3", ["noddy3.c"]),
Extension("noddy4", ["noddy4.c"]),
+ Extension("shoddy", ["shoddy.c"]),
])
static PyTypeObject ShoddyType = {
- PyObject_HEAD_INIT(NULL)
+ PyVarObject_HEAD_INIT(NULL, 0)
"shoddy.Shoddy", /* tp_name */
sizeof(Shoddy), /* tp_basicsize */
0, /* tp_itemsize */
* conflict_handler_ - The strategy for resolving conflicting optionals
(usually unnecessary)
- * add_help_ - Add a -h/--help option to the parser (default: ``True``)
+ * add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)
* allow_abbrev_ - Allows long options to be abbreviated if the
abbreviation is unambiguous. (default: ``True``)
-h, --help show this help message and exit
--foo FOO foo help
$ cd ..
- $ python subdir\myprogram.py --help
+ $ python subdir/myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]
optional arguments:
Base class for transports.
- .. method:: close(self)
+ .. method:: close()
Close the transport. If the transport has a buffer for outgoing
data, buffered data will be flushed asynchronously. No more data
protocol's :meth:`connection_lost` method will be called with
:const:`None` as its argument.
- .. method:: is_closing(self)
+ .. method:: is_closing()
Return ``True`` if the transport is closing or is closed.
if it hasn't returned, similarly to the
:attr:`subprocess.Popen.returncode` attribute.
- .. method:: kill(self)
+ .. method:: kill()
Kill the subprocess, as in :meth:`subprocess.Popen.kill`.
loop.run_until_complete(display_date(loop))
loop.close()
-The same coroutine implemented using a generator::
-
- @asyncio.coroutine
- def display_date(loop):
- end_time = loop.time() + 5.0
- while True:
- print(datetime.datetime.now())
- if (loop.time() + 1.0) >= end_time:
- break
- yield from asyncio.sleep(1)
-
.. seealso::
The :ref:`display the current date with call_later()
import asyncio
- @asyncio.coroutine
- def slow_operation(future):
- yield from asyncio.sleep(1)
+ async def slow_operation(future):
+ await asyncio.sleep(1)
future.set_result('Future is done!')
loop = asyncio.get_event_loop()
import asyncio
- @asyncio.coroutine
- def slow_operation(future):
- yield from asyncio.sleep(1)
+ async def slow_operation(future):
+ await asyncio.sleep(1)
future.set_result('Future is done!')
def got_result(future):
import asyncio
- @asyncio.coroutine
- def factorial(name, number):
+ async def factorial(name, number):
f = 1
for i in range(2, number+1):
print("Task %s: Compute factorial(%s)..." % (name, i))
- yield from asyncio.sleep(1)
+ await asyncio.sleep(1)
f *= i
print("Task %s: factorial(%s) = %s" % (name, number, f))
loop = asyncio.get_event_loop()
- tasks = [
- asyncio.ensure_future(factorial("A", 2)),
- asyncio.ensure_future(factorial("B", 3)),
- asyncio.ensure_future(factorial("C", 4))]
- loop.run_until_complete(asyncio.gather(*tasks))
+ loop.run_until_complete(asyncio.gather(
+ factorial("A", 2),
+ factorial("B", 3),
+ factorial("C", 4),
+ ))
loop.close()
Output::
.. function:: decodebytes(s)
- decodestring(s)
Decode the :term:`bytes-like object` *s*, which must contain one or more
lines of base64 encoded data, and return the decoded :class:`bytes`.
- ``decodestring`` is a deprecated alias.
.. versionadded:: 3.1
+.. function:: decodestring(s)
+
+ Deprecated alias of :func:`decodebytes`.
+
+ .. deprecated:: 3.1
+
.. function:: encode(input, output)
.. function:: encodebytes(s)
- encodestring(s)
Encode the :term:`bytes-like object` *s*, which can contain arbitrary binary
data, and return :class:`bytes` containing the base64-encoded data, with newlines
(``b'\n'``) inserted after every 76 bytes of output, and ensuring that
there is a trailing newline, as per :rfc:`2045` (MIME).
- ``encodestring`` is a deprecated alias.
+ .. versionadded:: 3.1
+
+.. function:: encodestring(s)
+
+ Deprecated alias of :func:`encodebytes`.
+
+ .. deprecated:: 3.1
An example usage of the module:
.. function:: crc_hqx(data, value)
- Compute the binhex4 crc value of *data*, starting with *value* as the
- initial crc, and return the result.
+ Compute a 16-bit CRC value of *data*, starting with *value* as the
+ initial CRC, and return the result. This uses the CRC-CCITT polynomial
+ *x*:sup:`16` + *x*:sup:`12` + *x*:sup:`5` + 1, often represented as
+ 0x1021. This CRC is used in the binhex4 format.
.. function:: crc32(data[, value])
dictionaries. This allows :class:`OrderedDict` objects to be substituted
anywhere a regular dictionary is used.
-The :class:`OrderedDict` constructor and :meth:`update` method both accept
-keyword arguments, but their order is lost because Python's function call
-semantics pass in keyword arguments using a regular unordered dictionary.
-
.. versionchanged:: 3.5
The items, keys, and values :term:`views <dictionary view>`
of :class:`OrderedDict` now support reverse iteration using :func:`reversed`.
+.. versionchanged:: 3.6
+ With the acceptance of :pep:`468`, order is retained for keyword arguments
+ passed to the :class:`OrderedDict` constructor and its :meth:`update`
+ method.
+
:class:`OrderedDict` Examples and Recipes
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. method:: read(filenames, encoding=None)
Attempt to read and parse a list of filenames, returning a list of
- filenames which were successfully parsed. If *filenames* is a string, it
- is treated as a single filename. If a file named in *filenames* cannot
- be opened, that file will be ignored. This is designed so that you can
- specify a list of potential configuration file locations (for example,
- the current directory, the user's home directory, and some system-wide
- directory), and all existing configuration files in the list will be
- read. If none of the named files exist, the :class:`ConfigParser`
+ filenames which were successfully parsed.
+
+ If *filenames* is a string or :term:`path-like object`, it is treated as
+ a single filename. If a file named in *filenames* cannot be opened, that
+ file will be ignored. This is designed so that you can specify a list of
+ potential configuration file locations (for example, the current
+ directory, the user's home directory, and some system-wide directory),
+ and all existing configuration files in the list will be read.
+
+ If none of the named files exist, the :class:`ConfigParser`
instance will contain an empty dataset. An application which requires
initial values to be loaded from a file should load the required file or
files using :meth:`read_file` before calling :meth:`read` for any
The *encoding* parameter. Previously, all files were read using the
default encoding for :func:`open`.
+ .. versionadded:: 3.6.1
+ The *filenames* parameter accepts a :term:`path-like object`.
+
.. method:: read_file(f, source=None)
Use :meth:`read_file` instead.
.. versionchanged:: 3.2
- :meth:`readfp` now iterates on *f* instead of calling ``f.readline()``.
+ :meth:`readfp` now iterates on *fp* instead of calling ``fp.readline()``.
For existing code calling :meth:`readfp` with arguments which don't
support iteration, the following generator may be used as a wrapper
around the file-like object::
- def readline_generator(f):
- line = f.readline()
+ def readline_generator(fp):
+ line = fp.readline()
while line:
yield line
- line = f.readline()
+ line = fp.readline()
- Instead of ``parser.readfp(f)`` use
- ``parser.read_file(readline_generator(f))``.
+ Instead of ``parser.readfp(fp)`` use
+ ``parser.read_file(readline_generator(fp))``.
.. data:: MAX_INTERPOLATION_DEPTH
.. toctree::
hashlib.rst
- hashlib-blake2.rst
hmac.rst
secrets.rst
The :mod:`csv` module defines the following classes:
-.. class:: DictReader(csvfile, fieldnames=None, restkey=None, restval=None, \
+.. class:: DictReader(f, fieldnames=None, restkey=None, restval=None, \
dialect='excel', *args, **kwds)
Create an object that operates like a regular reader but maps the
whose keys are given by the optional *fieldnames* parameter.
The *fieldnames* parameter is a :term:`sequence`. If *fieldnames* is
- omitted, the values in the first row of the *csvfile* will be used as the
+ omitted, the values in the first row of file *f* will be used as the
fieldnames. Regardless of how the fieldnames are determined, the ordered
dictionary preserves their original ordering.
OrderedDict([('first_name', 'John'), ('last_name', 'Cleese')])
-.. class:: DictWriter(csvfile, fieldnames, restval='', extrasaction='raise', \
+.. class:: DictWriter(f, fieldnames, restval='', extrasaction='raise', \
dialect='excel', *args, **kwds)
Create an object which operates like a regular writer but maps dictionaries
onto output rows. The *fieldnames* parameter is a :mod:`sequence
<collections.abc>` of keys that identify the order in which values in the
- dictionary passed to the :meth:`writerow` method are written to the
- *csvfile*. The optional *restval* parameter specifies the value to be
+ dictionary passed to the :meth:`writerow` method are written to file
+ *f*. The optional *restval* parameter specifies the value to be
written if the dictionary is missing a key in *fieldnames*. If the
dictionary passed to the :meth:`writerow` method contains a key not found in
*fieldnames*, the optional *extrasaction* parameter indicates what action to
Note that unlike the :class:`DictReader` class, the *fieldnames* parameter
of the :class:`DictWriter` is not optional. Since Python's :class:`dict`
objects are not ordered, there is not enough information available to deduce
- the order in which the row should be written to the *csvfile*.
+ the order in which the row should be written to file *f*.
A short usage example::
Example:
- >>> from datetime import time, tzinfo
+ >>> from datetime import time, tzinfo, timedelta
>>> class GMT1(tzinfo):
... def utcoffset(self, dt):
... return timedelta(hours=1)
.. opcode:: BUILD_MAP (count)
- Pushes a new dictionary object onto the stack. The dictionary is pre-sized
- to hold *count* entries.
+ Pushes a new dictionary object onto the stack. Pops ``2 * count`` items
+ so that the dictionary holds *count* entries:
+ ``{..., TOS3: TOS2, TOS1: TOS}``.
+
+ .. versionchanged:: 3.5
+ The dictionary is created from stack items instead of creating an
+ empty dictionary pre-sized to hold *count* items.
.. opcode:: BUILD_CONST_KEY_MAP (count)
.. versionadded:: 3.6
+.. opcode:: BUILD_TUPLE_UNPACK (count)
+
+ Pops *count* iterables from the stack, joins them in a single tuple,
+ and pushes the result. Implements iterable unpacking in tuple
+ displays ``(*x, *y, *z)``.
+
+ .. versionadded:: 3.5
+
+
+.. opcode:: BUILD_LIST_UNPACK (count)
+
+ This is similar to :opcode:`BUILD_TUPLE_UNPACK`, but pushes a list
+ instead of tuple. Implements iterable unpacking in list
+ displays ``[*x, *y, *z]``.
+
+ .. versionadded:: 3.5
+
+
+.. opcode:: BUILD_SET_UNPACK (count)
+
+ This is similar to :opcode:`BUILD_TUPLE_UNPACK`, but pushes a set
+ instead of tuple. Implements iterable unpacking in set
+ displays ``{*x, *y, *z}``.
+
+ .. versionadded:: 3.5
+
+
+.. opcode:: BUILD_MAP_UNPACK (count)
+
+ Pops *count* mappings from the stack, merges them into a single dictionary,
+ and pushes the result. Implements dictionary unpacking in dictionary
+ displays ``{**x, **y, **z}``.
+
+ .. versionadded:: 3.5
+
+
+.. opcode:: BUILD_MAP_UNPACK_WITH_CALL (oparg)
+
+ This is similar to :opcode:`BUILD_MAP_UNPACK`,
+ but is used for ``f(**x, **y, **z)`` call syntax. The lowest byte of
+ *oparg* is the count of mappings, the relative position of the
+ corresponding callable ``f`` is encoded in the second byte of *oparg*.
+
+ .. versionadded:: 3.5
+
+
.. opcode:: LOAD_ATTR (namei)
Replaces TOS with ``getattr(TOS, co_names[namei])``.
A number of option flags control various aspects of doctest's behavior.
Symbolic names for the flags are supplied as module constants, which can be
-or'ed together and passed to various functions. The names can also be used in
-:ref:`doctest directives <doctest-directives>`, and may be passed to the
-doctest command line interface via the ``-o`` option.
+:ref:`bitwise ORed <bitwise>` together and passed to various functions.
+The names can also be used in :ref:`doctest directives <doctest-directives>`,
+and may be passed to the doctest command line interface via the ``-o`` option.
.. versionadded:: 3.4
The ``-o`` command line option.
nothing at the end. In verbose mode, the summary is detailed, else the summary
is very brief (in fact, empty if all tests passed).
- Optional argument *optionflags* (default value 0) takes the bitwise-or of
- option flags. See section :ref:`doctest-options`.
+ Optional argument *optionflags* (default value 0) takes the
+ :ref:`bitwise OR <bitwise>` of option flags.
+ See section :ref:`doctest-options`.
Optional argument *raise_on_error* defaults to false. If true, an exception is
raised upon the first failure or unexpected exception in an example. This
Set the :mod:`doctest` reporting flags to use.
- Argument *flags* takes the bitwise-or of option flags. See section
- :ref:`doctest-options`. Only "reporting flags" can be used.
+ Argument *flags* takes the :ref:`bitwise OR <bitwise>` of option flags. See
+ section :ref:`doctest-options`. Only "reporting flags" can be used.
This is a module-global setting, and affects all future doctests run by module
:mod:`unittest`: the :meth:`runTest` method of :class:`DocTestCase` looks at
the option flags specified for the test case when the :class:`DocTestCase`
instance was constructed. If no reporting flags were specified (which is the
typical and expected case), :mod:`doctest`'s :mod:`unittest` reporting flags are
- or'ed into the option flags, and the option flags so augmented are passed to the
- :class:`DocTestRunner` instance created to run the doctest. If any reporting
- flags were specified when the :class:`DocTestCase` instance was constructed,
- :mod:`doctest`'s :mod:`unittest` reporting flags are ignored.
+ :ref:`bitwise ORed <bitwise>` into the option flags, and the option flags
+ so augmented are passed to the :class:`DocTestRunner` instance created to
+ run the doctest. If any reporting flags were specified when the
+ :class:`DocTestCase` instance was constructed, :mod:`doctest`'s
+ :mod:`unittest` reporting flags are ignored.
The value of the :mod:`unittest` reporting flags in effect before the function
was called is returned by the function.
The conceptual model provided by a :class:`Message` object is that of an
ordered dictionary of headers with additional methods for accessing both
specialized information from the headers, for accessing the payload, for
-generating a serialized version of the mssage, and for recursively walking over
-the object tree. Note that duplicate headers are supported but special methods
-must be used to access them.
+generating a serialized version of the message, and for recursively walking
+over the object tree. Note that duplicate headers are supported but special
+methods must be used to access them.
-The :class:`Message` psuedo-dictionary is indexed by the header names, which
+The :class:`Message` pseudo-dictionary is indexed by the header names, which
must be ASCII values. The values of the dictionary are strings that are
supposed to contain only ASCII characters; there is some special handling for
non-ASCII input, but it doesn't always produce the correct results. Headers
This is a legacy method. On the
:class:`~email.emailmessage.EmailMessage` class its functionality is
replaced by :meth:`~email.message.EmailMessage.set_content` and the
- realted ``make`` and ``add`` methods.
+ related ``make`` and ``add`` methods.
.. method:: get_payload(i=None, decode=False)
*header* specifies an alternative header to :mailheader:`Content-Type`.
If the value contains non-ASCII characters, the charset and language may
- be explicity specified using the optional *charset* and *language*
+ be explicitly specified using the optional *charset* and *language*
parameters. Optional *language* specifies the :rfc:`2231` language,
defaulting to the empty string. Both *charset* and *language* should be
strings. The default is to use the ``utf8`` *charset* and ``None`` for
---------------
This module defines four enumeration classes that can be used to define unique
-sets of names and values: :class:`Enum`, :class:`IntEnum`, and
-:class:`IntFlags`. It also defines one decorator, :func:`unique`, and one
+sets of names and values: :class:`Enum`, :class:`IntEnum`, :class:`Flag`, and
+:class:`IntFlag`. It also defines one decorator, :func:`unique`, and one
helper, :class:`auto`.
.. class:: Enum
Using :class:`auto`
"""""""""""""""""""
-Using :class:`object` would look like::
+Using :class:`auto` would look like::
>>> class Color(NoValue):
... RED = auto()
+++ /dev/null
-.. _hashlib-blake2:
-
-:mod:`hashlib` --- BLAKE2 hash functions
-========================================
-
-.. module:: hashlib
- :synopsis: BLAKE2 hash function for Python
-.. sectionauthor:: Dmitry Chestnykh
-
-.. index::
- single: blake2b, blake2s
-
-BLAKE2_ is a cryptographic hash function defined in RFC-7693_ that comes in two
-flavors:
-
-* **BLAKE2b**, optimized for 64-bit platforms and produces digests of any size
- between 1 and 64 bytes,
-
-* **BLAKE2s**, optimized for 8- to 32-bit platforms and produces digests of any
- size between 1 and 32 bytes.
-
-BLAKE2 supports **keyed mode** (a faster and simpler replacement for HMAC_),
-**salted hashing**, **personalization**, and **tree hashing**.
-
-Hash objects from this module follow the API of standard library's
-:mod:`hashlib` objects.
-
-
-Module
-======
-
-Creating hash objects
----------------------
-
-New hash objects are created by calling constructor functions:
-
-
-.. function:: blake2b(data=b'', digest_size=64, key=b'', salt=b'', \
- person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \
- node_depth=0, inner_size=0, last_node=False)
-
-.. function:: blake2s(data=b'', digest_size=32, key=b'', salt=b'', \
- person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \
- node_depth=0, inner_size=0, last_node=False)
-
-
-These functions return the corresponding hash objects for calculating
-BLAKE2b or BLAKE2s. They optionally take these general parameters:
-
-* *data*: initial chunk of data to hash, which must be interpretable as buffer
- of bytes.
-
-* *digest_size*: size of output digest in bytes.
-
-* *key*: key for keyed hashing (up to 64 bytes for BLAKE2b, up to 32 bytes for
- BLAKE2s).
-
-* *salt*: salt for randomized hashing (up to 16 bytes for BLAKE2b, up to 8
- bytes for BLAKE2s).
-
-* *person*: personalization string (up to 16 bytes for BLAKE2b, up to 8 bytes
- for BLAKE2s).
-
-The following table shows limits for general parameters (in bytes):
-
-======= =========== ======== ========= ===========
-Hash digest_size len(key) len(salt) len(person)
-======= =========== ======== ========= ===========
-BLAKE2b 64 64 16 16
-BLAKE2s 32 32 8 8
-======= =========== ======== ========= ===========
-
-.. note::
-
- BLAKE2 specification defines constant lengths for salt and personalization
- parameters, however, for convenience, this implementation accepts byte
- strings of any size up to the specified length. If the length of the
- parameter is less than specified, it is padded with zeros, thus, for
- example, ``b'salt'`` and ``b'salt\x00'`` is the same value. (This is not
- the case for *key*.)
-
-These sizes are available as module `constants`_ described below.
-
-Constructor functions also accept the following tree hashing parameters:
-
-* *fanout*: fanout (0 to 255, 0 if unlimited, 1 in sequential mode).
-
-* *depth*: maximal depth of tree (1 to 255, 255 if unlimited, 1 in
- sequential mode).
-
-* *leaf_size*: maximal byte length of leaf (0 to 2**32-1, 0 if unlimited or in
- sequential mode).
-
-* *node_offset*: node offset (0 to 2**64-1 for BLAKE2b, 0 to 2**48-1 for
- BLAKE2s, 0 for the first, leftmost, leaf, or in sequential mode).
-
-* *node_depth*: node depth (0 to 255, 0 for leaves, or in sequential mode).
-
-* *inner_size*: inner digest size (0 to 64 for BLAKE2b, 0 to 32 for
- BLAKE2s, 0 in sequential mode).
-
-* *last_node*: boolean indicating whether the processed node is the last
- one (`False` for sequential mode).
-
-.. figure:: hashlib-blake2-tree.png
- :alt: Explanation of tree mode parameters.
-
-See section 2.10 in `BLAKE2 specification
-<https://blake2.net/blake2_20130129.pdf>`_ for comprehensive review of tree
-hashing.
-
-
-Constants
----------
-
-.. data:: blake2b.SALT_SIZE
-.. data:: blake2s.SALT_SIZE
-
-Salt length (maximum length accepted by constructors).
-
-
-.. data:: blake2b.PERSON_SIZE
-.. data:: blake2s.PERSON_SIZE
-
-Personalization string length (maximum length accepted by constructors).
-
-
-.. data:: blake2b.MAX_KEY_SIZE
-.. data:: blake2s.MAX_KEY_SIZE
-
-Maximum key size.
-
-
-.. data:: blake2b.MAX_DIGEST_SIZE
-.. data:: blake2s.MAX_DIGEST_SIZE
-
-Maximum digest size that the hash function can output.
-
-
-Examples
-========
-
-Simple hashing
---------------
-
-To calculate hash of some data, you should first construct a hash object by
-calling the appropriate constructor function (:func:`blake2b` or
-:func:`blake2s`), then update it with the data by calling :meth:`update` on the
-object, and, finally, get the digest out of the object by calling
-:meth:`digest` (or :meth:`hexdigest` for hex-encoded string).
-
- >>> from hashlib import blake2b
- >>> h = blake2b()
- >>> h.update(b'Hello world')
- >>> h.hexdigest()
- '6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
-
-
-As a shortcut, you can pass the first chunk of data to update directly to the
-constructor as the first argument (or as *data* keyword argument):
-
- >>> from hashlib import blake2b
- >>> blake2b(b'Hello world').hexdigest()
- '6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
-
-You can call :meth:`hash.update` as many times as you need to iteratively
-update the hash:
-
- >>> from hashlib import blake2b
- >>> items = [b'Hello', b' ', b'world']
- >>> h = blake2b()
- >>> for item in items:
- ... h.update(item)
- >>> h.hexdigest()
- '6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
-
-
-Using different digest sizes
-----------------------------
-
-BLAKE2 has configurable size of digests up to 64 bytes for BLAKE2b and up to 32
-bytes for BLAKE2s. For example, to replace SHA-1 with BLAKE2b without changing
-the size of output, we can tell BLAKE2b to produce 20-byte digests:
-
- >>> from hashlib import blake2b
- >>> h = blake2b(digest_size=20)
- >>> h.update(b'Replacing SHA1 with the more secure function')
- >>> h.hexdigest()
- 'd24f26cf8de66472d58d4e1b1774b4c9158b1f4c'
- >>> h.digest_size
- 20
- >>> len(h.digest())
- 20
-
-Hash objects with different digest sizes have completely different outputs
-(shorter hashes are *not* prefixes of longer hashes); BLAKE2b and BLAKE2s
-produce different outputs even if the output length is the same:
-
- >>> from hashlib import blake2b, blake2s
- >>> blake2b(digest_size=10).hexdigest()
- '6fa1d8fcfd719046d762'
- >>> blake2b(digest_size=11).hexdigest()
- 'eb6ec15daf9546254f0809'
- >>> blake2s(digest_size=10).hexdigest()
- '1bf21a98c78a1c376ae9'
- >>> blake2s(digest_size=11).hexdigest()
- '567004bf96e4a25773ebf4'
-
-
-Keyed hashing
--------------
-
-Keyed hashing can be used for authentication as a faster and simpler
-replacement for `Hash-based message authentication code
-<http://en.wikipedia.org/wiki/Hash-based_message_authentication_code>`_ (HMAC).
-BLAKE2 can be securely used in prefix-MAC mode thanks to the
-indifferentiability property inherited from BLAKE.
-
-This example shows how to get a (hex-encoded) 128-bit authentication code for
-message ``b'message data'`` with key ``b'pseudorandom key'``::
-
- >>> from hashlib import blake2b
- >>> h = blake2b(key=b'pseudorandom key', digest_size=16)
- >>> h.update(b'message data')
- >>> h.hexdigest()
- '3d363ff7401e02026f4a4687d4863ced'
-
-
-As a practical example, a web application can symmetrically sign cookies sent
-to users and later verify them to make sure they weren't tampered with::
-
- >>> from hashlib import blake2b
- >>> from hmac import compare_digest
- >>>
- >>> SECRET_KEY = b'pseudorandomly generated server secret key'
- >>> AUTH_SIZE = 16
- >>>
- >>> def sign(cookie):
- ... h = blake2b(data=cookie, digest_size=AUTH_SIZE, key=SECRET_KEY)
- ... return h.hexdigest()
- >>>
- >>> cookie = b'user:vatrogasac'
- >>> sig = sign(cookie)
- >>> print("{0},{1}".format(cookie.decode('utf-8'), sig))
- user:vatrogasac,349cf904533767ed2d755279a8df84d0
- >>> compare_digest(cookie, sig)
- True
- >>> compare_digest(b'user:policajac', sig)
- False
- >>> compare_digesty(cookie, '0102030405060708090a0b0c0d0e0f00')
- False
-
-Even though there's a native keyed hashing mode, BLAKE2 can, of course, be used
-in HMAC construction with :mod:`hmac` module::
-
- >>> import hmac, hashlib
- >>> m = hmac.new(b'secret key', digestmod=hashlib.blake2s)
- >>> m.update(b'message')
- >>> m.hexdigest()
- 'e3c8102868d28b5ff85fc35dda07329970d1a01e273c37481326fe0c861c8142'
-
-
-Randomized hashing
-------------------
-
-By setting *salt* parameter users can introduce randomization to the hash
-function. Randomized hashing is useful for protecting against collision attacks
-on the hash function used in digital signatures.
-
- Randomized hashing is designed for situations where one party, the message
- preparer, generates all or part of a message to be signed by a second
- party, the message signer. If the message preparer is able to find
- cryptographic hash function collisions (i.e., two messages producing the
- same hash value), then she might prepare meaningful versions of the message
- that would produce the same hash value and digital signature, but with
- different results (e.g., transferring $1,000,000 to an account, rather than
- $10). Cryptographic hash functions have been designed with collision
- resistance as a major goal, but the current concentration on attacking
- cryptographic hash functions may result in a given cryptographic hash
- function providing less collision resistance than expected. Randomized
- hashing offers the signer additional protection by reducing the likelihood
- that a preparer can generate two or more messages that ultimately yield the
- same hash value during the digital signature generation process --- even if
- it is practical to find collisions for the hash function. However, the use
- of randomized hashing may reduce the amount of security provided by a
- digital signature when all portions of the message are prepared
- by the signer.
-
- (`NIST SP-800-106 "Randomized Hashing for Digital Signatures"
- <http://csrc.nist.gov/publications/nistpubs/800-106/NIST-SP-800-106.pdf>`_)
-
-In BLAKE2 the salt is processed as a one-time input to the hash function during
-initialization, rather than as an input to each compression function.
-
-.. warning::
-
- *Salted hashing* (or just hashing) with BLAKE2 or any other general-purpose
- cryptographic hash function, such as SHA-256, is not suitable for hashing
- passwords. See `BLAKE2 FAQ <https://blake2.net/#qa>`_ for more
- information.
-..
-
- >>> import os
- >>> from hashlib import blake2b
- >>> msg = b'some message'
- >>> # Calculate the first hash with a random salt.
- >>> salt1 = os.urandom(blake2b.SALT_SIZE)
- >>> h1 = blake2b(salt=salt1)
- >>> h1.update(msg)
- >>> # Calculate the second hash with a different random salt.
- >>> salt2 = os.urandom(blake2b.SALT_SIZE)
- >>> h2 = blake2b(salt=salt2)
- >>> h2.update(msg)
- >>> # The digests are different.
- >>> h1.digest() != h2.digest()
- True
-
-
-Personalization
----------------
-
-Sometimes it is useful to force hash function to produce different digests for
-the same input for different purposes. Quoting the authors of the Skein hash
-function:
-
- We recommend that all application designers seriously consider doing this;
- we have seen many protocols where a hash that is computed in one part of
- the protocol can be used in an entirely different part because two hash
- computations were done on similar or related data, and the attacker can
- force the application to make the hash inputs the same. Personalizing each
- hash function used in the protocol summarily stops this type of attack.
-
- (`The Skein Hash Function Family
- <http://www.skein-hash.info/sites/default/files/skein1.3.pdf>`_,
- p. 21)
-
-BLAKE2 can be personalized by passing bytes to the *person* argument::
-
- >>> from hashlib import blake2b
- >>> FILES_HASH_PERSON = b'MyApp Files Hash'
- >>> BLOCK_HASH_PERSON = b'MyApp Block Hash'
- >>> h = blake2b(digest_size=32, person=FILES_HASH_PERSON)
- >>> h.update(b'the same content')
- >>> h.hexdigest()
- '20d9cd024d4fb086aae819a1432dd2466de12947831b75c5a30cf2676095d3b4'
- >>> h = blake2b(digest_size=32, person=BLOCK_HASH_PERSON)
- >>> h.update(b'the same content')
- >>> h.hexdigest()
- 'cf68fb5761b9c44e7878bfb2c4c9aea52264a80b75005e65619778de59f383a3'
-
-Personalization together with the keyed mode can also be used to derive different
-keys from a single one.
-
- >>> from hashlib import blake2s
- >>> from base64 import b64decode, b64encode
- >>> orig_key = b64decode(b'Rm5EPJai72qcK3RGBpW3vPNfZy5OZothY+kHY6h21KM=')
- >>> enc_key = blake2s(key=orig_key, person=b'kEncrypt').digest()
- >>> mac_key = blake2s(key=orig_key, person=b'kMAC').digest()
- >>> print(b64encode(enc_key).decode('utf-8'))
- rbPb15S/Z9t+agffno5wuhB77VbRi6F9Iv2qIxU7WHw=
- >>> print(b64encode(mac_key).decode('utf-8'))
- G9GtHFE1YluXY1zWPlYk1e/nWfu0WSEb0KRcjhDeP/o=
-
-Tree mode
----------
-
-Here's an example of hashing a minimal tree with two leaf nodes::
-
- 10
- / \
- 00 01
-
-This example uses 64-byte internal digests, and returns the 32-byte final
-digest::
-
- >>> from hashlib import blake2b
- >>>
- >>> FANOUT = 2
- >>> DEPTH = 2
- >>> LEAF_SIZE = 4096
- >>> INNER_SIZE = 64
- >>>
- >>> buf = bytearray(6000)
- >>>
- >>> # Left leaf
- ... h00 = blake2b(buf[0:LEAF_SIZE], fanout=FANOUT, depth=DEPTH,
- ... leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
- ... node_offset=0, node_depth=0, last_node=False)
- >>> # Right leaf
- ... h01 = blake2b(buf[LEAF_SIZE:], fanout=FANOUT, depth=DEPTH,
- ... leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
- ... node_offset=1, node_depth=0, last_node=True)
- >>> # Root node
- ... h10 = blake2b(digest_size=32, fanout=FANOUT, depth=DEPTH,
- ... leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
- ... node_offset=0, node_depth=1, last_node=True)
- >>> h10.update(h00.digest())
- >>> h10.update(h01.digest())
- >>> h10.hexdigest()
- '3ad2a9b37c6070e374c7a8c508fe20ca86b6ed54e286e93a0318e95e881db5aa'
-
-Credits
-=======
-
-BLAKE2_ was designed by *Jean-Philippe Aumasson*, *Samuel Neves*, *Zooko
-Wilcox-O'Hearn*, and *Christian Winnerlein* based on SHA-3_ finalist BLAKE_
-created by *Jean-Philippe Aumasson*, *Luca Henzen*, *Willi Meier*, and
-*Raphael C.-W. Phan*.
-
-It uses core algorithm from ChaCha_ cipher designed by *Daniel J. Bernstein*.
-
-The stdlib implementation is based on pyblake2_ module. It was written by
-*Dmitry Chestnykh* based on C implementation written by *Samuel Neves*. The
-documentation was copied from pyblake2_ and written by *Dmitry Chestnykh*.
-
-The C code was partly rewritten for Python by *Christian Heimes*.
-
-The following public domain dedication applies for both C hash function
-implementation, extension code, and this documentation:
-
- To the extent possible under law, the author(s) have dedicated all copyright
- and related and neighboring rights to this software to the public domain
- worldwide. This software is distributed without any warranty.
-
- You should have received a copy of the CC0 Public Domain Dedication along
- with this software. If not, see
- http://creativecommons.org/publicdomain/zero/1.0/.
-
-The following people have helped with development or contributed their changes
-to the project and the public domain according to the Creative Commons Public
-Domain Dedication 1.0 Universal:
-
-* *Alexandr Sokolovskiy*
-
-.. seealso:: Official BLAKE2 website: https://blake2.net
-
-.. _RFC-7693: https://tools.ietf.org/html/rfc7693
-.. _BLAKE2: https://blake2.net
-.. _HMAC: https://en.wikipedia.org/wiki/Hash-based_message_authentication_code
-.. _BLAKE: https://131002.net/blake/
-.. _SHA-3: https://en.wikipedia.org/wiki/NIST_hash_function_competition
-.. _ChaCha: https://cr.yp.to/chacha.html
-.. _pyblake2: https://pythonhosted.org/pyblake2/
-
BLAKE2
------
-BLAKE2 takes additional arguments, see :ref:`hashlib-blake2`.
+.. sectionauthor:: Dmitry Chestnykh
+
+.. index::
+ single: blake2b, blake2s
+
+BLAKE2_ is a cryptographic hash function defined in RFC-7693_ that comes in two
+flavors:
+
+* **BLAKE2b**, optimized for 64-bit platforms and produces digests of any size
+ between 1 and 64 bytes,
+
+* **BLAKE2s**, optimized for 8- to 32-bit platforms and produces digests of any
+ size between 1 and 32 bytes.
+
+BLAKE2 supports **keyed mode** (a faster and simpler replacement for HMAC_),
+**salted hashing**, **personalization**, and **tree hashing**.
+
+Hash objects from this module follow the API of standard library's
+:mod:`hashlib` objects.
+
+
+Creating hash objects
+^^^^^^^^^^^^^^^^^^^^^
+
+New hash objects are created by calling constructor functions:
+
+
+.. function:: blake2b(data=b'', digest_size=64, key=b'', salt=b'', \
+ person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \
+ node_depth=0, inner_size=0, last_node=False)
+
+.. function:: blake2s(data=b'', digest_size=32, key=b'', salt=b'', \
+ person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \
+ node_depth=0, inner_size=0, last_node=False)
+
+
+These functions return the corresponding hash objects for calculating
+BLAKE2b or BLAKE2s. They optionally take these general parameters:
+
+* *data*: initial chunk of data to hash, which must be interpretable as buffer
+ of bytes.
+
+* *digest_size*: size of output digest in bytes.
+
+* *key*: key for keyed hashing (up to 64 bytes for BLAKE2b, up to 32 bytes for
+ BLAKE2s).
+
+* *salt*: salt for randomized hashing (up to 16 bytes for BLAKE2b, up to 8
+ bytes for BLAKE2s).
+
+* *person*: personalization string (up to 16 bytes for BLAKE2b, up to 8 bytes
+ for BLAKE2s).
+
+The following table shows limits for general parameters (in bytes):
+
+======= =========== ======== ========= ===========
+Hash digest_size len(key) len(salt) len(person)
+======= =========== ======== ========= ===========
+BLAKE2b 64 64 16 16
+BLAKE2s 32 32 8 8
+======= =========== ======== ========= ===========
+
+.. note::
+
+ BLAKE2 specification defines constant lengths for salt and personalization
+ parameters, however, for convenience, this implementation accepts byte
+ strings of any size up to the specified length. If the length of the
+ parameter is less than specified, it is padded with zeros, thus, for
+ example, ``b'salt'`` and ``b'salt\x00'`` is the same value. (This is not
+ the case for *key*.)
+
+These sizes are available as module `constants`_ described below.
+
+Constructor functions also accept the following tree hashing parameters:
+
+* *fanout*: fanout (0 to 255, 0 if unlimited, 1 in sequential mode).
+
+* *depth*: maximal depth of tree (1 to 255, 255 if unlimited, 1 in
+ sequential mode).
+
+* *leaf_size*: maximal byte length of leaf (0 to 2**32-1, 0 if unlimited or in
+ sequential mode).
+
+* *node_offset*: node offset (0 to 2**64-1 for BLAKE2b, 0 to 2**48-1 for
+ BLAKE2s, 0 for the first, leftmost, leaf, or in sequential mode).
+
+* *node_depth*: node depth (0 to 255, 0 for leaves, or in sequential mode).
+
+* *inner_size*: inner digest size (0 to 64 for BLAKE2b, 0 to 32 for
+ BLAKE2s, 0 in sequential mode).
+
+* *last_node*: boolean indicating whether the processed node is the last
+ one (`False` for sequential mode).
+
+.. figure:: hashlib-blake2-tree.png
+ :alt: Explanation of tree mode parameters.
+
+See section 2.10 in `BLAKE2 specification
+<https://blake2.net/blake2_20130129.pdf>`_ for comprehensive review of tree
+hashing.
+
+
+Constants
+^^^^^^^^^
+
+.. data:: blake2b.SALT_SIZE
+.. data:: blake2s.SALT_SIZE
+
+Salt length (maximum length accepted by constructors).
+
+
+.. data:: blake2b.PERSON_SIZE
+.. data:: blake2s.PERSON_SIZE
+
+Personalization string length (maximum length accepted by constructors).
+
+
+.. data:: blake2b.MAX_KEY_SIZE
+.. data:: blake2s.MAX_KEY_SIZE
+
+Maximum key size.
+
+
+.. data:: blake2b.MAX_DIGEST_SIZE
+.. data:: blake2s.MAX_DIGEST_SIZE
+
+Maximum digest size that the hash function can output.
+
+
+Examples
+^^^^^^^^
+
+Simple hashing
+""""""""""""""
+
+To calculate hash of some data, you should first construct a hash object by
+calling the appropriate constructor function (:func:`blake2b` or
+:func:`blake2s`), then update it with the data by calling :meth:`update` on the
+object, and, finally, get the digest out of the object by calling
+:meth:`digest` (or :meth:`hexdigest` for hex-encoded string).
+
+ >>> from hashlib import blake2b
+ >>> h = blake2b()
+ >>> h.update(b'Hello world')
+ >>> h.hexdigest()
+ '6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
+
+
+As a shortcut, you can pass the first chunk of data to update directly to the
+constructor as the first argument (or as *data* keyword argument):
+
+ >>> from hashlib import blake2b
+ >>> blake2b(b'Hello world').hexdigest()
+ '6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
+
+You can call :meth:`hash.update` as many times as you need to iteratively
+update the hash:
+
+ >>> from hashlib import blake2b
+ >>> items = [b'Hello', b' ', b'world']
+ >>> h = blake2b()
+ >>> for item in items:
+ ... h.update(item)
+ >>> h.hexdigest()
+ '6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
+
+
+Using different digest sizes
+""""""""""""""""""""""""""""
+
+BLAKE2 has configurable size of digests up to 64 bytes for BLAKE2b and up to 32
+bytes for BLAKE2s. For example, to replace SHA-1 with BLAKE2b without changing
+the size of output, we can tell BLAKE2b to produce 20-byte digests:
+
+ >>> from hashlib import blake2b
+ >>> h = blake2b(digest_size=20)
+ >>> h.update(b'Replacing SHA1 with the more secure function')
+ >>> h.hexdigest()
+ 'd24f26cf8de66472d58d4e1b1774b4c9158b1f4c'
+ >>> h.digest_size
+ 20
+ >>> len(h.digest())
+ 20
+
+Hash objects with different digest sizes have completely different outputs
+(shorter hashes are *not* prefixes of longer hashes); BLAKE2b and BLAKE2s
+produce different outputs even if the output length is the same:
+
+ >>> from hashlib import blake2b, blake2s
+ >>> blake2b(digest_size=10).hexdigest()
+ '6fa1d8fcfd719046d762'
+ >>> blake2b(digest_size=11).hexdigest()
+ 'eb6ec15daf9546254f0809'
+ >>> blake2s(digest_size=10).hexdigest()
+ '1bf21a98c78a1c376ae9'
+ >>> blake2s(digest_size=11).hexdigest()
+ '567004bf96e4a25773ebf4'
+
+
+Keyed hashing
+"""""""""""""
+
+Keyed hashing can be used for authentication as a faster and simpler
+replacement for `Hash-based message authentication code
+<http://en.wikipedia.org/wiki/Hash-based_message_authentication_code>`_ (HMAC).
+BLAKE2 can be securely used in prefix-MAC mode thanks to the
+indifferentiability property inherited from BLAKE.
+
+This example shows how to get a (hex-encoded) 128-bit authentication code for
+message ``b'message data'`` with key ``b'pseudorandom key'``::
+
+ >>> from hashlib import blake2b
+ >>> h = blake2b(key=b'pseudorandom key', digest_size=16)
+ >>> h.update(b'message data')
+ >>> h.hexdigest()
+ '3d363ff7401e02026f4a4687d4863ced'
+
+
+As a practical example, a web application can symmetrically sign cookies sent
+to users and later verify them to make sure they weren't tampered with::
+
+ >>> from hashlib import blake2b
+ >>> from hmac import compare_digest
+ >>>
+ >>> SECRET_KEY = b'pseudorandomly generated server secret key'
+ >>> AUTH_SIZE = 16
+ >>>
+ >>> def sign(cookie):
+ ... h = blake2b(data=cookie, digest_size=AUTH_SIZE, key=SECRET_KEY)
+ ... return h.hexdigest()
+ >>>
+ >>> cookie = b'user:vatrogasac'
+ >>> sig = sign(cookie)
+ >>> print("{0},{1}".format(cookie.decode('utf-8'), sig))
+ user:vatrogasac,349cf904533767ed2d755279a8df84d0
+ >>> compare_digest(cookie, sig)
+ True
+ >>> compare_digest(b'user:policajac', sig)
+ False
+ >>> compare_digesty(cookie, '0102030405060708090a0b0c0d0e0f00')
+ False
+
+Even though there's a native keyed hashing mode, BLAKE2 can, of course, be used
+in HMAC construction with :mod:`hmac` module::
+
+ >>> import hmac, hashlib
+ >>> m = hmac.new(b'secret key', digestmod=hashlib.blake2s)
+ >>> m.update(b'message')
+ >>> m.hexdigest()
+ 'e3c8102868d28b5ff85fc35dda07329970d1a01e273c37481326fe0c861c8142'
+
+
+Randomized hashing
+""""""""""""""""""
+
+By setting *salt* parameter users can introduce randomization to the hash
+function. Randomized hashing is useful for protecting against collision attacks
+on the hash function used in digital signatures.
+
+ Randomized hashing is designed for situations where one party, the message
+ preparer, generates all or part of a message to be signed by a second
+ party, the message signer. If the message preparer is able to find
+ cryptographic hash function collisions (i.e., two messages producing the
+ same hash value), then she might prepare meaningful versions of the message
+ that would produce the same hash value and digital signature, but with
+ different results (e.g., transferring $1,000,000 to an account, rather than
+ $10). Cryptographic hash functions have been designed with collision
+ resistance as a major goal, but the current concentration on attacking
+ cryptographic hash functions may result in a given cryptographic hash
+ function providing less collision resistance than expected. Randomized
+ hashing offers the signer additional protection by reducing the likelihood
+ that a preparer can generate two or more messages that ultimately yield the
+ same hash value during the digital signature generation process --- even if
+ it is practical to find collisions for the hash function. However, the use
+ of randomized hashing may reduce the amount of security provided by a
+ digital signature when all portions of the message are prepared
+ by the signer.
+
+ (`NIST SP-800-106 "Randomized Hashing for Digital Signatures"
+ <http://csrc.nist.gov/publications/nistpubs/800-106/NIST-SP-800-106.pdf>`_)
+
+In BLAKE2 the salt is processed as a one-time input to the hash function during
+initialization, rather than as an input to each compression function.
+
+.. warning::
+
+ *Salted hashing* (or just hashing) with BLAKE2 or any other general-purpose
+ cryptographic hash function, such as SHA-256, is not suitable for hashing
+ passwords. See `BLAKE2 FAQ <https://blake2.net/#qa>`_ for more
+ information.
+..
+
+ >>> import os
+ >>> from hashlib import blake2b
+ >>> msg = b'some message'
+ >>> # Calculate the first hash with a random salt.
+ >>> salt1 = os.urandom(blake2b.SALT_SIZE)
+ >>> h1 = blake2b(salt=salt1)
+ >>> h1.update(msg)
+ >>> # Calculate the second hash with a different random salt.
+ >>> salt2 = os.urandom(blake2b.SALT_SIZE)
+ >>> h2 = blake2b(salt=salt2)
+ >>> h2.update(msg)
+ >>> # The digests are different.
+ >>> h1.digest() != h2.digest()
+ True
+
+
+Personalization
+"""""""""""""""
+
+Sometimes it is useful to force hash function to produce different digests for
+the same input for different purposes. Quoting the authors of the Skein hash
+function:
+
+ We recommend that all application designers seriously consider doing this;
+ we have seen many protocols where a hash that is computed in one part of
+ the protocol can be used in an entirely different part because two hash
+ computations were done on similar or related data, and the attacker can
+ force the application to make the hash inputs the same. Personalizing each
+ hash function used in the protocol summarily stops this type of attack.
+
+ (`The Skein Hash Function Family
+ <http://www.skein-hash.info/sites/default/files/skein1.3.pdf>`_,
+ p. 21)
+
+BLAKE2 can be personalized by passing bytes to the *person* argument::
+
+ >>> from hashlib import blake2b
+ >>> FILES_HASH_PERSON = b'MyApp Files Hash'
+ >>> BLOCK_HASH_PERSON = b'MyApp Block Hash'
+ >>> h = blake2b(digest_size=32, person=FILES_HASH_PERSON)
+ >>> h.update(b'the same content')
+ >>> h.hexdigest()
+ '20d9cd024d4fb086aae819a1432dd2466de12947831b75c5a30cf2676095d3b4'
+ >>> h = blake2b(digest_size=32, person=BLOCK_HASH_PERSON)
+ >>> h.update(b'the same content')
+ >>> h.hexdigest()
+ 'cf68fb5761b9c44e7878bfb2c4c9aea52264a80b75005e65619778de59f383a3'
+
+Personalization together with the keyed mode can also be used to derive different
+keys from a single one.
+
+ >>> from hashlib import blake2s
+ >>> from base64 import b64decode, b64encode
+ >>> orig_key = b64decode(b'Rm5EPJai72qcK3RGBpW3vPNfZy5OZothY+kHY6h21KM=')
+ >>> enc_key = blake2s(key=orig_key, person=b'kEncrypt').digest()
+ >>> mac_key = blake2s(key=orig_key, person=b'kMAC').digest()
+ >>> print(b64encode(enc_key).decode('utf-8'))
+ rbPb15S/Z9t+agffno5wuhB77VbRi6F9Iv2qIxU7WHw=
+ >>> print(b64encode(mac_key).decode('utf-8'))
+ G9GtHFE1YluXY1zWPlYk1e/nWfu0WSEb0KRcjhDeP/o=
+
+Tree mode
+"""""""""
+
+Here's an example of hashing a minimal tree with two leaf nodes::
+
+ 10
+ / \
+ 00 01
+
+This example uses 64-byte internal digests, and returns the 32-byte final
+digest::
+
+ >>> from hashlib import blake2b
+ >>>
+ >>> FANOUT = 2
+ >>> DEPTH = 2
+ >>> LEAF_SIZE = 4096
+ >>> INNER_SIZE = 64
+ >>>
+ >>> buf = bytearray(6000)
+ >>>
+ >>> # Left leaf
+ ... h00 = blake2b(buf[0:LEAF_SIZE], fanout=FANOUT, depth=DEPTH,
+ ... leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
+ ... node_offset=0, node_depth=0, last_node=False)
+ >>> # Right leaf
+ ... h01 = blake2b(buf[LEAF_SIZE:], fanout=FANOUT, depth=DEPTH,
+ ... leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
+ ... node_offset=1, node_depth=0, last_node=True)
+ >>> # Root node
+ ... h10 = blake2b(digest_size=32, fanout=FANOUT, depth=DEPTH,
+ ... leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
+ ... node_offset=0, node_depth=1, last_node=True)
+ >>> h10.update(h00.digest())
+ >>> h10.update(h01.digest())
+ >>> h10.hexdigest()
+ '3ad2a9b37c6070e374c7a8c508fe20ca86b6ed54e286e93a0318e95e881db5aa'
+
+Credits
+^^^^^^^
+
+BLAKE2_ was designed by *Jean-Philippe Aumasson*, *Samuel Neves*, *Zooko
+Wilcox-O'Hearn*, and *Christian Winnerlein* based on SHA-3_ finalist BLAKE_
+created by *Jean-Philippe Aumasson*, *Luca Henzen*, *Willi Meier*, and
+*Raphael C.-W. Phan*.
+
+It uses core algorithm from ChaCha_ cipher designed by *Daniel J. Bernstein*.
+
+The stdlib implementation is based on pyblake2_ module. It was written by
+*Dmitry Chestnykh* based on C implementation written by *Samuel Neves*. The
+documentation was copied from pyblake2_ and written by *Dmitry Chestnykh*.
+
+The C code was partly rewritten for Python by *Christian Heimes*.
+
+The following public domain dedication applies for both C hash function
+implementation, extension code, and this documentation:
+
+ To the extent possible under law, the author(s) have dedicated all copyright
+ and related and neighboring rights to this software to the public domain
+ worldwide. This software is distributed without any warranty.
+
+ You should have received a copy of the CC0 Public Domain Dedication along
+ with this software. If not, see
+ http://creativecommons.org/publicdomain/zero/1.0/.
+
+The following people have helped with development or contributed their changes
+to the project and the public domain according to the Creative Commons Public
+Domain Dedication 1.0 Universal:
+
+* *Alexandr Sokolovskiy*
+
+.. _RFC-7693: https://tools.ietf.org/html/rfc7693
+.. _BLAKE2: https://blake2.net
+.. _HMAC: https://en.wikipedia.org/wiki/Hash-based_message_authentication_code
+.. _BLAKE: https://131002.net/blake/
+.. _SHA-3: https://en.wikipedia.org/wiki/NIST_hash_function_competition
+.. _ChaCha: https://cr.yp.to/chacha.html
+.. _pyblake2: https://pythonhosted.org/pyblake2/
+
.. seealso::
Module :mod:`base64`
Another way to encode binary hashes for non-binary environments.
- See :ref:`hashlib-blake2`.
+ https://blake2.net
+ Official BLAKE2 website.
http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
The FIPS 180-2 publication on Secure Hash Algorithms.
Calltips
^^^^^^^^
-A calltip is shown when one types :kbd:`(` after the name of an *acccessible*
+A calltip is shown when one types :kbd:`(` after the name of an *accessible*
function. A name expression may include dots and subscripts. A calltip
remains until it is clicked, the cursor is moved out of the argument area,
or :kbd:`)` is typed. When the cursor is in the argument part of a definition,
are the names of the ``*`` and ``**`` arguments or ``None``. *locals* is the
locals dictionary of the given frame.
- .. deprecated:: 3.5
- Use :func:`signature` and
- :ref:`Signature Object <inspect-signature-object>`, which provide a
- better introspecting API for callables.
+ .. note::
+ This function was inadvertently marked as deprecated in Python 3.5.
.. function:: formatargspec(args[, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations[, formatarg, formatvarargs, formatvarkw, formatvalue, formatreturns, formatannotations]])
:func:`getargvalues`. The format\* arguments are the corresponding optional
formatting functions that are called to turn names and values into strings.
- .. deprecated:: 3.5
- Use :func:`signature` and
- :ref:`Signature Object <inspect-signature-object>`, which provide a
- better introspecting API for callables.
+ .. note::
+ This function was inadvertently marked as deprecated in Python 3.5.
.. function:: getmro(cls)
If the data being deserialized is not a valid JSON document, a
:exc:`JSONDecodeError` will be raised.
+ .. versionchanged:: 3.6
+ *s* can now be of type :class:`bytes` or :class:`bytearray`. The
+ input encoding should be UTF-8, UTF-16 or UTF-32.
+
+
Encoders and Decoders
---------------------
.. exception:: JSONDecodeError(msg, doc, pos, end=None)
- Subclass of :exc:`ValueError` with the following additional attributes:
+ Subclass of :exc:`ValueError` with the following additional attributes:
- .. attribute:: msg
+ .. attribute:: msg
- The unformatted error message.
+ The unformatted error message.
- .. attribute:: doc
+ .. attribute:: doc
- The JSON document being parsed.
+ The JSON document being parsed.
- .. attribute:: pos
+ .. attribute:: pos
- The start index of *doc* where parsing failed.
+ The start index of *doc* where parsing failed.
- .. attribute:: lineno
+ .. attribute:: lineno
- The line corresponding to *pos*.
+ The line corresponding to *pos*.
- .. attribute:: colno
+ .. attribute:: colno
- The column corresponding to *pos*.
+ The column corresponding to *pos*.
.. versionadded:: 3.5
:param disable_existing_loggers: If specified as ``False``, loggers which
exist when this call is made are left
enabled. The default is ``True`` because this
- enables old behaviour in a backward-
- compatible way. This behaviour is to
+ enables old behaviour in a
+ backward-compatible way. This behaviour is to
disable any existing loggers unless they or
their ancestors are explicitly named in the
logging configuration.
You can use the *maxBytes* and *backupCount* values to allow the file to
:dfn:`rollover` at a predetermined size. When the size is about to be exceeded,
the file is closed and a new file is silently opened for output. Rollover occurs
- whenever the current log file is nearly *maxBytes* in length; if either of
- *maxBytes* or *backupCount* is zero, rollover never occurs. If *backupCount*
- is non-zero, the system will save old log files by appending the extensions
- '.1', '.2' etc., to the filename. For example, with a *backupCount* of 5 and
- a base file name of :file:`app.log`, you would get :file:`app.log`,
+ whenever the current log file is nearly *maxBytes* in length; but if either of
+ *maxBytes* or *backupCount* is zero, rollover never occurs, so you generally want
+ to set *backupCount* to at least 1, and have a non-zero *maxBytes*.
+ When *backupCount* is non-zero, the system will save old log files by appending
+ the extensions '.1', '.2' etc., to the filename. For example, with a *backupCount*
+ of 5 and a base file name of :file:`app.log`, you would get :file:`app.log`,
:file:`app.log.1`, :file:`app.log.2`, up to :file:`app.log.5`. The file being
written to is always :file:`app.log`. When this file is filled, it is closed
and renamed to :file:`app.log.1`, and if files :file:`app.log.1`,
- :file:`app.log.2`, etc. exist, then they are renamed to :file:`app.log.2`,
- :file:`app.log.3` etc. respectively.
+ :file:`app.log.2`, etc. exist, then they are renamed to :file:`app.log.2`,
+ :file:`app.log.3` etc. respectively.
.. versionchanged:: 3.6
As well as string values, :class:`~pathlib.Path` objects are also accepted
.. class:: QueueHandler(queue)
Returns a new instance of the :class:`QueueHandler` class. The instance is
- initialized with the queue to send messages to. The queue can be any queue-
- like object; it's used as-is by the :meth:`enqueue` method, which needs
+ initialized with the queue to send messages to. The queue can be any
+ queue-like object; it's used as-is by the :meth:`enqueue` method, which needs
to know how to send messages to it.
Returns a new instance of the :class:`QueueListener` class. The instance is
initialized with the queue to send messages to and a list of handlers which
- will handle entries placed on the queue. The queue can be any queue-
- like object; it's passed as-is to the :meth:`dequeue` method, which needs
+ will handle entries placed on the queue. The queue can be any queue-like
+ object; it's passed as-is to the :meth:`dequeue` method, which needs
to know how to get messages from it. If ``respect_handler_level`` is ``True``,
a handler's level is respected (compared with the level for the message) when
deciding whether to pass messages to that handler; otherwise, the behaviour
object`.
The *filename* argument can be either an actual file name (given as a
- :class:`str`, :class:`bytes` or :term:`path-like object` object), in
+ :class:`str`, :class:`bytes` or :term:`path-like <path-like object>` object), in
which case the named file is opened, or it can be an existing file object
to read from or write to.
An :class:`LZMAFile` can wrap an already-open :term:`file object`, or operate
directly on a named file. The *filename* argument specifies either the file
object to wrap, or the name of the file to open (as a :class:`str`,
- :class:`bytes` or :term:`path-like object` object). When wrapping an
+ :class:`bytes` or :term:`path-like <path-like object>` object). When wrapping an
existing file object, the wrapped file will not be closed when the
:class:`LZMAFile` is closed.
Get the status of a file or a file descriptor. Perform the equivalent of a
:c:func:`stat` system call on the given path. *path* may be specified as
- either a string -- directly or indirectly through the :class:`PathLike`
+ either a string or bytes -- directly or indirectly through the :class:`PathLike`
interface -- or as an open file descriptor. Return a :class:`stat_result`
object.
:ref:`not following symlinks <follow_symlinks>`.
.. versionchanged:: 3.6
- Accepts a :term:`path-like object` fpr *path* and *attribute*.
+ Accepts a :term:`path-like object` for *path* and *attribute*.
.. function:: listxattr(path=None, *, follow_symlinks=True)
If the package cannot be located or loaded, or it uses a :term:`loader`
which does not support :meth:`get_data <importlib.abc.ResourceLoader.get_data>`,
- then ``None`` is returned.
+ then ``None`` is returned. In particular, the :term:`loader` for
+ :term:`namespace packages <namespace package>` does not support
+ :meth:`get_data <importlib.abc.ResourceLoader.get_data>`.
significant entries. Initially, the list is taken to be the complete set
of profiled functions. Each restriction is either an integer (to select a
count of lines), or a decimal fraction between 0.0 and 1.0 inclusive (to
- select a percentage of lines), or a regular expression (to pattern match
- the standard name that is printed. If several restrictions are provided,
- then they are applied sequentially. For example::
+ select a percentage of lines), or a string that will interpreted as a
+ regular expression (to pattern match the standard name that is printed).
+ If several restrictions are provided, then they are applied sequentially.
+ For example::
print_stats(.1, 'foo:')
.. function:: encode(input, output, quotetabs, header=False)
- Encode the contents of the *input* file and write the resulting quoted-
- printable data to the *output* file. *input* and *output* must be
+ Encode the contents of the *input* file and write the resulting quoted-printable
+ data to the *output* file. *input* and *output* must be
:term:`binary file objects <file object>`. *quotetabs*, a flag which controls
whether to encode embedded spaces and tabs must be provideda and when true it
encodes such embedded whitespace, and when false it leaves them unencoded.
that don't require you to compile a regex object first, but miss some
fine-tuning parameters.
+.. seealso::
+
+ The third-party `regex <https://pypi.python.org/pypi/regex/>`_ module,
+ which has an API compatible with the standard library :mod:`re` module,
+ but offers additional functionality and a more thorough Unicode support.
+
.. _re-syntax:
now are errors.
.. deprecated-removed:: 3.5 3.7
- Unknown escapes in *repl* consist of ``'\'`` and ASCII letter now raise
+ Unknown escapes in *repl* consisting of ``'\'`` and an ASCII letter now raise
a deprecation warning and will be forbidden in Python 3.7.
elif kind == 'SKIP':
pass
elif kind == 'MISMATCH':
- raise RuntimeError('%r unexpected on line %d' % (value, line_num))
+ raise RuntimeError(f'{value!r} unexpected on line {line_num}')
else:
if kind == 'ID' and value in keywords:
kind = value
this is short of a full parser for shells (which would be out of scope for the
standard library, given the multiplicity of shells out there), it does allow
you to perform processing of command lines more easily than you could
-otherwise. To illustrate, you can see the difference in the following snippet::
+otherwise. To illustrate, you can see the difference in the following snippet:
- import shlex
+.. doctest::
+ :options: +NORMALIZE_WHITESPACE
- for punct in (False, True):
- if punct:
- message = 'Old'
- else:
- message = 'New'
- text = "a && b; c && d || e; f >'abc'; (def \"ghi\")"
- s = shlex.shlex(text, punctuation_chars=punct)
- print('%s: %s' % (message, list(s)))
-
-which prints out::
-
- Old: ['a', '&', '&', 'b', ';', 'c', '&', '&', 'd', '|', '|', 'e', ';', 'f', '>', "'abc'", ';', '(', 'def', '"ghi"', ')']
- New: ['a', '&&', 'b', ';', 'c', '&&', 'd', '||', 'e', ';', 'f', '>', "'abc'", ';', '(', 'def', '"ghi"', ')']
+ >>> import shlex
+ >>> text = "a && b; c && d || e; f >'abc'; (def \"ghi\")"
+ >>> list(shlex.shlex(text))
+ ['a', '&', '&', 'b', ';', 'c', '&', '&', 'd', '|', '|', 'e', ';', 'f', '>',
+ "'abc'", ';', '(', 'def', '"ghi"', ')']
+ >>> list(shlex.shlex(text, punctuation_chars=True))
+ ['a', '&&', 'b', ';', 'c', '&&', 'd', '||', 'e', ';', 'f', '>', "'abc'",
+ ';', '(', 'def', '"ghi"', ')']
Of course, tokens will be returned which are not valid for shells, and you'll
need to implement your own error checks on the returned tokens.
>>> list(s)
['~/a', '&&', 'b-c', '--color=auto', '||', 'd', '*.py?']
-
+For best effect, ``punctuation_chars`` should be set in conjunction with
+``posix=True``. (Note that ``posix=False`` is the default for
+:class:`~shlex.shlex`.)
.. versionadded:: 3.2
+.. versionchanged:: 3.5
+ Added support for the *xztar* format.
+
+
High-level utilities to create and read compressed and archived files are also
provided. They rely on the :mod:`zipfile` and :mod:`tarfile` modules.
*base_name* is the name of the file to create, including the path, minus
any format-specific extension. *format* is the archive format: one of
- "zip", "tar", "bztar" (if the :mod:`bz2` module is available), "xztar"
- (if the :mod:`lzma` module is available) or "gztar".
+ "zip" (if the :mod:`zlib` module is available), "tar", "gztar" (if the
+ :mod:`zlib` module is available), "bztar" (if the :mod:`bz2` module is
+ available), or "xztar" (if the :mod:`lzma` module is available).
*root_dir* is a directory that will be the root directory of the
archive; for example, we typically chdir into *root_dir* before creating the
The *verbose* argument is unused and deprecated.
- .. versionchanged:: 3.5
- Added support for the *xztar* format.
-
.. function:: get_archive_formats()
By default :mod:`shutil` provides these formats:
- - *gztar*: gzip'ed tar-file
- - *bztar*: bzip2'ed tar-file (if the :mod:`bz2` module is available.)
- - *xztar*: xz'ed tar-file (if the :mod:`lzma` module is available.)
- - *tar*: uncompressed tar file
- - *zip*: ZIP file
+ - *zip*: ZIP file (if the :mod:`zlib` module is available).
+ - *tar*: uncompressed tar file.
+ - *gztar*: gzip'ed tar-file (if the :mod:`zlib` module is available).
+ - *bztar*: bzip2'ed tar-file (if the :mod:`bz2` module is available).
+ - *xztar*: xz'ed tar-file (if the :mod:`lzma` module is available).
You can register new formats or provide your own archiver for any existing
formats, by using :func:`register_archive_format`.
*extract_dir* is the name of the target directory where the archive is
unpacked. If not provided, the current working directory is used.
- *format* is the archive format: one of "zip", "tar", or "gztar". Or any
- other format registered with :func:`register_unpack_format`. If not
- provided, :func:`unpack_archive` will use the archive file name extension
- and see if an unpacker was registered for that extension. In case none is
- found, a :exc:`ValueError` is raised.
+ *format* is the archive format: one of "zip", "tar", "gztar", "bztar", or
+ "xztar". Or any other format registered with
+ :func:`register_unpack_format`. If not provided, :func:`unpack_archive`
+ will use the archive file name extension and see if an unpacker was
+ registered for that extension. In case none is found,
+ a :exc:`ValueError` is raised.
.. function:: register_unpack_format(name, extensions, function[, extra_args[, description]])
By default :mod:`shutil` provides these formats:
- - *gztar*: gzip'ed tar-file
- - *bztar*: bzip2'ed tar-file (if the :mod:`bz2` module is available.)
- - *xztar*: xz'ed tar-file (if the :mod:`lzma` module is available.)
- - *tar*: uncompressed tar file
- - *zip*: ZIP file
+ - *zip*: ZIP file (unpacking compressed files works only if the corresponding
+ module is available).
+ - *tar*: uncompressed tar file.
+ - *gztar*: gzip'ed tar-file (if the :mod:`zlib` module is available).
+ - *bztar*: bzip2'ed tar-file (if the :mod:`bz2` module is available).
+ - *xztar*: xz'ed tar-file (if the :mod:`lzma` module is available).
You can register new formats or provide your own unpacker for any existing
formats, by using :func:`register_unpack_format`.
Querying the size of the output terminal
----------------------------------------
-.. versionadded:: 3.3
-
.. function:: get_terminal_size(fallback=(columns, lines))
Get the size of the terminal window.
See also: The Single UNIX Specification, Version 2,
`Other Environment Variables`_.
+ .. versionadded:: 3.3
+
.. _`Other Environment Variables`:
http://pubs.opengroup.org/onlinepubs/7908799/xbd/envvar.html#tag_002_003
This module offers several classes to implement SMTP (email) servers.
+.. seealso::
+
+ The `aiosmtpd <http://aiosmtpd.readthedocs.io/>`_ package is a recommended
+ replacement for this module. It is based on :mod:`asyncio` and provides a
+ more straightforward API. :mod:`smtpd` should be considered deprecated.
+
Several server implementations are present; one is a generic
do-nothing implementation, which can be overridden, while the other two offer
specific mail-sending strategies.
provided.
.. versionchanged:: 3.6
- ``SO_DOMAIN``, ``SO_PROTOCOL``, ``SO_PEERSEC``, ``SO_PASSSEC``
- were added.
+ ``SO_DOMAIN``, ``SO_PROTOCOL``, ``SO_PEERSEC``, ``SO_PASSSEC``,
+ ``TCP_USER_TIMEOUT``, ``TCP_CONGESTION`` were added.
.. data:: AF_CAN
PF_CAN
to transmit as opposed to sending the file until EOF is reached. File
position is updated on return or also in case of error in which case
:meth:`file.tell() <io.IOBase.tell>` can be used to figure out the number of
- bytes which were sent. The socket must be of :const:`SOCK_STREAM` type. Non-
- blocking sockets are not supported.
+ bytes which were sent. The socket must be of :const:`SOCK_STREAM` type.
+ Non-blocking sockets are not supported.
.. versionadded:: 3.5
Data Modification Language (DML) statement (i.e.
``INSERT``/``UPDATE``/``DELETE``/``REPLACE``).
-So if you are within a transaction and issue a command like ``CREATE TABLE
-...``, ``VACUUM``, ``PRAGMA``, the :mod:`sqlite3` module will commit implicitly
-before executing that command. There are two reasons for doing that. The first
-is that some of these commands don't work within transactions. The other reason
-is that sqlite3 needs to keep track of the transaction state (if a transaction
-is active or not). The current transaction state is exposed through the
-:attr:`Connection.in_transaction` attribute of the connection object.
-
You can control which kind of ``BEGIN`` statements sqlite3 implicitly executes
(or none at all) via the *isolation_level* parameter to the :func:`connect`
call, or via the :attr:`isolation_level` property of connections.
statement, or set it to one of SQLite's supported isolation levels: "DEFERRED",
"IMMEDIATE" or "EXCLUSIVE".
+The current transaction state is exposed through the
+:attr:`Connection.in_transaction` attribute of the connection object.
+
.. versionchanged:: 3.6
:mod:`sqlite3` used to implicitly commit an open transaction before DDL
statements. This is no longer the case.
.. data:: PROTOCOL_TLS_CLIENT
- Auto-negotiate the the highest protocol version like :data:`PROTOCOL_SSLv23`,
+ Auto-negotiate the highest protocol version like :data:`PROTOCOL_SSLv23`,
but only support client-side :class:`SSLSocket` connections. The protocol
enables :data:`CERT_REQUIRED` and :attr:`~SSLContext.check_hostname` by
default.
.. data:: PROTOCOL_TLS_SERVER
- Auto-negotiate the the highest protocol version like :data:`PROTOCOL_SSLv23`,
+ Auto-negotiate the highest protocol version like :data:`PROTOCOL_SSLv23`,
but only support server-side :class:`SSLSocket` connections.
.. versionadded:: 3.6
.. deprecated:: 3.6
- Use data:`PROTOCOL_TLS` instead.
+ Use :data:`PROTOCOL_TLS` instead.
.. data:: PROTOCOL_SSLv2
.. deprecated:: 3.6
OpenSSL has deprecated all version specific protocols. Use the default
- protocol data:`PROTOCOL_TLS` with flags like data:`OP_NO_SSLv3` instead.
+ protocol :data:`PROTOCOL_TLS` with flags like :data:`OP_NO_SSLv3` instead.
.. data:: PROTOCOL_TLSv1
.. deprecated:: 3.6
OpenSSL has deprecated all version specific protocols. Use the default
- protocol data:`PROTOCOL_TLS` with flags like data:`OP_NO_SSLv3` instead.
+ protocol :data:`PROTOCOL_TLS` with flags like :data:`OP_NO_SSLv3` instead.
.. data:: PROTOCOL_TLSv1_1
.. deprecated:: 3.6
OpenSSL has deprecated all version specific protocols. Use the default
- protocol data:`PROTOCOL_TLS` with flags like data:`OP_NO_SSLv3` instead.
+ protocol :data:`PROTOCOL_TLS` with flags like :data:`OP_NO_SSLv3` instead.
.. data:: PROTOCOL_TLSv1_2
.. deprecated:: 3.6
OpenSSL has deprecated all version specific protocols. Use the default
- protocol data:`PROTOCOL_TLS` with flags like data:`OP_NO_SSLv3` instead.
+ protocol :data:`PROTOCOL_TLS` with flags like :data:`OP_NO_SSLv3` instead.
.. data:: OP_ALL
The version string of the OpenSSL library loaded by the interpreter::
>>> ssl.OPENSSL_VERSION
- 'OpenSSL 0.9.8k 25 Mar 2009'
+ 'OpenSSL 1.0.2k 26 Jan 2017'
.. versionadded:: 3.2
OpenSSL library::
>>> ssl.OPENSSL_VERSION_INFO
- (0, 9, 8, 11, 15)
+ (1, 0, 2, 11, 15)
.. versionadded:: 3.2
The raw version number of the OpenSSL library, as a single integer::
>>> ssl.OPENSSL_VERSION_NUMBER
- 9470143
+ 268443839
>>> hex(ssl.OPENSSL_VERSION_NUMBER)
- '0x9080bf'
+ '0x100020bf'
.. versionadded:: 3.2
:ref:`notes on non-blocking sockets <ssl-nonblocking>`.
Usually, :class:`SSLSocket` are not created directly, but using the
- the :meth:`SSLContext.wrap_socket` method.
+ :meth:`SSLContext.wrap_socket` method.
.. versionchanged:: 3.5
The :meth:`sendfile` method was added.
(1)
This is a short-circuit operator, so it only evaluates the second
- argument if the first one is :const:`False`.
+ argument if the first one is false.
(2)
This is a short-circuit operator, so it only evaluates the second
- argument if the first one is :const:`True`.
+ argument if the first one is true.
(3)
``not`` has a lower priority than non-Boolean operators, so ``not a == b`` is
:ref:`faq-multidimensional-list`.
(3)
- If *i* or *j* is negative, the index is relative to the end of the string:
+ If *i* or *j* is negative, the index is relative to the end of sequence *s*:
``len(s) + i`` or ``len(s) + j`` is substituted. But note that ``-0`` is
still ``0``.
The slice of *s* from *i* to *j* with step *k* is defined as the sequence of
items with index ``x = i + n*k`` such that ``0 <= n < (j-i)/k``. In other words,
the indices are ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` and so on, stopping when
- *j* is reached (but never including *j*). If *i* or *j* is greater than
- ``len(s)``, use ``len(s)``. If *i* or *j* are omitted or ``None``, they become
+ *j* is reached (but never including *j*). When *k* is positive,
+ *i* and *j* are reduced to ``len(s)`` if they are greater.
+ When *k* is negative, *i* and *j* are reduced to ``len(s) - 1`` if
+ they are greater. If *i* or *j* are omitted or ``None``, they become
"end" values (which end depends on the sign of *k*). Note, *k* cannot be zero.
If *k* is ``None``, it is treated like ``1``.
Return true if all characters in the string are decimal
characters and there is at least one character, false
- otherwise. Decimal characters are those from general category "Nd". This category
- includes digit characters, and all characters
- that can be used to form decimal-radix numbers, e.g. U+0660,
- ARABIC-INDIC DIGIT ZERO.
+ otherwise. Decimal characters are those that can be used to form
+ numbers in base 10, e.g. U+0660, ARABIC-INDIC DIGIT
+ ZERO. Formally a decimal character is a character in the Unicode
+ General Category "Nd".
.. method:: str.isdigit()
Return true if all characters in the string are digits and there is at least one
character, false otherwise. Digits include decimal characters and digits that need
- special handling, such as the compatibility superscript digits. Formally, a digit
- is a character that has the property value Numeric_Type=Digit or Numeric_Type=Decimal.
+ special handling, such as the compatibility superscript digits.
+ This covers digits which cannot be used to form numbers in base 10,
+ like the Kharosthi numbers. Formally, a digit is a character that has the
+ property value Numeric_Type=Digit or Numeric_Type=Decimal.
.. method:: str.isidentifier()
+------------+-----------------------------------------------------+-------+
| ``'o'`` | Signed octal value. | \(1) |
+------------+-----------------------------------------------------+-------+
-| ``'u'`` | Obsolete type -- it is identical to ``'d'``. | \(7) |
+| ``'u'`` | Obsolete type -- it is identical to ``'d'``. | \(6) |
+------------+-----------------------------------------------------+-------+
| ``'x'`` | Signed hexadecimal (lowercase). | \(2) |
+------------+-----------------------------------------------------+-------+
Notes:
(1)
- The alternate form causes a leading zero (``'0'``) to be inserted between
- left-hand padding and the formatting of the number if the leading character
- of the result is not already a zero.
+ The alternate form causes a leading octal specifier (``'0o'``) to be
+ inserted before the first digit.
(2)
The alternate form causes a leading ``'0x'`` or ``'0X'`` (depending on whether
- the ``'x'`` or ``'X'`` format was used) to be inserted between left-hand padding
- and the formatting of the number if the leading character of the result is not
- already a zero.
+ the ``'x'`` or ``'X'`` format was used) to be inserted before the first digit.
(3)
The alternate form causes the result to always contain a decimal point, even if
(5)
If precision is ``N``, the output is truncated to ``N`` characters.
-
-(7)
+(6)
See :pep:`237`.
Since Python strings have an explicit length, ``%s`` conversions do not assume
Notes:
(1)
- The alternate form causes a leading zero (``'0'``) to be inserted between
- left-hand padding and the formatting of the number if the leading character
- of the result is not already a zero.
+ The alternate form causes a leading octal specifier (``'0o'``) to be
+ inserted before the first digit.
(2)
The alternate form causes a leading ``'0x'`` or ``'0X'`` (depending on whether
- the ``'x'`` or ``'X'`` format was used) to be inserted between left-hand padding
- and the formatting of the number if the leading character of the result is not
- already a zero.
+ the ``'x'`` or ``'X'`` format was used) to be inserted before the first digit.
(3)
The alternate form causes the result to always contain a decimal point, even if
The *pass_fds* parameter was added.
If *cwd* is not ``None``, the function changes the working directory to
- *cwd* before executing the child. In particular, the function looks for
- *executable* (or for the first item in *args*) relative to *cwd* if the
- executable path is a relative path.
+ *cwd* before executing the child. *cwd* can be a :class:`str` and
+ :term:`path-like <path-like object>` object. In particular, the function
+ looks for *executable* (or for the first item in *args*) relative to *cwd*
+ if the executable path is a relative path.
+
+ .. versionchanged:: 3.6
+ *cwd* parameter accepts a :term:`path-like object`.
If *restore_signals* is true (the default) all signals that Python has set to
SIG_IGN are restored to SIG_DFL in the child process before the exec.
Wait until the thread terminates. This blocks the calling thread until
the thread whose :meth:`~Thread.join` method is called terminates -- either
- normally or through an unhandled exception --, or until the optional
+ normally or through an unhandled exception -- or until the optional
timeout occurs.
When the *timeout* argument is present and not ``None``, it should be a
An explanation of some terminology and conventions is in order.
+.. _epoch:
+
.. index:: single: epoch
-* The :dfn:`epoch` is the point where the time starts. On January 1st of that
- year, at 0 hours, the "time since the epoch" is zero. For Unix, the epoch is
- 1970. To find out what the epoch is, look at ``gmtime(0)``.
+* The :dfn:`epoch` is the point where the time starts, and is platform
+ dependent. For Unix, the epoch is January 1, 1970, 00:00:00 (UTC).
+ To find out what the epoch is on a given platform, look at
+ ``time.gmtime(0)``.
+
+.. _leap seconds: https://en.wikipedia.org/wiki/Leap_second
+
+.. index:: seconds since the epoch
+
+* The term :dfn:`seconds since the epoch` refers to the total number
+ of elapsed seconds since the epoch, typically excluding
+ `leap seconds`_. Leap seconds are excluded from this total on all
+ POSIX-compliant platforms.
.. index:: single: Year 2038
(2)
The range really is ``0`` to ``61``; value ``60`` is valid in
- timestamps representing leap seconds and value ``61`` is supported
+ timestamps representing `leap seconds`_ and value ``61`` is supported
for historical reasons.
(3)
.. function:: time()
- Return the time in seconds since the epoch as a floating point number.
+ Return the time in seconds since the epoch_ as a floating point
+ number. The specific date of the epoch and the handling of
+ `leap seconds`_ is platform dependent.
+ On Windows and most Unix systems, the epoch is January 1, 1970,
+ 00:00:00 (UTC) and leap seconds are not counted towards the time
+ in seconds since the epoch. This is commonly referred to as
+ `Unix time <https://en.wikipedia.org/wiki/Unix_time>`_.
+ To find out what the epoch is on a given platform, look at
+ ``gmtime(0)``.
+
Note that even though the time is always returned as a floating point
number, not all systems provide time with a better precision than 1 second.
While this function normally returns non-decreasing values, it can return a
- lower value than a previous call if the system clock has been set back between
- the two calls.
+ lower value than a previous call if the system clock has been set back
+ between the two calls.
+
+ The number returned by :func:`.time` may be converted into a more common
+ time format (i.e. year, month, day, hour, etc...) in UTC by passing it to
+ :func:`gmtime` function or in local time by passing it to the
+ :func:`localtime` function. In both cases a
+ :class:`struct_time` object is returned, from which the components
+ of the calendar date may be accessed as attributes.
.. data:: timezone
timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()
- .. method:: Timer.autorange(callback=None)
+ .. method:: Timer.autorange(callback=None)
- Automatically determine how many times to call :meth:`.timeit`.
+ Automatically determine how many times to call :meth:`.timeit`.
- This is a convenience function that calls :meth:`.timeit` repeatedly
- so that the total time >= 0.2 second, returning the eventual
- (number of loops, time taken for that number of loops). It calls
- :meth:`.timeit` with *number* set to successive powers of ten (10,
- 100, 1000, ...) up to a maximum of one billion, until the time taken
- is at least 0.2 second, or the maximum is reached.
+ This is a convenience function that calls :meth:`.timeit` repeatedly
+ so that the total time >= 0.2 second, returning the eventual
+ (number of loops, time taken for that number of loops). It calls
+ :meth:`.timeit` with *number* set to successive powers of ten (10,
+ 100, 1000, ...) up to a maximum of one billion, until the time taken
+ is at least 0.2 second, or the maximum is reached.
- If *callback* is given and is not ``None``, it will be called after
- each trial with two arguments: ``callback(number, time_taken)``.
+ If *callback* is given and is not ``None``, it will be called after
+ each trial with two arguments: ``callback(number, time_taken)``.
- .. versionadded:: 3.6
+ .. versionadded:: 3.6
.. method:: Timer.repeat(repeat=3, number=1000000)
list functions executed during a program run. It can be used in another program
or from the command line.
+.. seealso::
+
+ `Coverage.py <https://coverage.readthedocs.io/>`_
+ A popular third-party coverage tool that provides HTML
+ output along with advanced features such as branch coverage.
+
.. _trace-cli:
Command-Line Usage
<string>:5: size=49.7 KiB, count=148, average=344 B
/usr/lib/python3.4/sysconfig.py:411: size=48.0 KiB, count=1, average=48.0 KiB
-We can see that Python loaded ``4.8 MiB`` data (bytecode and constants) from
+We can see that Python loaded ``4855 KiB`` data (bytecode and constants) from
modules and that the :mod:`collections` module allocated ``244 KiB`` to build
:class:`~collections.namedtuple` types.
/usr/lib/python3.4/urllib/parse.py:476: size=71.8 KiB (+71.8 KiB), count=969 (+969), average=76 B
/usr/lib/python3.4/contextlib.py:38: size=67.2 KiB (+67.2 KiB), count=126 (+126), average=546 B
-We can see that Python has loaded ``8.2 MiB`` of module data (bytecode and
-constants), and that this is ``4.4 MiB`` more than had been loaded before the
+We can see that Python has loaded ``8173 KiB`` of module data (bytecode and
+constants), and that this is ``4428 KiB`` more than had been loaded before the
tests, when the previous snapshot was taken. Similarly, the :mod:`linecache`
module has cached ``940 KiB`` of Python source code to format tracebacks, all
of it since the previous snapshot.
"__main__", fname, loader, pkg_name)
We can see that the most memory was allocated in the :mod:`importlib` module to
-load data (bytecode and constants) from modules: ``870 KiB``. The traceback is
+load data (bytecode and constants) from modules: ``870.1 KiB``. The traceback is
where the :mod:`importlib` loaded data most recently: on the ``import pdb``
line of the :mod:`doctest` module. The traceback may change if a new module is
loaded.
import os
import tracemalloc
- def display_top(snapshot, group_by='lineno', limit=10):
+ def display_top(snapshot, key_type='lineno', limit=10):
snapshot = snapshot.filter_traces((
tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
tracemalloc.Filter(False, "<unknown>"),
))
- top_stats = snapshot.statistics(group_by)
+ top_stats = snapshot.statistics(key_type)
print("Top %s lines" % limit)
for index, stat in enumerate(top_stats[:limit], 1):
The :func:`take_snapshot` function creates a snapshot instance.
- .. method:: compare_to(old_snapshot: Snapshot, group_by: str, cumulative: bool=False)
+ .. method:: compare_to(old_snapshot: Snapshot, key_type: str, cumulative: bool=False)
Compute the differences with an old snapshot. Get statistics as a sorted
- list of :class:`StatisticDiff` instances grouped by *group_by*.
+ list of :class:`StatisticDiff` instances grouped by *key_type*.
- See the :meth:`Snapshot.statistics` method for *group_by* and *cumulative*
+ See the :meth:`Snapshot.statistics` method for *key_type* and *cumulative*
parameters.
The result is sorted from the biggest to the smallest by: absolute value
See also :meth:`dump`.
- .. method:: statistics(group_by: str, cumulative: bool=False)
+ .. method:: statistics(key_type: str, cumulative: bool=False)
Get statistics as a sorted list of :class:`Statistic` instances grouped
- by *group_by*:
+ by *key_type*:
===================== ========================
- group_by description
+ key_type description
===================== ========================
``'filename'`` filename
``'lineno'`` filename and line number
If *cumulative* is ``True``, cumulate size and count of memory blocks of
all frames of the traceback of a trace, not only the most recent frame.
- The cumulative mode can only be used with *group_by* equals to
+ The cumulative mode can only be used with *key_type* equals to
``'filename'`` and ``'lineno'``.
The result is sorted from the biggest to the smallest by:
**Source code:** :source:`Lib/typing.py`
+.. note::
+
+ The typing module has been included in the standard library on a
+ :term:`provisional basis <provisional api>`. New features might
+ be added and API may change even between minor releases if deemed
+ necessary by the core developers.
+
--------------
This module supports type hints as specified by :pep:`484` and :pep:`526`.
The :data:`Any` type
----------------------
+--------------------
A special kind of type is :data:`Any`. A static type checker will treat
every type as being compatible with :data:`Any` and :data:`Any` as being
As a shorthand for this type, :class:`bytes` can be used to
annotate arguments of any of the types mentioned above.
+.. class:: Deque(deque, MutableSequence[T])
+
+ A generic version of :class:`collections.deque`.
+
+ .. versionadded:: 3.6.1
+
.. class:: List(list, MutableSequence[T])
Generic version of :class:`list`.
.. class:: AsyncIterator(AsyncIterable[T_co])
- A generic version of :class:`collections.abc.AsyncIterator`.
+ A generic version of :class:`collections.abc.AsyncIterator`.
.. class:: ContextManager(Generic[T_co])
yield start
start += 1
+.. class:: AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra])
+
+ An async generator can be annotated by the generic type
+ ``AsyncGenerator[YieldType, SendType]``. For example::
+
+ async def echo_round() -> AsyncGenerator[int, float]:
+ sent = yield 0
+ while sent >= 0.0:
+ rounded = await round(sent)
+ sent = yield rounded
+
+ Unlike normal generators, async generators cannot return a value, so there
+ is no ``ReturnType`` type parameter. As with :class:`Generator`, the
+ ``SendType`` behaves contravariantly.
+
+ If your generator will only yield values, set the ``SendType`` to
+ ``None``::
+
+ async def infinite_stream(start: int) -> AsyncGenerator[int, None]:
+ while True:
+ yield start
+ start = await increment(start)
+
+ Alternatively, annotate your generator as having a return type of
+ either ``AsyncIterable[YieldType]`` or ``AsyncIterator[YieldType]``::
+
+ async def infinite_stream(start: int) -> AsyncIterator[int]:
+ while True:
+ yield start
+ start = await increment(start)
+
+ .. versionadded:: 3.5.4
+
.. class:: Text
``Text`` is an alias for ``str``. It is provided to supply a forward
Employee = collections.namedtuple('Employee', ['name', 'id'])
- The resulting class has one extra attribute: ``_field_types``,
- giving a dict mapping field names to types. (The field names
- are in the ``_fields`` attribute, which is part of the namedtuple
- API.)
+ To give a field a default value, you can assign to it in the class body::
+
+ class Employee(NamedTuple):
+ name: str
+ id: int = 3
+
+ employee = Employee('Guido')
+ assert employee.id == 3
+
+ Fields with a default value must come after any fields without a default.
+
+ The resulting class has two extra attributes: ``_field_types``,
+ giving a dict mapping field names to types, and ``field_defaults``, a dict
+ mapping field names to default values. (The field names are in the
+ ``_fields`` attribute, which is part of the namedtuple API.)
Backward-compatible usage::
.. versionchanged:: 3.6
Added support for :pep:`526` variable annotation syntax.
+ .. versionchanged:: 3.6.1
+ Added support for default values.
+
.. function:: NewType(typ)
A helper function to indicate a distinct types to a typechecker,
.. method:: assert_called_once_with(*args, **kwargs)
- Assert that the mock was called exactly once and with the specified
- arguments.
+ Assert that the mock was called exactly once and that that call was
+ with the specified arguments.
>>> mock = Mock(return_value=None)
>>> mock('foo', bar='baz')
>>> mock.assert_called_once_with('foo', bar='baz')
- >>> mock('foo', bar='baz')
- >>> mock.assert_called_once_with('foo', bar='baz')
+ >>> mock('other', bar='values')
+ >>> mock.assert_called_once_with('other', bar='values')
Traceback (most recent call last):
...
AssertionError: Expected 'mock' to be called once. Called 2 times.
The assert passes if the mock has *ever* been called, unlike
:meth:`assert_called_with` and :meth:`assert_called_once_with` that
- only pass if the call is the most recent one.
+ only pass if the call is the most recent one, and in the case of
+ :meth:`assert_called_once_with` it must also be the only call.
>>> mock = Mock(return_value=None)
>>> mock(1, 2, arg='thing')
the same attribute will always return the same object. The objects
returned have a sensible repr so that test failure messages are readable.
+ The ``sentinel`` attributes don't preserve their identity when they are
+ :mod:`copied <copy>` or :mod:`pickled <pickle>`.
+
Sometimes when testing you need to test that a specific object is passed as an
argument to another method, or returned. It can be common to create named
sentinel objects to test this. :data:`sentinel` provides a convenient way of
.. class:: TestSuite(tests=())
- This class represents an aggregation of individual tests cases and test suites.
+ This class represents an aggregation of individual test cases and test suites.
The class presents the interface needed by the test runner to allow it to be run
as any other test case. Running a :class:`TestSuite` instance is the same as
iterating over the suite, running each test individually.
.. method:: loadTestsFromTestCase(testCaseClass)
- Return a suite of all tests cases contained in the :class:`TestCase`\ -derived
+ Return a suite of all test cases contained in the :class:`TestCase`\ -derived
:class:`testCaseClass`.
A test case instance is created for each method named by
.. method:: loadTestsFromModule(module, pattern=None)
- Return a suite of all tests cases contained in the given module. This
+ Return a suite of all test cases contained in the given module. This
method searches *module* for classes derived from :class:`TestCase` and
creates an instance of the class for each test method defined for the
class.
.. method:: loadTestsFromName(name, module=None)
- Return a suite of all tests cases given a string specifier.
+ Return a suite of all test cases given a string specifier.
The specifier *name* is a "dotted name" that may resolve either to a
module, a test case class, a test method within a test case class, a
The method optionally resolves *name* relative to the given *module*.
- .. versionchanged:: 3.5
- If an :exc:`ImportError` or :exc:`AttributeError` occurs while traversing
- *name* then a synthetic test that raises that error when run will be
- returned. These errors are included in the errors accumulated by
- self.errors.
+ .. versionchanged:: 3.5
+ If an :exc:`ImportError` or :exc:`AttributeError` occurs while traversing
+ *name* then a synthetic test that raises that error when run will be
+ returned. These errors are included in the errors accumulated by
+ self.errors.
.. method:: loadTestsFromNames(names, module=None)
If both lowercase and uppercase environment variables exist (and disagree),
lowercase is preferred.
- .. note::
+ .. note::
- If the environment variable ``REQUEST_METHOD`` is set, which usually
- indicates your script is running in a CGI environment, the environment
- variable ``HTTP_PROXY`` (uppercase ``_PROXY``) will be ignored. This is
- because that variable can be injected by a client using the "Proxy:" HTTP
- header. If you need to use an HTTP proxy in a CGI environment, either use
- ``ProxyHandler`` explicitly, or make sure the variable name is in
- lowercase (or at least the ``_proxy`` suffix).
+ If the environment variable ``REQUEST_METHOD`` is set, which usually
+ indicates your script is running in a CGI environment, the environment
+ variable ``HTTP_PROXY`` (uppercase ``_PROXY``) will be ignored. This is
+ because that variable can be injected by a client using the "Proxy:" HTTP
+ header. If you need to use an HTTP proxy in a CGI environment, either use
+ ``ProxyHandler`` explicitly, or make sure the variable name is in
+ lowercase (or at least the ``_proxy`` suffix).
The following classes are provided:
:class:`URLopener` objects will raise an :exc:`OSError` exception if the server
returns an error code.
- .. method:: open(fullurl, data=None)
+ .. method:: open(fullurl, data=None)
- Open *fullurl* using the appropriate protocol. This method sets up cache and
- proxy information, then calls the appropriate open method with its input
- arguments. If the scheme is not recognized, :meth:`open_unknown` is called.
- The *data* argument has the same meaning as the *data* argument of
- :func:`urlopen`.
+ Open *fullurl* using the appropriate protocol. This method sets up cache and
+ proxy information, then calls the appropriate open method with its input
+ arguments. If the scheme is not recognized, :meth:`open_unknown` is called.
+ The *data* argument has the same meaning as the *data* argument of
+ :func:`urlopen`.
- .. method:: open_unknown(fullurl, data=None)
+ .. method:: open_unknown(fullurl, data=None)
- Overridable interface to open unknown URL types.
+ Overridable interface to open unknown URL types.
- .. method:: retrieve(url, filename=None, reporthook=None, data=None)
+ .. method:: retrieve(url, filename=None, reporthook=None, data=None)
- Retrieves the contents of *url* and places it in *filename*. The return value
- is a tuple consisting of a local filename and either an
- :class:`email.message.Message` object containing the response headers (for remote
- URLs) or ``None`` (for local URLs). The caller must then open and read the
- contents of *filename*. If *filename* is not given and the URL refers to a
- local file, the input filename is returned. If the URL is non-local and
- *filename* is not given, the filename is the output of :func:`tempfile.mktemp`
- with a suffix that matches the suffix of the last path component of the input
- URL. If *reporthook* is given, it must be a function accepting three numeric
- parameters: A chunk number, the maximum size chunks are read in and the total size of the download
- (-1 if unknown). It will be called once at the start and after each chunk of data is read from the
- network. *reporthook* is ignored for local URLs.
+ Retrieves the contents of *url* and places it in *filename*. The return value
+ is a tuple consisting of a local filename and either an
+ :class:`email.message.Message` object containing the response headers (for remote
+ URLs) or ``None`` (for local URLs). The caller must then open and read the
+ contents of *filename*. If *filename* is not given and the URL refers to a
+ local file, the input filename is returned. If the URL is non-local and
+ *filename* is not given, the filename is the output of :func:`tempfile.mktemp`
+ with a suffix that matches the suffix of the last path component of the input
+ URL. If *reporthook* is given, it must be a function accepting three numeric
+ parameters: A chunk number, the maximum size chunks are read in and the total size of the download
+ (-1 if unknown). It will be called once at the start and after each chunk of data is read from the
+ network. *reporthook* is ignored for local URLs.
- If the *url* uses the :file:`http:` scheme identifier, the optional *data*
- argument may be given to specify a ``POST`` request (normally the request type
- is ``GET``). The *data* argument must in standard
- :mimetype:`application/x-www-form-urlencoded` format; see the
- :func:`urllib.parse.urlencode` function.
+ If the *url* uses the :file:`http:` scheme identifier, the optional *data*
+ argument may be given to specify a ``POST`` request (normally the request type
+ is ``GET``). The *data* argument must in standard
+ :mimetype:`application/x-www-form-urlencoded` format; see the
+ :func:`urllib.parse.urlencode` function.
- .. attribute:: version
+ .. attribute:: version
- Variable that specifies the user agent of the opener object. To get
- :mod:`urllib` to tell servers that it is a particular user agent, set this in a
- subclass as a class variable or in the constructor before calling the base
- constructor.
+ Variable that specifies the user agent of the opener object. To get
+ :mod:`urllib` to tell servers that it is a particular user agent, set this in a
+ subclass as a class variable or in the constructor before calling the base
+ constructor.
.. class:: FancyURLopener(...)
variant and version number set according to RFC 4122, overriding bits in the
given *hex*, *bytes*, *bytes_le*, *fields*, or *int*.
+ Comparison of UUID objects are made by way of comparing their
+ :attr:`UUID.int` attributes. Comparison with a non-UUID object
+ raises a :exc:`TypeError`.
+
+ ``str(uuid)`` returns a string in the form
+ ``12345678-1234-5678-1234-567812345678`` where the 32 hexadecimal digits
+ represent the UUID.
:class:`UUID` instances have these read-only attributes:
.. attribute:: UUID.variant
The UUID variant, which determines the internal layout of the UUID. This will be
- one of the integer constants :const:`RESERVED_NCS`, :const:`RFC_4122`,
+ one of the constants :const:`RESERVED_NCS`, :const:`RFC_4122`,
:const:`RESERVED_MICROSOFT`, or :const:`RESERVED_FUTURE`.
performed by the program during iteration may cause items in the
dictionary to vanish "by magic" (as a side effect of garbage collection).
-:class:`WeakKeyDictionary` objects have the following additional methods. These
-expose the internal references directly. The references are not guaranteed to
+:class:`WeakKeyDictionary` objects have an additional method that
+exposes the internal references directly. The references are not guaranteed to
be "live" at the time they are used, so the result of calling the references
needs to be checked before being used. This can be used to avoid creating
references that will cause the garbage collector to keep the keys around longer
by the program during iteration may cause items in the dictionary to vanish "by
magic" (as a side effect of garbage collection).
-:class:`WeakValueDictionary` objects have the following additional methods.
-These method have the same issues as the and :meth:`keyrefs` method of
-:class:`WeakKeyDictionary` objects.
+:class:`WeakValueDictionary` objects have an additional method that has the
+same issues as the :meth:`keyrefs` method of :class:`WeakKeyDictionary`
+objects.
.. method:: WeakValueDictionary.valuerefs()
(:mod:`zlib`, :mod:`bz2` or :mod:`lzma`) is not available, :exc:`RuntimeError`
is raised. The default is :const:`ZIP_STORED`. If *allowZip64* is
``True`` (the default) zipfile will create ZIP files that use the ZIP64
- extensions when the zipfile is larger than 2 GiB. If it is false :mod:`zipfile`
+ extensions when the zipfile is larger than 4 GiB. If it is false :mod:`zipfile`
will raise an exception when the ZIP file would require ZIP64 extensions.
If the file is created with mode ``'w'``, ``'x'`` or ``'a'`` and then
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python |release| alone or in any derivative
version, provided, however, that PSF's License Agreement and PSF's notice of
- copyright, i.e., "Copyright © 2001-2016 Python Software Foundation; All Rights
+ copyright, i.e., "Copyright © 2001-2017 Python Software Foundation; All Rights
Reserved" are retained in Python |release| alone or in any derivative version
prepared by Licensee.
echo. clean, check, serve, htmlview\r
echo.\r
echo.All arguments past the first one are passed through to sphinx-build as\r
-echo.filenames to build or are ignored. See README.txt in this directory or\r
+echo.filenames to build or are ignored. See README.rst in this directory or\r
echo.the documentation for your version of Sphinx for more exhaustive lists\r
echo.of available targets and descriptions of each.\r
echo.\r
\r
:build\r
if NOT "%PAPER%" == "" (\r
- set SPHINXOPTS=-D latex_paper_size=%PAPER% %SPHINXOPTS%\r
+ set SPHINXOPTS=-D latex_elements.papersize=%PAPER% %SPHINXOPTS%\r
)\r
cmd /C %SPHINXBUILD% %SPHINXOPTS% -b%1 -dbuild\doctrees . %BUILDDIR%\%*\r
\r
Special attributes: :attr:`~definition.__name__` is the class name; :attr:`__module__` is
the module name in which the class was defined; :attr:`~object.__dict__` is the
dictionary containing the class's namespace; :attr:`~class.__bases__` is a
- tuple (possibly empty or a singleton) containing the base classes, in the
- order of their occurrence in the base class list; :attr:`__doc__` is the
- class's documentation string, or ``None`` if undefined;
- :attr:`__annotations__` (optional) is a dictionary containing
- :term:`variable annotations <variable annotation>` collected during
+ tuple containing the base classes, in the order of their occurrence in the
+ base class list; :attr:`__doc__` is the class's documentation string,
+ or ``None`` if undefined; :attr:`__annotations__` (optional) is a dictionary
+ containing :term:`variable annotations <variable annotation>` collected during
class body execution.
Class instances
Called by built-in function :func:`hash` and for operations on members of
hashed collections including :class:`set`, :class:`frozenset`, and
- :class:`dict`. :meth:`__hash__` should return an integer. The only
- required property is that objects which compare equal have the same hash
- value; it is advised to somehow mix together (e.g. using exclusive or) the
- hash values for the components of the object that also play a part in
- comparison of objects.
+ :class:`dict`. :meth:`__hash__` should return an integer. The only required
+ property is that objects which compare equal have the same hash value; it is
+ advised to mix together the hash values of the components of the object that
+ also play a part in comparison of objects by packing them into a tuple and
+ hashing the tuple. Example::
+
+ def __hash__(self):
+ return hash((self.name, self.nick, self.color))
.. note::
clause may be used to iterate over a :term:`asynchronous iterator`.
A comprehension in an :keyword:`async def` function may consist of either a
:keyword:`for` or :keyword:`async for` clause following the leading
-expression, may contan additonal :keyword:`for` or :keyword:`async for`
+expression, may contain additional :keyword:`for` or :keyword:`async for`
clauses, and may also use :keyword:`await` expressions.
If a comprehension contains either :keyword:`async for` clauses
or :keyword:`await` expressions it is called an
starred_and_keywords: ("*" `expression` | `keyword_item`)
: ("," "*" `expression` | "," `keyword_item`)*
keywords_arguments: (`keyword_item` | "**" `expression`)
- : ("," `keyword_item` | "**" `expression`)*
+ : ("," `keyword_item` | "," "**" `expression`)*
keyword_item: `identifier` "=" `expression`
An optional trailing comma may be present after the positional and keyword arguments
* Sequences (instances of :class:`tuple`, :class:`list`, or :class:`range`) can
be compared only within each of their types, with the restriction that ranges
do not support order comparison. Equality comparison across these types
- results in unequality, and ordering comparison across these types raises
+ results in inequality, and ordering comparison across these types raises
:exc:`TypeError`.
Sequences compare lexicographically using comparison of corresponding
sequences, but not to sets or mappings). See also the
:func:`~functools.total_ordering` decorator.
+* The :func:`hash` result should be consistent with equality.
+ Objects that are equal should either have the same hash value,
+ or be marked as unhashable.
+
Python does not enforce these consistency rules. In fact, the not-a-number
values are an example for not following these rules.
import machinery will create the new module itself.
.. versionadded:: 3.4
- The create_module() method of loaders.
+ The :meth:`~importlib.abc.Loader.create_module` method of loaders.
.. versionchanged:: 3.4
The :meth:`~importlib.abc.Loader.load_module` method was replaced by
.. versionchanged:: 3.5
A :exc:`DeprecationWarning` is raised when ``exec_module()`` is defined but
- ``create_module()`` is not. Starting in Python 3.6 it will be an error to not
- define ``create_module()`` on a loader attached to a ModuleSpec.
+ ``create_module()`` is not.
+
+.. versionchanged:: 3.6
+ An :exc:`ImportError` is raised when ``exec_module()`` is defined but
+ ``create_module()`` is not.
Submodules
----------
:license: Python license.
"""
+from __future__ import print_function
+
import os
import re
import sys
return get_header_version_info('.')
except (IOError, OSError):
version, release = get_sys_version_info()
- print >>sys.stderr, 'Can\'t get version info from Include/patchlevel.h, ' \
- 'using version of this interpreter (%s).' % release
+ print('Can\'t get version info from Include/patchlevel.h, ' \
+ 'using version of this interpreter (%s).' % release, file=sys.stderr)
return version, release
if __name__ == '__main__':
ISSUE_URI = 'https://bugs.python.org/issue%s'
-SOURCE_URI = 'https://hg.python.org/cpython/file/3.6/%s'
+SOURCE_URI = 'https://github.com/python/cpython/tree/3.6/%s'
# monkey-patch reST parser to disable alphabetic and roman enumerated lists
from docutils.parsers.rst.states import Body
def issue_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
issue = utils.unescape(text)
- text = 'issue ' + issue
+ text = 'bpo-' + issue
refnode = nodes.reference(text, text, refuri=ISSUE_URI % issue)
return [refnode], []
# Support for including Misc/NEWS
-issue_re = re.compile('([Ii])ssue #([0-9]+)')
+issue_re = re.compile('(?:[Ii]ssue #|bpo-)([0-9]+)')
whatsnew_re = re.compile(r"(?im)^what's new in (.*?)\??$")
text = 'The NEWS file is not available.'
node = nodes.strong(text, text)
return [node]
- content = issue_re.sub(r'`\1ssue #\2 <https://bugs.python.org/\2>`__',
+ content = issue_re.sub(r'`bpo-\1 <https://bugs.python.org/issue\1>`__',
content)
content = whatsnew_re.sub(r'\1', content)
# remove first 3 lines as they are the main heading
library/functions,,:step,a[start:stop:step]
library/functions,,:stop,"a[start:stop, i]"
library/functions,,:stop,a[start:stop:step]
-library/hashlib-blake2,,:vatrogasac,>>> cookie = b'user:vatrogasac'
-library/hashlib-blake2,,:vatrogasac,"user:vatrogasac,349cf904533767ed2d755279a8df84d0"
-library/hashlib-blake2,,:policajac,">>> compare_digest(b'user:policajac', sig)"
-library/hashlib-blake2,,:LEAF,"h00 = blake2b(buf[0:LEAF_SIZE], fanout=FANOUT, depth=DEPTH,"
+library/hashlib,,:vatrogasac,>>> cookie = b'user:vatrogasac'
+library/hashlib,,:vatrogasac,"user:vatrogasac,349cf904533767ed2d755279a8df84d0"
+library/hashlib,,:policajac,">>> compare_digest(b'user:policajac', sig)"
+library/hashlib,,:LEAF,"h00 = blake2b(buf[0:LEAF_SIZE], fanout=FANOUT, depth=DEPTH,"
library/http.client,,:port,host:port
library/http.cookies,,`,!#$%&'*+-.^_`|~:
library/imaplib,,:MM,"""DD-Mmm-YYYY HH:MM:SS"
<h3>{{ _('This Page') }}</h3>
<ul class="this-page-menu">
<li><a href="{{ pathto('bugs') }}">{% trans %}Report a Bug{% endtrans %}</a></li>
- <li><a href="{{ pathto('_sources/' + sourcename, true)|e }}"
- rel="nofollow">{{ _('Show Source') }}</a></li>
+ <li>
+ <a href="https://github.com/python/cpython/blob/{{ version }}/Doc/{{ sourcename|replace('txt', 'rst') }}"
+ rel="nofollow">{{ _('Show Source') }}
+ </a>
+ </li>
</ul>
</div>
{%- endif %}
-{% extends "defindex.html" %}
-{% block tables %}
+{% extends "layout.html" %}
+{%- block htmltitle -%}
+<title>{{ shorttitle }}</title>
+{%- endblock -%}
+{% block body %}
+ <h1>{{ docstitle|e }}</h1>
+ <p>
+ {% trans %}Welcome! This is the documentation for Python {{ release }}.{% endtrans %}
+ </p>
<p><strong>{% trans %}Parts of the documentation:{% endtrans %}</strong></p>
<table class="contentstable" align="center"><tr>
<td width="50%">
{% endblock %}
{% block extrahead %}
<link rel="shortcut icon" type="image/png" href="{{ pathto('_static/py.png', 1) }}" />
+ <link rel="canonical" href="https://docs.python.org/3/{{pagename}}.html" />
{% if builder != "htmlhelp" %}
{% if not embedded %}<script type="text/javascript" src="{{ pathto('_static/copybutton.js', 1) }}"></script>{% endif %}
{% if versionswitcher is defined and not embedded %}<script type="text/javascript" src="{{ pathto('_static/version_switch.js', 1) }}"></script>{% endif %}
called without any --- even if the argument isn't actually used...
Actually, you may have guessed the answer: the special thing about methods is
-that the object is passed as the first argument of the function. In our
+that the instance object is passed as the first argument of the function. In our
example, the call ``x.f()`` is exactly equivalent to ``MyClass.f(x)``. In
general, calling a method with a list of *n* arguments is equivalent to calling
the corresponding function with an argument list that is created by inserting
-the method's object before the first argument.
+the method's instance object before the first argument.
If you still don't understand how methods work, a look at the implementation can
perhaps clarify matters. When an instance attribute is referenced that isn't a
namespace; the name :attr:`~object.__dict__` is an attribute but not a global name.
Obviously, using this violates the abstraction of namespace implementation, and
should be restricted to things like post-mortem debuggers.
-
for arg in arguments:
print(arg)
print("-" * 40)
- keys = sorted(keywords.keys())
- for kw in keys:
+ for kw in keywords:
print(kw, ":", keywords[kw])
It could be called like this::
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
- client : John Cleese
shopkeeper : Michael Palin
+ client : John Cleese
sketch : Cheese Shop Sketch
-Note that the list of keyword argument names is created by sorting the result
-of the keywords dictionary's ``keys()`` method before printing its contents;
-if this is not done, the order in which the arguments are printed is undefined.
+Note that the order in which the keyword arguments are printed is guaranteed
+to match the order in which they were provided in the function call.
+
.. _tut-arbitraryargs:
Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``.
-.. method:: list.extend(L)
+.. method:: list.extend(iterable)
:noindex:
- Extend the list by appending all the items in the given list. Equivalent to
- ``a[len(a):] = L``.
+ Extend the list by appending all the items from the iterable. Equivalent to
+ ``a[len(a):] = iterable``.
.. method:: list.insert(i, x)
The optional arguments *start* and *end* are interpreted as in the slice
notation and are used to limit the search to a particular subsequence of
- *x*. The returned index is computed relative to the beginning of the full
+ the list. The returned index is computed relative to the beginning of the full
sequence rather than the *start* argument.
recognize that the file is UTF-8, and it must use a font that supports all the
characters in the file.
-It is also possible to specify a different encoding for source files. In order
-to do this, put one more special comment line right after the ``#!`` line to
-define the source file encoding::
+To declare an encoding other than the default one, a special comment line
+should be added as the *first* line of the file. The syntax is as follows::
# -*- coding: encoding -*-
-With that declaration, everything in the source file will be treated as having
-the encoding *encoding* instead of UTF-8. The list of possible encodings can be
-found in the Python Library Reference, in the section on :mod:`codecs`.
+where *encoding* is one of the valid :mod:`codecs` supported by Python.
-For example, if your editor of choice does not support UTF-8 encoded files and
-insists on using some other encoding, say Windows-1252, you can write::
+For example, to declare that Windows-1252 encoding is to be used, the first
+line of your source code file should be::
# -*- coding: cp-1252 -*-
-and still use all characters in the Windows-1252 character set in the source
-files. The special encoding comment must be in the *first or second* line
-within the file.
+One exception to the *first line* rule is when the source code starts with a
+:ref:`UNIX "shebang" line <tut-scripts>`. In this case, the encoding
+declaration should be added as the second line of the file. For example::
+ #!/usr/bin/env python3
+ # -*- coding: cp-1252 -*-
.. rubric:: Footnotes
Information about string formatting with :meth:`str.format`.
:ref:`old-string-formatting`
- The old formatting operations invoked when strings and Unicode strings are
+ The old formatting operations invoked when strings are
the left operand of the ``%`` operator are described in more detail here.
``__all__`` is defined.)
Although certain modules are designed to export only names that follow certain
-patterns when you use ``import *``, it is still considered bad practise in
+patterns when you use ``import *``, it is still considered bad practice in
production code.
Remember, there is nothing wrong with using ``from Package import
defines the following possible values:
* ``-X faulthandler`` to enable :mod:`faulthandler`;
- * ``-X showrefcount`` to enable the output of the total reference count
- and memory blocks (only works on debug builds);
+ * ``-X showrefcount`` to output the total reference count and number of used
+ memory blocks when the program finishes or after each statement in the
+ interactive interpreter. This only works on debug builds.
* ``-X tracemalloc`` to start tracing Python memory allocations using the
:mod:`tracemalloc` module. By default, only the most recent frame is
stored in a traceback of a trace. Use ``-X tracemalloc=NFRAME`` to start
tracing with a traceback limit of *NFRAME* frames. See the
:func:`tracemalloc.start` for more information.
- * ``-X showalloccount`` to enable the output of the total count of allocated
- objects for each type (only works when built with ``COUNT_ALLOCS`` defined);
+ * ``-X showalloccount`` to output the total count of allocated objects for
+ each type when the program finishes. This only works when Python was built with
+ ``COUNT_ALLOCS`` defined.
It also allows passing arbitrary values and retrieving them through the
:data:`sys._xoptions` dictionary.
.. versionchanged:: 3.2
- It is now allowed to pass :option:`-X` with CPython.
+ The :option:`-X` option was added.
.. versionadded:: 3.3
The ``-X faulthandler`` option.
To use shell commands in your Python scripts, look at the :mod:`subprocess` module.
-Editors
-=======
+Editors and IDEs
+================
-Vim and Emacs are excellent editors which support Python very well. For more
-information on how to code in Python in these editors, look at:
+There are a number of IDEs that support Python programming language.
+Many editors and IDEs provide syntax highlighting, debugging tools, and PEP-8 checks.
-* http://www.vim.org/scripts/script.php?script_id=790
-* https://sourceforge.net/projects/python-mode
-
-Geany is an excellent IDE with support for a lot of languages. For more
-information, read: https://www.geany.org/
-
-Komodo edit is another extremely good IDE. It also has support for a lot of
-languages. For more information, read https://komodoide.com/.
+Please go to `Python Editors <https://wiki.python.org/moin/PythonEditors>`_ and
+`Integrated Development Environments <https://wiki.python.org/moin/IntegratedDevelopmentEnvironments>`_
+for a comprehensive list.
\ No newline at end of file
8-bit number used by ASCII, meaning that 65,536 distinct characters can be
supported.
-The final interface for Unicode support was arrived at through countless often-
-stormy discussions on the python-dev mailing list, and mostly implemented by
+The final interface for Unicode support was arrived at through countless
+often-stormy discussions on the python-dev mailing list, and mostly implemented by
Marc-André Lemburg, based on a Unicode string type implementation by Fredrik
Lundh. A detailed explanation of the interface was written up as :pep:`100`,
"Python Unicode Integration". This article will simply cover the most
API for XML) provides an event-driven interface with some similarities to
:mod:`xmllib`, and the DOM (Document Object Model) provides a tree-based
interface, transforming an XML document into a tree of nodes that can be
-traversed and modified. Python 2.0 includes a SAX2 interface and a stripped-
-down DOM interface as part of the :mod:`xml` package. Here we will give a brief
+traversed and modified. Python 2.0 includes a SAX2 interface and a stripped-down
+DOM interface as part of the :mod:`xml` package. Here we will give a brief
overview of these new interfaces; consult the Python documentation or the source
code for complete details. The Python XML SIG is also working on improved
documentation.
PEP 207: Rich Comparisons
=========================
-In earlier versions, Python's support for implementing comparisons on user-
-defined classes and extension types was quite simple. Classes could implement a
+In earlier versions, Python's support for implementing comparisons on user-defined
+classes and extension types was quite simple. Classes could implement a
:meth:`__cmp__` method that was given two instances of a class, and could only
return 0 if they were equal or +1 or -1 if they weren't; the method couldn't
raise an exception or return anything other than a Boolean value. Users of
distinguish the filenames ``FILE.PY`` and ``file.py``, even though they do store
the file's name in its original case (they're case-preserving, too).
-In Python 2.1, the :keyword:`import` statement will work to simulate case-
-sensitivity on case-insensitive platforms. Python will now search for the first
+In Python 2.1, the :keyword:`import` statement will work to simulate case-sensitivity
+on case-insensitive platforms. Python will now search for the first
case-sensitive match by default, raising an :exc:`ImportError` if no such file
-is found, so ``import file`` will not import a module named ``FILE.PY``. Case-
-insensitive matching can be requested by setting the :envvar:`PYTHONCASEOK`
+is found, so ``import file`` will not import a module named ``FILE.PY``.
+Case-insensitive matching can be requested by setting the :envvar:`PYTHONCASEOK`
environment variable before starting the Python interpreter.
.. ======================================================================
When using the Python interpreter interactively, the output of commands is
displayed using the built-in :func:`repr` function. In Python 2.1, the variable
:func:`sys.displayhook` can be set to a callable object which will be called
-instead of :func:`repr`. For example, you can set it to a special pretty-
-printing function::
+instead of :func:`repr`. For example, you can set it to a special
+pretty-printing function::
>>> # Create a recursive data structure
... L = [1,2,3]
* The new :mod:`hmac` module implements the HMAC algorithm described by
:rfc:`2104`. (Contributed by Gerhard Häring.)
-* Several functions that originally returned lengthy tuples now return pseudo-
- sequences that still behave like tuples but also have mnemonic attributes such
+* Several functions that originally returned lengthy tuples now return
+ pseudo-sequences that still behave like tuples but also have mnemonic attributes such
as memberst_mtime or :attr:`tm_year`. The enhanced functions include
:func:`stat`, :func:`fstat`, :func:`statvfs`, and :func:`fstatvfs` in the
:mod:`os` module, and :func:`localtime`, :func:`gmtime`, and :func:`strptime` in
The most significant change is the ability to build Python as a framework,
enabled by supplying the :option:`!--enable-framework` option to the configure
- script when compiling Python. According to Jack Jansen, "This installs a self-
- contained Python installation plus the OS X framework "glue" into
+ script when compiling Python. According to Jack Jansen, "This installs a
+ self-contained Python installation plus the OS X framework "glue" into
:file:`/Library/Frameworks/Python.framework` (or another location of choice).
For now there is little immediate added benefit to this (actually, there is the
disadvantage that you have to change your PATH to be able to find Python), but
It's also possible to take the symmetric difference of two sets. This is the
set of all elements in the union that aren't in the intersection. Another way
of putting it is that the symmetric difference contains all elements that are in
-exactly one set. Again, there's an alternative notation (``^``), and an in-
-place version with the ungainly name :meth:`symmetric_difference_update`. ::
+exactly one set. Again, there's an alternative notation (``^``), and an
+in-place version with the ungainly name :meth:`symmetric_difference_update`. ::
>>> S1 = sets.Set([1,2,3,4])
>>> S2 = sets.Set([3,4,5,6])
PEP 273: Importing Modules from ZIP Archives
============================================
-The new :mod:`zipimport` module adds support for importing modules from a ZIP-
-format archive. You don't need to import the module explicitly; it will be
+The new :mod:`zipimport` module adds support for importing modules from a
+ZIP-format archive. You don't need to import the module explicitly; it will be
automatically imported if a ZIP archive's filename is added to ``sys.path``.
For example:
==================================
The three major operating systems used today are Microsoft Windows, Apple's
-Macintosh OS, and the various Unix derivatives. A minor irritation of cross-
-platform work is that these three platforms all use different characters to
+Macintosh OS, and the various Unix derivatives. A minor irritation of
+cross-platform work is that these three platforms all use different characters to
mark the ends of lines in text files. Unix uses the linefeed (ASCII character
10), MacOS uses the carriage return (ASCII character 13), and Windows uses a
two-character sequence of a carriage return plus a newline.
>>> 1.1
1.1000000000000001
-The inaccuracy isn't always visible when you print the number because the FP-to-
-decimal-string conversion is provided by the C library, and most C libraries try
+The inaccuracy isn't always visible when you print the number because the
+FP-to-decimal-string conversion is provided by the C library, and most C libraries try
to produce sensible output. Even if it's not displayed, however, the inaccuracy
is still there and subsequent operations can magnify the error.
...
decimal.InvalidOperation: x ** (non-integer)
-You can combine :class:`Decimal` instances with integers, but not with floating-
-point numbers::
+You can combine :class:`Decimal` instances with integers, but not with
+floating-point numbers::
>>> a + 4
Decimal("39.72")
Raymond Hettinger, Aahz, and Tim Peters.
http://www.lahey.com/float.htm
- The article uses Fortran code to illustrate many of the problems that floating-
- point inaccuracy can cause.
+ The article uses Fortran code to illustrate many of the problems that
+ floating-point inaccuracy can cause.
http://speleotrove.com/decimal/
A description of a decimal-based representation. This representation is being
to the ``'C'`` locale. Often this was because the code was using the C
library's :c:func:`atof` function.
-Not setting the numeric locale caused trouble for extensions that used third-
-party C libraries, however, because they wouldn't have the correct locale set.
+Not setting the numeric locale caused trouble for extensions that used third-party
+C libraries, however, because they wouldn't have the correct locale set.
The motivating example was GTK+, whose user interface widgets weren't displaying
numbers in the current locale.
(Contributed by Raymond Hettinger.)
-* Encountering a failure while importing a module no longer leaves a partially-
- initialized module object in ``sys.modules``. The incomplete module object left
+* Encountering a failure while importing a module no longer leaves a partially-initialized
+ module object in ``sys.modules``. The incomplete module object left
behind would fool further imports of the same module into succeeding, leading to
confusing errors. (Fixed by Tim Peters.)
previous ones left off. (Implemented by Walter Dörwald.)
* There is a new :mod:`collections` module for various specialized collection
- datatypes. Currently it contains just one type, :class:`deque`, a double-
- ended queue that supports efficiently adding and removing elements from either
+ datatypes. Currently it contains just one type, :class:`deque`, a double-ended
+ queue that supports efficiently adding and removing elements from either
end::
>>> from collections import deque
intended as an aid to people developing the Python core. Providing
:option:`!--enable-profiling` to the :program:`configure` script will let you
profile the interpreter with :program:`gprof`, and providing the
- :option:`!--with-tsc` switch enables profiling using the Pentium's Time-Stamp-
- Counter register. Note that the :option:`!--with-tsc` switch is slightly
+ :option:`!--with-tsc` switch enables profiling using the Pentium's
+ Time-Stamp-Counter register. Note that the :option:`!--with-tsc` switch is slightly
misnamed, because the profiling feature also works on the PowerPC platform,
though that processor architecture doesn't call that register "the TSC
register". (Contributed by Jeremy Hylton.)
* The :mod:`tarfile` module now generates GNU-format tar files by default.
-* Encountering a failure while importing a module no longer leaves a partially-
- initialized module object in ``sys.modules``.
+* Encountering a failure while importing a module no longer leaves a
+ partially-initialized module object in ``sys.modules``.
* :const:`None` is now a constant; code that binds a new value to the name
``None`` is now a syntax error.
server_log = functools.partial(log, subsystem='server')
server_log('Unable to open socket')
-Here's another example, from a program that uses PyGTK. Here a context-
-sensitive pop-up menu is being constructed dynamically. The callback provided
+Here's another example, from a program that uses PyGTK. Here a context-sensitive
+pop-up menu is being constructed dynamically. The callback provided
for the menu option is a partially applied version of the :meth:`open_item`
method, where the first argument has been provided. ::
popup_menu.append( ("Open", open_func, 1) )
Another function in the :mod:`functools` module is the
-``update_wrapper(wrapper, wrapped)`` function that helps you write well-
-behaved decorators. :func:`update_wrapper` copies the name, module, and
+``update_wrapper(wrapper, wrapped)`` function that helps you write
+well-behaved decorators. :func:`update_wrapper` copies the name, module, and
docstring attribute to a wrapper function so that tracebacks inside the wrapped
function are easier to understand. For example, you might write::
added in a future version of Python.
In Python 2.5, you can switch :keyword:`import`'s behaviour to absolute imports
-using a ``from __future__ import absolute_import`` directive. This absolute-
-import behaviour will become the default in a future version (probably Python
+using a ``from __future__ import absolute_import`` directive. This absolute-import
+behaviour will become the default in a future version (probably Python
2.7). Once absolute imports are the default, ``import string`` will always
find the standard library's version. It's suggested that users should begin
using absolute imports as much as possible, so it's preferable to begin writing
... more processing code ...
After this statement has executed, the file object in *f* will have been
-automatically closed, even if the :keyword:`for` loop raised an exception part-
-way through the block.
+automatically closed, even if the :keyword:`for` loop raised an exception
+part-way through the block.
.. note::
You can also pack and unpack data to and from buffer objects directly using the
``pack_into(buffer, offset, v1, v2, ...)`` and ``unpack_from(buffer,
- offset)`` methods. This lets you store data directly into an array or a memory-
- mapped file.
+ offset)`` methods. This lets you store data directly into an array or a
+ memory-mapped file.
(:class:`Struct` objects were implemented by Bob Ippolito at the NeedForSpeed
sprint. Support for buffer objects was added by Martin Blais, also at the
The author would like to thank the following people for offering suggestions,
corrections and assistance with various drafts of this article: Georg Brandl,
-Nick Coghlan, Phillip J. Eby, Lars Gustäbel, Raymond Hettinger, Ralf W. Grosse-
-Kunstleve, Kent Johnson, Iain Lowe, Martin von Löwis, Fredrik Lundh, Andrew
+Nick Coghlan, Phillip J. Eby, Lars Gustäbel, Raymond Hettinger, Ralf W.
+Grosse-Kunstleve, Kent Johnson, Iain Lowe, Martin von Löwis, Fredrik Lundh, Andrew
McNamara, Skip Montanaro, Gustavo Niemeyer, Paul Prescod, James Pryor, Mike
Rovner, Scott Weikart, Barry Warsaw, Thomas Wouters.
... more processing code ...
After this statement has executed, the file object in *f* will have been
-automatically closed, even if the :keyword:`for` loop raised an exception part-
-way through the block.
+automatically closed, even if the :keyword:`for` loop raised an exception
+part-way through the block.
.. note::
removed in Python 3.6. (See :issue:`20438` for details.)
The :mod:`inspect` :func:`~inspect.getfullargspec`,
-:func:`~inspect.getargvalues`, :func:`~inspect.getcallargs`,
-:func:`~inspect.getargvalues`, :func:`~inspect.formatargspec`, and
-:func:`~inspect.formatargvalues` functions are deprecated in favor of
-the :func:`inspect.signature` API.
-(Contributed by Yury Selivanov in :issue:`20438`.)
+:func:`~inspect.getcallargs`, and :func:`~inspect.formatargspec` functions are
+deprecated in favor of the :func:`inspect.signature` API. (Contributed by Yury
+Selivanov in :issue:`20438`.)
+
+:func:`~inspect.getargvalues` and :func:`~inspect.formatargvalues` functions
+were inadvertently marked as deprecated with the release of Python 3.5.0.
Use of :const:`re.LOCALE` flag with str patterns or :const:`re.ASCII` is now
deprecated. (Contributed by Serhiy Storchaka in :issue:`22407`.)
What's New In Python 3.6
****************************
-:Release: |release|
-:Date: |today|
:Editors: Elvis Pranskevichus <elvis@magic.io>, Yury Selivanov <yury@magic.io>
.. Rules for maintenance:
* The :ref:`dict <typesmapping>` type has been reimplemented to use
a :ref:`more compact representation <whatsnew36-compactdict>`
- similar to the `PyPy dict implementation`_. This resulted in dictionaries
+ based on `a proposal by Raymond Hettinger
+ <https://mail.python.org/pipermail/python-dev/2012-December/123028.html>`_
+ and similar to the `PyPy dict implementation`_. This resulted in dictionaries
using 20% to 25% less memory when compared to Python 3.5.
* Customization of class creation has been simplified with the
:ref:`Local Time Disambiguation <whatsnew36-pep495>`.
* The :mod:`typing` module received a number of
- :ref:`improvements <whatsnew36-typing>` and is no longer provisional.
+ :ref:`improvements <whatsnew36-typing>`.
* The :mod:`tracemalloc` module has been significantly reworked
and is now used to provide better output for :exc:`ResourceWarning`
PEP 487: Descriptor Protocol Enhancements
-----------------------------------------
-:pep:`487` extends the descriptor protocol has to include the new optional
+:pep:`487` extends the descriptor protocol to include the new optional
:meth:`~object.__set_name__` method. Whenever a new class is defined, the new
method will be called on all descriptors included in the definition, providing
them with a reference to the class being defined and the name given to the
---------------------------------------------
The :ref:`dict <typesmapping>` type now uses a "compact" representation
-`pioneered by PyPy <https://morepypy.blogspot.com/2015/01/faster-more-memory-efficient-and-more.html>`_.
+based on `a proposal by Raymond Hettinger
+<https://mail.python.org/pipermail/python-dev/2012-December/123028.html>`_
+which was `first implemented by PyPy
+<https://morepypy.blogspot.com/2015/01/faster-more-memory-efficient-and-more.html>`_.
The memory usage of the new :func:`dict` is between 20% and 25% smaller
compared to Python 3.5.
(Contributed by Christian Heimes in :issue:`27744` with support from
Victor Stinner.)
+New Linux constants ``TCP_USER_TIMEOUT`` and ``TCP_CONGESTION`` were added.
+(Contributed by Omar Sandoval, issue:`26273`).
+
socketserver
------------
typing
------
-Starting with Python 3.6 the :mod:`typing` module is no longer provisional
-and its API is considered stable.
-
-Since the :mod:`typing` module was :term:`provisional <provisional api>`
-in Python 3.5, all changes introduced in Python 3.6 have also been
+Since the :mod:`typing` module is :term:`provisional <provisional api>`,
+all changes introduced in Python 3.6 have also been
backported to Python 3.5.x.
The :mod:`typing` module has a much improved support for generic type
* The ``--enable-optimizations`` configure flag has been added. Turning it on
will activate expensive optimizations like PGO.
- (Original patch by Alecsandru Patrascu of Intel in :issue:`26539`.)
+ (Original patch by Alecsandru Patrascu of Intel in :issue:`26359`.)
* The :term:`GIL <global interpreter lock>` must now be held when allocator
functions of :c:data:`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) and
# Grammar for Python
-# Note: Changing the grammar specified in this file will most likely
-# require corresponding changes in the parser module
-# (../Modules/parsermodule.c). If you can't make the changes to
-# that module yourself, please co-ordinate the required changes
-# with someone who can; ask around on python-dev for help. Fred
-# Drake <fdrake@acm.org> will probably be listening there.
-
# NOTE WELL: You should also follow all the steps listed at
# https://docs.python.org/devguide/grammar.html
o1*o2.
*/
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(PyObject *) PyNumber_MatrixMultiply(PyObject *o1, PyObject *o2);
/*
This is the equivalent of the Python expression: o1 @ o2.
*/
+#endif
PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
o1 *= o2.
*/
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(PyObject *) PyNumber_InPlaceMatrixMultiply(PyObject *o1, PyObject *o2);
/*
This is the equivalent of the Python expression: o1 @= o2.
*/
+#endif
PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1,
PyObject *o2);
PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t,
const char *, Py_ssize_t,
const char *);
+#ifndef Py_LIMITED_API
/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */
PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t,
const char *, Py_ssize_t,
const char *,
const char **);
+#endif
/* Macro, trading safety for speed */
#ifndef Py_LIMITED_API
/* replace the unicode encode error with backslash escapes (\x, \u and \U) */
PyAPI_FUNC(PyObject *) PyCodec_BackslashReplaceErrors(PyObject *exc);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
/* replace the unicode encode error with backslash escapes (\N, \x, \u and \U) */
PyAPI_FUNC(PyObject *) PyCodec_NameReplaceErrors(PyObject *exc);
+#endif
+#ifndef Py_LIMITED_API
PyAPI_DATA(const char *) Py_hexdigits;
+#endif
#ifdef __cplusplus
}
#ifndef Py_LIMITED_API
PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key,
Py_hash_t hash);
+PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key,
+ int (*predicate)(PyObject *value));
#endif
PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
PyAPI_FUNC(int) PyDict_Next(
Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys);
Py_ssize_t _PyDict_SizeOf(PyDictObject *);
PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *);
+PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *);
PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *);
#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL)
If non-NULL, this is different than the default encoding for strings
*/
PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
PyAPI_DATA(const char *) Py_FileSystemDefaultEncodeErrors;
+#endif
PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding;
/* Internal API
extern "C" {
#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(wchar_t *) Py_DecodeLocale(
const char *arg,
size_t *size);
PyAPI_FUNC(char*) Py_EncodeLocale(
const wchar_t *text,
size_t *error_pos);
+#endif
#ifndef Py_LIMITED_API
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyImportZip_Init(void);
-#endif /* !Py_LIMITED_API */
PyMODINIT_FUNC PyInit_imp(void);
+#endif /* !Py_LIMITED_API */
PyAPI_FUNC(long) PyImport_GetMagicNumber(void);
PyAPI_FUNC(const char *) PyImport_GetMagicTag(void);
PyAPI_FUNC(PyObject *) PyImport_ExecCodeModule(
const char *pathname, /* decoded from the filesystem encoding */
const char *cpathname /* decoded from the filesystem encoding */
);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleObject(
PyObject *name,
PyObject *co,
PyObject *pathname,
PyObject *cpathname
);
+#endif
PyAPI_FUNC(PyObject *) PyImport_GetModuleDict(void);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyImport_AddModuleObject(
PyObject *name
);
+#endif
PyAPI_FUNC(PyObject *) PyImport_AddModule(
const char *name /* UTF-8 encoded string */
);
PyObject *fromlist,
int level
);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevelObject(
PyObject *name,
PyObject *globals,
PyObject *fromlist,
int level
);
+#endif
#define PyImport_ImportModuleEx(n, g, l, f) \
PyImport_ImportModuleLevel(n, g, l, f, 0)
PyAPI_FUNC(PyObject *) PyImport_Import(PyObject *name);
PyAPI_FUNC(PyObject *) PyImport_ReloadModule(PyObject *m);
PyAPI_FUNC(void) PyImport_Cleanup(void);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(int) PyImport_ImportFrozenModuleObject(
PyObject *name
);
+#endif
PyAPI_FUNC(int) PyImport_ImportFrozenModule(
const char *name /* UTF-8 encoded string */
);
#endif
PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(char *mem, Py_ssize_t size,
int flags);
+#endif
#ifndef Py_LIMITED_API
PyAPI_FUNC(PyObject *) PyMemoryView_FromBuffer(Py_buffer *info);
#endif
#define PyArg_Parse _PyArg_Parse_SizeT
#define PyArg_ParseTuple _PyArg_ParseTuple_SizeT
#define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT
-#ifndef Py_LIMITED_API
#define PyArg_VaParse _PyArg_VaParse_SizeT
#define PyArg_VaParseTupleAndKeywords _PyArg_VaParseTupleAndKeywords_SizeT
-#endif /* !Py_LIMITED_API */
#define Py_BuildValue _Py_BuildValue_SizeT
#define Py_VaBuildValue _Py_VaBuildValue_SizeT
#else
PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...);
PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
const char *, char **, ...);
+PyAPI_FUNC(int) PyArg_VaParse(PyObject *, const char *, va_list);
+PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
+ const char *, char **, va_list);
+#endif
PyAPI_FUNC(int) PyArg_ValidateKeywordArguments(PyObject *);
PyAPI_FUNC(int) PyArg_UnpackTuple(PyObject *, const char *, Py_ssize_t, Py_ssize_t, ...);
PyAPI_FUNC(PyObject *) Py_BuildValue(const char *, ...);
PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);
-#endif
+
#ifndef Py_LIMITED_API
PyAPI_FUNC(int) _PyArg_NoKeywords(const char *funcname, PyObject *kw);
PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args);
-
-PyAPI_FUNC(int) PyArg_VaParse(PyObject *, const char *, va_list);
-PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
- const char *, char **, va_list);
#endif
PyAPI_FUNC(PyObject *) Py_VaBuildValue(const char *, va_list);
#define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type)
#define PyModule_CheckExact(op) (Py_TYPE(op) == &PyModule_Type)
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyModule_NewObject(
PyObject *name
);
+#endif
PyAPI_FUNC(PyObject *) PyModule_New(
const char *name /* UTF-8 encoded string */
);
PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyModule_GetNameObject(PyObject *);
+#endif
PyAPI_FUNC(const char *) PyModule_GetName(PyObject *);
PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *);
PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *);
PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject *, PyObject *, void *);
+#endif
PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject *);
PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *);
PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
the raw memory.
*/
PyAPI_FUNC(void *) PyObject_Malloc(size_t size);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(void *) PyObject_Calloc(size_t nelem, size_t elsize);
+#endif
PyAPI_FUNC(void *) PyObject_Realloc(void *ptr, size_t new_size);
PyAPI_FUNC(void) PyObject_Free(void *ptr);
PyAPI_DATA(PyTypeObject) PyODictItems_Type;
PyAPI_DATA(PyTypeObject) PyODictValues_Type;
-#endif /* Py_LIMITED_API */
-
#define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type)
#define PyODict_CheckExact(op) (Py_TYPE(op) == &PyODict_Type)
#define PyODict_SIZE(op) ((PyDictObject *)op)->ma_used
-#define PyODict_HasKey(od, key) (PyMapping_HasKey(PyObject *)od, key)
+
+#endif /* Py_LIMITED_API */
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(PyObject *) PyODict_New(void);
PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item);
#define PyODict_GetItemString(od, key) \
PyDict_GetItemString((PyObject *)od, key)
+#endif
+
#ifdef __cplusplus
}
#endif
extern "C" {
#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path);
+#endif
#ifdef __cplusplus
}
/*--start constants--*/
#define PY_MAJOR_VERSION 3
#define PY_MINOR_VERSION 6
-#define PY_MICRO_VERSION 0
+#define PY_MICRO_VERSION 1
#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL
#define PY_RELEASE_SERIAL 0
/* Version as a string */
-#define PY_VERSION "3.6.0"
+#define PY_VERSION "3.6.1"
/*--end constants--*/
/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
PyAPI_FUNC(void) PyErr_Clear(void);
PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);
PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **);
PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *);
+#endif
#if defined(__clang__) || \
(defined(__GNUC_MAJOR__) && \
PyAPI_DATA(PyObject *) PyExc_BaseException;
PyAPI_DATA(PyObject *) PyExc_Exception;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration;
+#endif
PyAPI_DATA(PyObject *) PyExc_StopIteration;
PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
PyAPI_DATA(PyObject *) PyExc_OSError;
PyAPI_DATA(PyObject *) PyExc_ImportError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError;
+#endif
PyAPI_DATA(PyObject *) PyExc_IndexError;
PyAPI_DATA(PyObject *) PyExc_KeyError;
PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
PyAPI_DATA(PyObject *) PyExc_NameError;
PyAPI_DATA(PyObject *) PyExc_OverflowError;
PyAPI_DATA(PyObject *) PyExc_RuntimeError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_DATA(PyObject *) PyExc_RecursionError;
+#endif
PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
PyAPI_DATA(PyObject *) PyExc_SyntaxError;
PyAPI_DATA(PyObject *) PyExc_IndentationError;
PyAPI_DATA(PyObject *) PyExc_ValueError;
PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_DATA(PyObject *) PyExc_BlockingIOError;
PyAPI_DATA(PyObject *) PyExc_BrokenPipeError;
PyAPI_DATA(PyObject *) PyExc_ChildProcessError;
PyAPI_DATA(PyObject *) PyExc_PermissionError;
PyAPI_DATA(PyObject *) PyExc_ProcessLookupError;
PyAPI_DATA(PyObject *) PyExc_TimeoutError;
+#endif
/* Compatibility aliases */
PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects(
PyObject *, PyObject *, PyObject *);
+#endif
PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(
PyObject *exc,
const char *filename /* decoded from the filesystem encoding */
PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
PyObject *,int, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects(
PyObject *,int, PyObject *, PyObject *);
+#endif
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
PyObject *exc,
int ierr,
PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
#endif /* MS_WINDOWS */
-PyAPI_FUNC(PyObject *) PyErr_SetExcWithArgsKwargs(PyObject *, PyObject *,
- PyObject *);
-
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *,
PyObject *, PyObject *);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *,
PyObject *);
+#endif
/* Export the old function so that the existing API remains available: */
PyAPI_FUNC(void) PyErr_BadInternalCall(void);
PyAPI_FUNC(const char *) Py_GetCompiler(void);
PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
#ifndef Py_LIMITED_API
-PyAPI_FUNC(const char *) _Py_hgidentifier(void);
-PyAPI_FUNC(const char *) _Py_hgversion(void);
+PyAPI_FUNC(const char *) _Py_gitidentifier(void);
+PyAPI_FUNC(const char *) _Py_gitversion(void);
#endif
/* Internal -- various one-time initializations */
*/
PyAPI_FUNC(void *) PyMem_Malloc(size_t size);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
+#endif
PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size);
PyAPI_FUNC(void) PyMem_Free(void *ptr);
* integral synonyms. Only define the ones we actually need.
*/
-// long long is required. Ensure HAVE_LONG_LONG is defined for compatibility.
+/* long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. */
#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG
+#define HAVE_LONG_LONG 1
#endif
#ifndef PY_LONG_LONG
#define PY_LONG_LONG long long
#endif
PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
int);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlagsFilename(const char *,
const char *,
int, int);
+#endif
PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
int, int);
PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject*) PyThread_GetInfo(void);
+#endif
/* Thread Local Storage (TLS) API */
PyAPI_FUNC(int) PyThread_create_key(void);
PyAPI_FUNC(int) PySlice_GetIndices(PyObject *r, Py_ssize_t length,
Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject *r, Py_ssize_t length,
- Py_ssize_t *start, Py_ssize_t *stop,
- Py_ssize_t *step, Py_ssize_t *slicelength);
+ Py_ssize_t *start, Py_ssize_t *stop,
+ Py_ssize_t *step, Py_ssize_t *slicelength);
+
+#if !defined(Py_LIMITED_API) || (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) || Py_LIMITED_API+0 >= 0x03060100
+#define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) ( \
+ PySlice_Unpack((slice), (start), (stop), (step)) < 0 ? \
+ ((*(slicelen) = 0), -1) : \
+ ((*(slicelen) = PySlice_AdjustIndices((length), (start), (stop), *(step))), \
+ 0))
+PyAPI_FUNC(int) PySlice_Unpack(PyObject *slice,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
+PyAPI_FUNC(Py_ssize_t) PySlice_AdjustIndices(Py_ssize_t length,
+ Py_ssize_t *start, Py_ssize_t *stop,
+ Py_ssize_t step);
+#endif
#ifdef __cplusplus
}
Py_ssize_t size);
#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject*) PyUnicode_Substring(
PyObject *str,
Py_ssize_t start,
Py_ssize_t end);
+#endif
#ifndef Py_LIMITED_API
/* Compute the maximum character of the substring unicode[start:end].
Py_ssize_t end);
#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
/* Copy the string into a UCS4 buffer including the null character if copy_null
is set. Return NULL and raise an exception on error. Raise a SystemError if
the buffer is smaller than the string. Return buffer on success.
* PyMem_Malloc; if this fails, NULL is returned with a memory error
exception set. */
PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4Copy(PyObject *unicode);
+#endif
/* Return a read-only pointer to the Unicode object's internal
Py_UNICODE buffer.
);
#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
/* Get the length of the Unicode object. */
PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength(
PyObject *unicode
);
+#endif
/* Get the number of Py_UNICODE units in the
string representation. */
PyObject *unicode /* Unicode object */
);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
/* Read a character from the string. */
PyAPI_FUNC(Py_UCS4) PyUnicode_ReadChar(
Py_ssize_t index,
Py_UCS4 character
);
+#endif
#ifndef Py_LIMITED_API
/* Get the maximum ordinal for a Unicode character. */
const char *errors /* error handling */
);
+#ifndef Py_LIMITED_API
/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape
chars. */
PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscape(
invalid escaped char in
string. */
);
+#endif
PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
PyObject *unicode /* Unicode object */
Py_ssize_t *consumed /* bytes consumed */
);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject*) PyUnicode_DecodeCodePageStateful(
int code_page, /* code page number */
const char *string, /* encoded string */
const char *errors, /* error handling */
Py_ssize_t *consumed /* bytes consumed */
);
+#endif
PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString(
PyObject *unicode /* Unicode object */
);
#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
PyAPI_FUNC(PyObject*) PyUnicode_EncodeCodePage(
int code_page, /* code page number */
PyObject *unicode, /* Unicode object */
const char *errors /* error handling */
);
+#endif
#endif /* MS_WINDOWS */
/* --- Locale encoding --------------------------------------------------- */
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
/* Decode a string from the current locale encoding. The decoder is strict if
*surrogateescape* is equal to zero, otherwise it uses the 'surrogateescape'
error handler (PEP 383) to escape undecodable bytes. If a byte sequence can
PyObject *unicode,
const char *errors
);
+#endif
/* --- File system encoding ---------------------------------------------- */
int direction /* Find direction: +1 forward, -1 backward */
);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
/* Like PyUnicode_Find, but search for single character only. */
PyAPI_FUNC(Py_ssize_t) PyUnicode_FindChar(
PyObject *str,
Py_ssize_t end,
int direction
);
+#endif
/* Count the number of occurrences of substr in str[start:end]. */
- Py_True or Py_False for successful comparisons
- Py_NotImplemented in case the type combination is unknown
- Note that Py_EQ and Py_NE comparisons can cause a UnicodeWarning in
- case the conversion of the arguments to Unicode fails with a
- UnicodeDecodeError.
-
Possible values for op:
Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE
const char *format, /* ASCII-encoded string */
...);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
/* Emit a ResourceWarning warning */
PyAPI_FUNC(int) PyErr_ResourceWarning(
PyObject *source,
Py_ssize_t stack_level,
const char *format, /* ASCII-encoded string */
...);
+#endif
#ifndef Py_LIMITED_API
PyAPI_FUNC(int) PyErr_WarnExplicitObject(
PyObject *category,
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-2011, 2012, 2013, 2014, 2015, 2016 Python Software Foundation; All Rights
+2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights
Reserved" are retained in Python alone or in any derivative version prepared by
Licensee.
try:
UnsupportedOperation = io.UnsupportedOperation
except AttributeError:
- class UnsupportedOperation(ValueError, OSError):
+ class UnsupportedOperation(OSError, ValueError):
pass
# _ssnd_chunk -- instantiation of a chunk class for the SSND chunk
# _framesize -- size of one frame in the file
+ _file = None # Set here since __del__ checks it
+
def initfp(self, file):
self._version = 0
self._convert = None
def __init__(self, f):
if isinstance(f, str):
- f = builtins.open(f, 'rb')
- # else, assume it is an open file object already
- self.initfp(f)
+ file_object = builtins.open(f, 'rb')
+ try:
+ self.initfp(file_object)
+ except:
+ file_object.close()
+ raise
+ else:
+ # assume it is an open file object already
+ self.initfp(f)
def __enter__(self):
return self
# _datalength -- the size of the audio samples written to the header
# _datawritten -- the size of the audio samples actually written
+ _file = None # Set here since __del__ checks it
+
def __init__(self, f):
if isinstance(f, str):
- filename = f
- f = builtins.open(f, 'wb')
- else:
- # else, assume it is an open file object already
- filename = '???'
- self.initfp(f)
- if filename[-5:] == '.aiff':
- self._aifc = 0
+ file_object = builtins.open(f, 'wb')
+ try:
+ self.initfp(file_object)
+ except:
+ file_object.close()
+ raise
+
+ # treat .aiff file extensions as non-compressed audio
+ if f.endswith('.aiff'):
+ self._aifc = 0
else:
- self._aifc = 1
+ # assume it is an open file object already
+ self.initfp(f)
def initfp(self, file):
self._file = file
self._root_section = self._Section(self, None)
self._current_section = self._root_section
- self._whitespace_matcher = _re.compile(r'\s+')
+ self._whitespace_matcher = _re.compile(r'\s+', _re.ASCII)
self._long_break_matcher = _re.compile(r'\n\n\n+')
# ===============================
import functools
import inspect
+import os
import reprlib
import socket
import subprocess
# A TLS for the running event loop, used by _get_running_loop.
class _RunningLoop(threading.local):
_loop = None
+ _pid = None
+
+
_running_loop = _RunningLoop()
This is a low-level function intended to be used by event loops.
This function is thread-specific.
"""
- return _running_loop._loop
+ running_loop = _running_loop._loop
+ if running_loop is not None and _running_loop._pid == os.getpid():
+ return running_loop
def _set_running_loop(loop):
This is a low-level function intended to be used by event loops.
This function is thread-specific.
"""
+ _running_loop._pid = os.getpid()
_running_loop._loop = loop
self._limit = limit
self.stdin = self.stdout = self.stderr = None
self._transport = None
+ self._process_exited = False
+ self._pipe_fds = []
def __repr__(self):
info = [self.__class__.__name__]
self.stdout = streams.StreamReader(limit=self._limit,
loop=self._loop)
self.stdout.set_transport(stdout_transport)
+ self._pipe_fds.append(1)
stderr_transport = transport.get_pipe_transport(2)
if stderr_transport is not None:
self.stderr = streams.StreamReader(limit=self._limit,
loop=self._loop)
self.stderr.set_transport(stderr_transport)
+ self._pipe_fds.append(2)
stdin_transport = transport.get_pipe_transport(0)
if stdin_transport is not None:
else:
reader.set_exception(exc)
+ if fd in self._pipe_fds:
+ self._pipe_fds.remove(fd)
+ self._maybe_close_transport()
+
def process_exited(self):
- self._transport.close()
- self._transport = None
+ self._process_exited = True
+ self._maybe_close_transport()
+
+ def _maybe_close_transport(self):
+ if len(self._pipe_fds) == 0 and self._process_exited:
+ self._transport.close()
+ self._transport = None
class Process:
"""
warnings.warn("asyncio.async() function is deprecated, use ensure_future()",
- DeprecationWarning)
+ DeprecationWarning,
+ stacklevel=2)
return ensure_future(coro_or_future, loop=loop)
self.set_event_loop(loop)
return loop
+ def unpatch_get_running_loop(self):
+ events._get_running_loop = self._get_running_loop
+
def setUp(self):
self._get_running_loop = events._get_running_loop
events._get_running_loop = lambda: None
def tearDown(self):
- events._get_running_loop = self._get_running_loop
+ self.unpatch_get_running_loop()
events.set_event_loop(None)
def encodestring(s):
"""Legacy alias of encodebytes()."""
import warnings
- warnings.warn("encodestring() is a deprecated alias, use encodebytes()",
+ warnings.warn("encodestring() is a deprecated alias since 3.1, "
+ "use encodebytes()",
DeprecationWarning, 2)
return encodebytes(s)
def decodestring(s):
"""Legacy alias of decodebytes()."""
import warnings
- warnings.warn("decodestring() is a deprecated alias, use decodebytes()",
+ warnings.warn("decodestring() is a deprecated alias since Python 3.1, "
+ "use decodebytes()",
DeprecationWarning, 2)
return decodebytes(s)
link = self.__map[key]
link_prev = link.prev
link_next = link.next
+ soft_link = link_next.prev
link_prev.next = link_next
link_next.prev = link_prev
root = self.__root
last = root.prev
link.prev = last
link.next = root
- last.next = root.prev = link
+ root.prev = soft_link
+ last.next = link
else:
first = root.next
link.prev = root
link.next = first
- root.next = first.prev = link
+ first.prev = soft_link
+ root.next = link
def __sizeof__(self):
sizeof = _sys.getsizeof
import functools
import io
import itertools
+import os
import re
import sys
import warnings
Return list of successfully read files.
"""
- if isinstance(filenames, str):
+ if isinstance(filenames, (str, os.PathLike)):
filenames = [filenames]
read_ok = []
for filename in filenames:
self._read(fp, filename)
except OSError:
continue
+ if isinstance(filename, os.PathLike):
+ filename = os.fspath(filename)
read_ok.append(filename)
return read_ok
# raised inside the "with" statement from being suppressed.
return exc is not value
except RuntimeError as exc:
- # Don't re-raise the passed in exception. (issue27112)
+ # Don't re-raise the passed in exception. (issue27122)
if exc is value:
return False
# Likewise, avoid suppressing if a StopIteration exception
"""
_func_flags_ = _FUNCFLAG_CDECL
_func_restype_ = c_int
+ # default values for repr
+ _name = '<uninitialized>'
+ _handle = 0
+ _FuncPtr = None
def __init__(self, name, mode=DEFAULT_MODE, handle=None,
use_errno=False,
def test_callback_large_struct(self):
class Check: pass
+ # This should mirror the structure in Modules/_ctypes/_ctypes_test.c
class X(Structure):
_fields_ = [
('first', c_ulong),
check.first = s.first
check.second = s.second
check.third = s.third
+ # See issue #29565.
+ # The structure should be passed by value, so
+ # any changes to it should not be reflected in
+ # the value passed
+ s.first = s.second = s.third = 0x0badf00d
check = Check()
s = X()
self.assertEqual(check.first, 0xdeadbeef)
self.assertEqual(check.second, 0xcafebabe)
self.assertEqual(check.third, 0x0bad1dea)
+ # See issue #29565.
+ # Ensure that the original struct is unchanged.
+ self.assertEqual(s.first, check.first)
+ self.assertEqual(s.second, check.second)
+ self.assertEqual(s.third, check.third)
################################################################
from ctypes.test import need_symbol
from struct import calcsize
import _testcapi
+import _ctypes_test
class SubclassesTest(unittest.TestCase):
def test_subclass(self):
(1, 0, 0, 0, 0, 0))
self.assertRaises(TypeError, lambda: Z(1, 2, 3, 4, 5, 6, 7))
+ def test_pass_by_value(self):
+ # This should mirror the structure in Modules/_ctypes/_ctypes_test.c
+ class X(Structure):
+ _fields_ = [
+ ('first', c_ulong),
+ ('second', c_ulong),
+ ('third', c_ulong),
+ ]
+
+ s = X()
+ s.first = 0xdeadbeef
+ s.second = 0xcafebabe
+ s.third = 0x0bad1dea
+ dll = CDLL(_ctypes_test.__file__)
+ func = dll._testfunc_large_struct_update_value
+ func.argtypes = (X,)
+ func.restype = None
+ func(s)
+ self.assertEqual(s.first, 0xdeadbeef)
+ self.assertEqual(s.second, 0xcafebabe)
+ self.assertEqual(s.third, 0x0bad1dea)
+
class PointerMemberTestCase(unittest.TestCase):
def test(self):
def isalnum(c): return isalpha(c) or isdigit(c)
def isalpha(c): return isupper(c) or islower(c)
-def isascii(c): return _ctoi(c) <= 127 # ?
+def isascii(c): return 0 <= _ctoi(c) <= 127 # ?
def isblank(c): return _ctoi(c) in (9, 32)
-def iscntrl(c): return _ctoi(c) <= 31 or _ctoi(c) == 127
-def isdigit(c): return _ctoi(c) >= 48 and _ctoi(c) <= 57
-def isgraph(c): return _ctoi(c) >= 33 and _ctoi(c) <= 126
-def islower(c): return _ctoi(c) >= 97 and _ctoi(c) <= 122
-def isprint(c): return _ctoi(c) >= 32 and _ctoi(c) <= 126
+def iscntrl(c): return 0 <= _ctoi(c) <= 31 or _ctoi(c) == 127
+def isdigit(c): return 48 <= _ctoi(c) <= 57
+def isgraph(c): return 33 <= _ctoi(c) <= 126
+def islower(c): return 97 <= _ctoi(c) <= 122
+def isprint(c): return 32 <= _ctoi(c) <= 126
def ispunct(c): return isgraph(c) and not isalnum(c)
def isspace(c): return _ctoi(c) in (9, 10, 11, 12, 13, 32)
-def isupper(c): return _ctoi(c) >= 65 and _ctoi(c) <= 90
+def isupper(c): return 65 <= _ctoi(c) <= 90
def isxdigit(c): return isdigit(c) or \
- (_ctoi(c) >= 65 and _ctoi(c) <= 70) or (_ctoi(c) >= 97 and _ctoi(c) <= 102)
-def isctrl(c): return _ctoi(c) < 32
+ (65 <= _ctoi(c) <= 70) or (97 <= _ctoi(c) <= 102)
+def isctrl(c): return 0 <= _ctoi(c) < 32
def ismeta(c): return _ctoi(c) > 127
def ascii(c):
def __init__(self, win, insert_mode=False):
self.win = win
self.insert_mode = insert_mode
- (self.maxy, self.maxx) = win.getmaxyx()
- self.maxy = self.maxy - 1
- self.maxx = self.maxx - 1
+ self._update_max_yx()
self.stripspaces = 1
self.lastcmd = None
win.keypad(1)
+ def _update_max_yx(self):
+ maxy, maxx = self.win.getmaxyx()
+ self.maxy = maxy - 1
+ self.maxx = maxx - 1
+
def _end_of_line(self, y):
"""Go to the location of the first blank on the given line,
returning the index of the last non-blank character."""
+ self._update_max_yx()
last = self.maxx
while True:
if curses.ascii.ascii(self.win.inch(y, last)) != curses.ascii.SP:
return last
def _insert_printable_char(self, ch):
+ self._update_max_yx()
(y, x) = self.win.getyx()
- if y < self.maxy or x < self.maxx:
+ backyx = None
+ while y < self.maxy or x < self.maxx:
if self.insert_mode:
oldch = self.win.inch()
# The try-catch ignores the error we trigger from some curses
self.win.addch(ch)
except curses.error:
pass
- if self.insert_mode:
- (backy, backx) = self.win.getyx()
- if curses.ascii.isprint(oldch):
- self._insert_printable_char(oldch)
- self.win.move(backy, backx)
+ if not self.insert_mode or not curses.ascii.isprint(oldch):
+ break
+ ch = oldch
+ (y, x) = self.win.getyx()
+ # Remember where to put the cursor back since we are in insert_mode
+ if backyx is None:
+ backyx = y, x
+
+ if backyx is not None:
+ self.win.move(*backyx)
def do_command(self, ch):
"Process a single editing command."
+ self._update_max_yx()
(y, x) = self.win.getyx()
self.lastcmd = ch
if curses.ascii.isprint(ch):
def gather(self):
"Collect and return the contents of the window."
result = ""
+ self._update_max_yx()
for y in range(self.maxy+1):
self.win.move(y, 0)
stop = self._end_of_line(y)
hour, minute (required)
second, microsecond (default to zero)
tzinfo (default to None)
- fold (keyword only, default to True)
+ fold (keyword only, default to zero)
"""
if isinstance(hour, bytes) and len(hour) == 6 and hour[0]&0x7F < 24:
# Pickle support
try:
f = _io.open(self._dirfile, 'r', encoding="Latin-1")
except OSError:
- pass
+ self._modified = not self._readonly
else:
+ self._modified = False
with f:
for line in f:
line = line.rstrip()
# CAUTION: It's vital that _commit() succeed, and _commit() can
# be called from __del__(). Therefore we must never reference a
# global in this routine.
- if self._index is None:
+ if self._index is None or not self._modified:
return # nothing to do
try:
elif not isinstance(val, (bytes, bytearray)):
raise TypeError("values must be bytes or strings")
self._verify_open()
+ self._modified = True
if key not in self._index:
self._addkey(key, self._addval(val))
else:
if isinstance(key, str):
key = key.encode('utf-8')
self._verify_open()
+ self._modified = True
# The blocks used by the associated value are lost.
del self._index[key]
# XXX It's unclear why we do a _commit() here (the code always
@unittest.skipIf(find_executable('rpmbuild') is None,
'the rpmbuild command is not found')
def test_no_optimize_flag(self):
- # let's create a package that brakes bdist_rpm
+ # let's create a package that breaks bdist_rpm
tmp_dir = self.mkdtemp()
os.environ['HOME'] = tmp_dir # to confine dir '.rpmdb' creation
pkg_dir = os.path.join(tmp_dir, 'foo')
import sys
from types import MappingProxyType, DynamicClassAttribute
from functools import reduce
-from operator import or_ as _or_, and_ as _and_, xor, neg
+from operator import or_ as _or_
# try _collections first to reduce startup cost
try:
pseudo_member = object.__new__(cls)
pseudo_member._name_ = None
pseudo_member._value_ = value
- cls._value2member_map_[value] = pseudo_member
+ # use setdefault in case another thread already created a composite
+ # with this value
+ pseudo_member = cls._value2member_map_.setdefault(value, pseudo_member)
return pseudo_member
def __contains__(self, other):
pseudo_member = int.__new__(cls, value)
pseudo_member._name_ = None
pseudo_member._value_ = value
- cls._value2member_map_[value] = pseudo_member
+ # use setdefault in case another thread already created a composite
+ # with this value
+ pseudo_member = cls._value2member_map_.setdefault(value, pseudo_member)
return pseudo_member
def __or__(self, other):
# _decompose is only called if the value is not named
not_covered = value
negative = value < 0
+ # issue29167: wrap accesses to _value2member_map_ in a list to avoid race
+ # conditions between iterating over it and having more psuedo-
+ # members added to it
if negative:
# only check for named flags
flags_to_check = [
(m, v)
- for v, m in flag._value2member_map_.items()
+ for v, m in list(flag._value2member_map_.items())
if m.name is not None
]
else:
# check for named flags and powers-of-two flags
flags_to_check = [
(m, v)
- for v, m in flag._value2member_map_.items()
+ for v, m in list(flag._value2member_map_.items())
if m.name is not None or _power_of_two(v)
]
members = []
def _make_key(args, kwds, typed,
kwd_mark = (object(),),
fasttypes = {int, str, frozenset, type(None)},
- sorted=sorted, tuple=tuple, type=type, len=len):
+ tuple=tuple, type=type, len=len):
"""Make a cache key from optionally typed positional and keyword arguments
The key is constructed in a way that is flat as possible rather than
"""
key = args
if kwds:
- sorted_items = sorted(kwds.items())
key += kwd_mark
- for item in sorted_items:
+ for item in kwds.items():
key += item
if typed:
key += tuple(type(v) for v in args)
if kwds:
- key += tuple(type(v) for k, v in sorted_items)
+ key += tuple(type(v) for v in kwds.values())
elif len(key) == 1 and type(key[0]) in fasttypes:
return key[0]
return _HashedSeq(key)
hits = misses = 0
full = False
cache_get = cache.get # bound method to lookup a key or return None
+ cache_len = cache.__len__ # get cache size without calling len()
lock = RLock() # because linkedlist updates aren't threadsafe
root = [] # root of the circular doubly linked list
root[:] = [root, root, None, None] # initialize by pointing to self
last = root[PREV]
link = [last, root, key, result]
last[NEXT] = root[PREV] = cache[key] = link
- full = (len(cache) >= maxsize)
+ # Use the cache_len bound method instead of the len() function
+ # which could potentially be wrapped in an lru_cache itself.
+ full = (cache_len() >= maxsize)
misses += 1
return result
def cache_info():
"""Report cache statistics"""
with lock:
- return _CacheInfo(hits, misses, maxsize, len(cache))
+ return _CacheInfo(hits, misses, maxsize, cache_len())
def cache_clear():
"""Clear the cache and cache statistics"""
echoing of the password contents while reading.
On Windows, the msvcrt module will be used.
-On the Mac EasyDialogs.AskPassword is used, if available.
"""
# 1st 'file' colorized normal, 2nd as builtin, 3rd as string
builtin = r"([^.'\"\\#]\b|^)" + any("BUILTIN", builtinlist) + r"\b"
comment = any("COMMENT", [r"#[^\n]*"])
- stringprefix = r"(\br|u|ur|R|U|UR|Ur|uR|b|B|br|Br|bR|BR|rb|rB|Rb|RB)?"
+ stringprefix = r"(?i:\br|u|f|fr|rf|b|br|rb)?"
sqstring = stringprefix + r"'[^'\\\n]*(\\.[^'\\\n]*)*'?"
dqstring = stringprefix + r'"[^"\\\n]*(\\.[^"\\\n]*)*"?'
sq3string = stringprefix + r"'''[^'\\]*((\\.|'(?!''))[^'\\]*)*(''')?"
top = Toplevel(parent)
top.title("Test ColorDelegator")
x, y = map(int, parent.geometry().split('+')[1:])
- top.geometry("200x100+%d+%d" % (x + 250, y + 175))
- source = "if somename: x = 'abc' # comment\nprint\n"
+ top.geometry("700x250+%d+%d" % (x + 20, y + 175))
+ source = ("# Following has syntax errors\n"
+ "if True: then int 1\nelif False: print 0\nelse: float(None)\n"
+ "if iF + If + IF: 'keywork matching must respect case'\n"
+ "# All valid prefixes for unicode and byte strings should be colored\n"
+ "'x', '''x''', \"x\", \"\"\"x\"\"\"\n"
+ "r'x', u'x', R'x', U'x', f'x', F'x', ur'is invalid'\n"
+ "fr'x', Fr'x', fR'x', FR'x', rf'x', rF'x', Rf'x', RF'x'\n"
+ "b'x',B'x', br'x',Br'x',bR'x',BR'x', rb'x'.rB'x',Rb'x',RB'x'\n")
text = Text(top, background="white")
text.pack(expand=1, fill="both")
text.insert("insert", source)
<div class="section" id="idle">
<span id="id1"></span><h1>25.5. IDLE<a class="headerlink" href="#idle" title="Permalink to this headline">¶</a></h1>
-<p><strong>Source code:</strong> <a class="reference external" href="https://hg.python.org/cpython/file/3.5/Lib/idlelib/">Lib/idlelib/</a></p>
+<p><strong>Source code:</strong> <a class="reference external" href="https://github.com/python/cpython/tree/3.5/Lib/idlelib">Lib/idlelib/</a></p>
<hr class="docutils" id="index-0" />
<p>IDLE is Python’s Integrated Development and Learning Environment.</p>
<p>IDLE has the following features:</p>
except ImportError:
print("** IDLE can't import Tkinter.\n"
"Your Python may not be configured for Tk. **", file=sys.__stderr__)
- sys.exit(1)
+ raise SystemExit(1)
import tkinter.messagebox as tkMessageBox
if TkVersion < 8.5:
root = Tk() # otherwise create root in main
root.withdraw()
tkMessageBox.showerror("Idle Cannot Start",
- "Idle requires tcl/tk 8.5+, not $s." % TkVersion,
+ "Idle requires tcl/tk 8.5+, not %s." % TkVersion,
parent=root)
- sys.exit(1)
+ raise SystemExit(1)
from code import InteractiveInterpreter
import getopt
self.literal = _Authenticator(authobject).process
typ, dat = self._simple_command('AUTHENTICATE', mech)
if typ != 'OK':
- raise self.error(dat[-1])
+ raise self.error(dat[-1].decode('utf-8', 'replace'))
self.state = 'AUTH'
return typ, dat
_setup(_bootstrap_module)
supported_loaders = _get_supported_file_loaders()
sys.path_hooks.extend([FileFinder.path_hook(*supported_loaders)])
- if _os.__name__ == 'nt':
- sys.meta_path.append(WindowsRegistryFinder)
sys.meta_path.append(PathFinder)
except OSError:
lines = index = None
else:
- start = max(start, 1)
start = max(0, min(start, len(lines) - context))
lines = lines[start:start+context]
index = lineno - 1 - start
Otherwise, the string "Level %s" % level is returned.
"""
- # See Issues #22386 and #27937 for why it's this way
- return (_levelToName.get(level) or _nameToLevel.get(level) or
- "Level %s" % level)
+ # See Issues #22386, #27937 and #29220 for why it's this way
+ result = _levelToName.get(level)
+ if result is not None:
+ return result
+ result = _nameToLevel.get(level)
+ if result is not None:
+ return result
+ return "Level %s" % level
def addLevelName(level, levelName):
"""
# final position in order to prevent race conditions with changes
# from other programs
try:
- if hasattr(os, 'link'):
+ try:
os.link(tmp_file.name, dest)
- os.remove(tmp_file.name)
- else:
+ except (AttributeError, PermissionError):
os.rename(tmp_file.name, dest)
+ else:
+ os.remove(tmp_file.name)
except OSError as e:
os.remove(tmp_file.name)
if e.errno == errno.EEXIST:
for key in self.iterkeys():
if key - 1 != prev:
changes.append((key, prev + 1))
- if hasattr(os, 'link'):
+ try:
os.link(os.path.join(self._path, str(key)),
os.path.join(self._path, str(prev + 1)))
- os.unlink(os.path.join(self._path, str(key)))
- else:
+ except (AttributeError, PermissionError):
os.rename(os.path.join(self._path, str(key)),
os.path.join(self._path, str(prev + 1)))
+ else:
+ os.unlink(os.path.join(self._path, str(key)))
prev += 1
self._next_key = prev + 1
if len(changes) == 0:
else:
raise
try:
- if hasattr(os, 'link'):
+ try:
os.link(pre_lock.name, f.name + '.lock')
dotlock_done = True
- os.unlink(pre_lock.name)
- else:
+ except (AttributeError, PermissionError):
os.rename(pre_lock.name, f.name + '.lock')
dotlock_done = True
+ else:
+ os.unlink(pre_lock.name)
except FileExistsError:
os.remove(pre_lock.name)
raise ExternalClashError('dot lock unavailable: %s' %
def get_start_method(self, allow_none=False):
return self._name
- def set_start_method(self, method=None):
+ def set_start_method(self, method, force=False):
raise ValueError('cannot set start method of concrete context')
@property
process.ORIGINAL_DIR = data['orig_dir']
if 'start_method' in data:
- set_start_method(data['start_method'])
+ set_start_method(data['start_method'], force=True)
if 'init_main_from_name' in data:
_fixup_main_from_name(data['init_main_from_name'])
s = self._ext_to_normal(_getfinalpathname(s))
except FileNotFoundError:
previous_s = s
- s = os.path.abspath(os.path.join(s, os.pardir))
+ s = os.path.dirname(s)
+ if previous_s == s:
+ return path
else:
if previous_s is None:
return s
if not exist_ok or not self.is_dir():
raise
except OSError as e:
- if e.errno != ENOENT:
+ if e.errno != ENOENT or self.parent == self:
raise
self.parent.mkdir(parents=True)
self._accessor.mkdir(self, mode)
"""
-__version__ = '1.0.7'
+__version__ = '1.0.8'
import collections
import sys, os, re, subprocess
elif buildtime:
builddate = builddate + ' ' + buildtime
- if hasattr(sys, '_mercurial'):
+ if hasattr(sys, '_git'):
+ _, branch, revision = sys._git
+ elif hasattr(sys, '_mercurial'):
_, branch, revision = sys._mercurial
elif hasattr(sys, 'subversion'):
# sys.subversion was added in Python 2.5
printed.
The sort_stats() method now processes some additional options (i.e., in
- addition to the old -1, 0, 1, or 2). It takes an arbitrary number of
- quoted strings to select the sort order. For example sort_stats('time',
- 'name') sorts on the major key of 'internal function time', and on the
- minor key of 'the name of the function'. Look at the two tables in
- sort_stats() and get_sort_arg_defs(self) for more examples.
+ addition to the old -1, 0, 1, or 2 that are respectively interpreted as
+ 'stdname', 'calls', 'time', and 'cumulative'). It takes an arbitrary number
+ of quoted strings to select the sort order.
+
+ For example sort_stats('time', 'name') sorts on the major key of 'internal
+ function time', and on the minor key of 'the name of the function'. Look at
+ the two tables in sort_stats() and get_sort_arg_defs(self) for more
+ examples.
All methods return self, so you can string together commands like:
Stats('foo', 'goo').strip_dirs().sort_stats('calls').\
# -*- coding: utf-8 -*-
-# Autogenerated by Sphinx on Fri Dec 16 16:33:16 2016
-topics = {'assert': '\n'
- 'The "assert" statement\n'
+# Autogenerated by Sphinx on Sat Mar 4 12:14:44 2017
+topics = {'assert': 'The "assert" statement\n'
'**********************\n'
'\n'
'Assert statements are a convenient way to insert debugging '
'Assignments to "__debug__" are illegal. The value for the '
'built-in\n'
'variable is determined when the interpreter starts.\n',
- 'assignment': '\n'
- 'Assignment statements\n'
+ 'assignment': 'Assignment statements\n'
'*********************\n'
'\n'
'Assignment statements are used to (re)bind names to values and '
'See also: **PEP 526** - Variable and attribute annotation '
'syntax\n'
' **PEP 484** - Type hints\n',
- 'atom-identifiers': '\n'
- 'Identifiers (Names)\n'
+ 'atom-identifiers': 'Identifiers (Names)\n'
'*******************\n'
'\n'
'An identifier occurring as an atom is a name. See '
'happen. If the class name consists only of underscores, '
'no\n'
'transformation is done.\n',
- 'atom-literals': '\n'
- 'Literals\n'
+ 'atom-literals': 'Literals\n'
'********\n'
'\n'
'Python supports string and bytes literals and various '
'may obtain\n'
'the same object or a different object with the same '
'value.\n',
- 'attribute-access': '\n'
- 'Customizing attribute access\n'
+ 'attribute-access': 'Customizing attribute access\n'
'****************************\n'
'\n'
'The following methods can be defined to customize the '
'* *__class__* assignment works only if both classes have '
'the same\n'
' *__slots__*.\n',
- 'attribute-references': '\n'
- 'Attribute references\n'
+ 'attribute-references': 'Attribute references\n'
'********************\n'
'\n'
'An attribute reference is a primary followed by a '
'determined by the object. Multiple evaluations of '
'the same attribute\n'
'reference may yield different objects.\n',
- 'augassign': '\n'
- 'Augmented assignment statements\n'
+ 'augassign': 'Augmented assignment statements\n'
'*******************************\n'
'\n'
'Augmented assignment is the combination, in a single statement, '
'about\n'
'class and instance attributes applies as for regular '
'assignments.\n',
- 'binary': '\n'
- 'Binary arithmetic operations\n'
+ 'binary': 'Binary arithmetic operations\n'
'****************************\n'
'\n'
'The binary arithmetic operations have the conventional priority\n'
'The "-" (subtraction) operator yields the difference of its '
'arguments.\n'
'The numeric arguments are first converted to a common type.\n',
- 'bitwise': '\n'
- 'Binary bitwise operations\n'
+ 'bitwise': 'Binary bitwise operations\n'
'*************************\n'
'\n'
'Each of the three bitwise operations has a different priority '
'The "|" operator yields the bitwise (inclusive) OR of its '
'arguments,\n'
'which must be integers.\n',
- 'bltin-code-objects': '\n'
- 'Code Objects\n'
+ 'bltin-code-objects': 'Code Objects\n'
'************\n'
'\n'
'Code objects are used by the implementation to '
'\n'
'See The standard type hierarchy for more '
'information.\n',
- 'bltin-ellipsis-object': '\n'
- 'The Ellipsis Object\n'
+ 'bltin-ellipsis-object': 'The Ellipsis Object\n'
'*******************\n'
'\n'
'This object is commonly used by slicing (see '
'"Ellipsis" singleton.\n'
'\n'
'It is written as "Ellipsis" or "...".\n',
- 'bltin-null-object': '\n'
- 'The Null Object\n'
+ 'bltin-null-object': 'The Null Object\n'
'***************\n'
'\n'
"This object is returned by functions that don't "
'same singleton.\n'
'\n'
'It is written as "None".\n',
- 'bltin-type-objects': '\n'
- 'Type Objects\n'
+ 'bltin-type-objects': 'Type Objects\n'
'************\n'
'\n'
'Type objects represent the various object types. An '
'all standard built-in types.\n'
'\n'
'Types are written like this: "<class \'int\'>".\n',
- 'booleans': '\n'
- 'Boolean operations\n'
+ 'booleans': 'Boolean operations\n'
'******************\n'
'\n'
' or_test ::= and_test | or_test "or" and_test\n'
'its\n'
'argument (for example, "not \'foo\'" produces "False" rather '
'than "\'\'".)\n',
- 'break': '\n'
- 'The "break" statement\n'
+ 'break': 'The "break" statement\n'
'*********************\n'
'\n'
' break_stmt ::= "break"\n'
'clause, that "finally" clause is executed before really leaving '
'the\n'
'loop.\n',
- 'callable-types': '\n'
- 'Emulating callable objects\n'
+ 'callable-types': 'Emulating callable objects\n'
'**************************\n'
'\n'
'object.__call__(self[, args...])\n'
'this method\n'
' is defined, "x(arg1, arg2, ...)" is a shorthand for\n'
' "x.__call__(arg1, arg2, ...)".\n',
- 'calls': '\n'
- 'Calls\n'
+ 'calls': 'Calls\n'
'*****\n'
'\n'
'A call calls a callable object (e.g., a *function*) with a '
' ("," "*" expression | "," '
'keyword_item)*\n'
' keywords_arguments ::= (keyword_item | "**" expression)\n'
- ' ("," keyword_item | "**" expression)*\n'
+ ' ("," keyword_item | "," "**" '
+ 'expression)*\n'
' keyword_item ::= identifier "=" expression\n'
'\n'
'An optional trailing comma may be present after the positional and\n'
' The class must define a "__call__()" method; the effect is then '
'the\n'
' same as if that method was called.\n',
- 'class': '\n'
- 'Class definitions\n'
+ 'class': 'Class definitions\n'
'*****************\n'
'\n'
'A class definition defines a class object (see section The '
'\n'
'See also: **PEP 3115** - Metaclasses in Python 3 **PEP 3129** -\n'
' Class Decorators\n',
- 'comparisons': '\n'
- 'Comparisons\n'
+ 'comparisons': 'Comparisons\n'
'***********\n'
'\n'
'Unlike C, all comparison operations in Python have the same '
'restriction that\n'
' ranges do not support order comparison. Equality '
'comparison across\n'
- ' these types results in unequality, and ordering comparison '
+ ' these types results in inequality, and ordering comparison '
'across\n'
' these types raises "TypeError".\n'
'\n'
' to sequences, but not to sets or mappings). See also the\n'
' "total_ordering()" decorator.\n'
'\n'
+ '* The "hash()" result should be consistent with equality. '
+ 'Objects\n'
+ ' that are equal should either have the same hash value, or '
+ 'be marked\n'
+ ' as unhashable.\n'
+ '\n'
'Python does not enforce these consistency rules. In fact, '
'the\n'
'not-a-number values are an example for not following these '
'is determined using the "id()" function. "x is not y" yields '
'the\n'
'inverse truth value. [4]\n',
- 'compound': '\n'
- 'Compound statements\n'
+ 'compound': 'Compound statements\n'
'*******************\n'
'\n'
'Compound statements contain (groups of) other statements; they '
' body is transformed into the namespace\'s "__doc__" item '
'and\n'
" therefore the class's *docstring*.\n",
- 'context-managers': '\n'
- 'With Statement Context Managers\n'
+ 'context-managers': 'With Statement Context Managers\n'
'*******************************\n'
'\n'
'A *context manager* is an object that defines the '
' The specification, background, and examples for the '
'Python "with"\n'
' statement.\n',
- 'continue': '\n'
- 'The "continue" statement\n'
+ 'continue': 'The "continue" statement\n'
'************************\n'
'\n'
' continue_stmt ::= "continue"\n'
'"finally" clause, that "finally" clause is executed before '
'really\n'
'starting the next loop cycle.\n',
- 'conversions': '\n'
- 'Arithmetic conversions\n'
+ 'conversions': 'Arithmetic conversions\n'
'**********************\n'
'\n'
'When a description of an arithmetic operator below uses the '
"left argument to the '%' operator). Extensions must define "
'their own\n'
'conversion behavior.\n',
- 'customization': '\n'
- 'Basic customization\n'
+ 'customization': 'Basic customization\n'
'*******************\n'
'\n'
'object.__new__(cls[, ...])\n'
'on members\n'
' of hashed collections including "set", "frozenset", and '
'"dict".\n'
- ' "__hash__()" should return an integer. The only '
- 'required property\n'
+ ' "__hash__()" should return an integer. The only required '
+ 'property\n'
' is that objects which compare equal have the same hash '
'value; it is\n'
- ' advised to somehow mix together (e.g. using exclusive '
- 'or) the hash\n'
- ' values for the components of the object that also play a '
- 'part in\n'
- ' comparison of objects.\n'
+ ' advised to mix together the hash values of the '
+ 'components of the\n'
+ ' object that also play a part in comparison of objects by '
+ 'packing\n'
+ ' them into a tuple and hashing the tuple. Example:\n'
+ '\n'
+ ' def __hash__(self):\n'
+ ' return hash((self.name, self.nick, self.color))\n'
'\n'
' Note: "hash()" truncates the value returned from an '
"object's\n"
' neither "__len__()" nor "__bool__()", all its instances '
'are\n'
' considered true.\n',
- 'debugger': '\n'
- '"pdb" --- The Python Debugger\n'
+ 'debugger': '"pdb" --- The Python Debugger\n'
'*****************************\n'
'\n'
'**Source code:** Lib/pdb.py\n'
'[1] Whether a frame is considered to originate in a certain '
'module\n'
' is determined by the "__name__" in the frame globals.\n',
- 'del': '\n'
- 'The "del" statement\n'
+ 'del': 'The "del" statement\n'
'*******************\n'
'\n'
' del_stmt ::= "del" target_list\n'
'Changed in version 3.2: Previously it was illegal to delete a name\n'
'from the local namespace if it occurs as a free variable in a nested\n'
'block.\n',
- 'dict': '\n'
- 'Dictionary displays\n'
+ 'dict': 'Dictionary displays\n'
'*******************\n'
'\n'
'A dictionary display is a possibly empty series of key/datum pairs\n'
'should be *hashable*, which excludes all mutable objects.) Clashes\n'
'between duplicate keys are not detected; the last datum (textually\n'
'rightmost in the display) stored for a given key value prevails.\n',
- 'dynamic-features': '\n'
- 'Interaction with dynamic features\n'
+ 'dynamic-features': 'Interaction with dynamic features\n'
'*********************************\n'
'\n'
'Name resolution of free variables occurs at runtime, not '
'override the global and local namespace. If only one '
'namespace is\n'
'specified, it is used for both.\n',
- 'else': '\n'
- 'The "if" statement\n'
+ 'else': 'The "if" statement\n'
'******************\n'
'\n'
'The "if" statement is used for conditional execution:\n'
'(and no other part of the "if" statement is executed or evaluated).\n'
'If all expressions are false, the suite of the "else" clause, if\n'
'present, is executed.\n',
- 'exceptions': '\n'
- 'Exceptions\n'
+ 'exceptions': 'Exceptions\n'
'**********\n'
'\n'
'Exceptions are a means of breaking out of the normal flow of '
' these operations is not available at the time the module '
'is\n'
' compiled.\n',
- 'execmodel': '\n'
- 'Execution model\n'
+ 'execmodel': 'Execution model\n'
'***************\n'
'\n'
'\n'
' these operations is not available at the time the module '
'is\n'
' compiled.\n',
- 'exprlists': '\n'
- 'Expression lists\n'
+ 'exprlists': 'Expression lists\n'
'****************\n'
'\n'
' expression_list ::= expression ( "," expression )* [","]\n'
'value of that expression. (To create an empty tuple, use an '
'empty pair\n'
'of parentheses: "()".)\n',
- 'floating': '\n'
- 'Floating point literals\n'
+ 'floating': 'Floating point literals\n'
'***********************\n'
'\n'
'Floating point literals are described by the following lexical\n'
'Changed in version 3.6: Underscores are now allowed for '
'grouping\n'
'purposes in literals.\n',
- 'for': '\n'
- 'The "for" statement\n'
+ 'for': 'The "for" statement\n'
'*******************\n'
'\n'
'The "for" statement is used to iterate over the elements of a '
'\n'
' for x in a[:]:\n'
' if x < 0: a.remove(x)\n',
- 'formatstrings': '\n'
- 'Format String Syntax\n'
+ 'formatstrings': 'Format String Syntax\n'
'********************\n'
'\n'
'The "str.format()" method and the "Formatter" class share '
' 9 9 11 1001\n'
' 10 A 12 1010\n'
' 11 B 13 1011\n',
- 'function': '\n'
- 'Function definitions\n'
+ 'function': 'Function definitions\n'
'********************\n'
'\n'
'A function definition defines a user-defined function object '
'\n'
' **PEP 3107** - Function Annotations\n'
' The original specification for function annotations.\n',
- 'global': '\n'
- 'The "global" statement\n'
+ 'global': 'The "global" statement\n'
'**********************\n'
'\n'
' global_stmt ::= "global" identifier ("," identifier)*\n'
'code containing the function call. The same applies to the '
'"eval()"\n'
'and "compile()" functions.\n',
- 'id-classes': '\n'
- 'Reserved classes of identifiers\n'
+ 'id-classes': 'Reserved classes of identifiers\n'
'*******************************\n'
'\n'
'Certain classes of identifiers (besides keywords) have '
' to help avoid name clashes between "private" attributes of '
'base and\n'
' derived classes. See section Identifiers (Names).\n',
- 'identifiers': '\n'
- 'Identifiers and keywords\n'
+ 'identifiers': 'Identifiers and keywords\n'
'************************\n'
'\n'
'Identifiers (also referred to as *names*) are described by '
' to help avoid name clashes between "private" attributes of '
'base and\n'
' derived classes. See section Identifiers (Names).\n',
- 'if': '\n'
- 'The "if" statement\n'
+ 'if': 'The "if" statement\n'
'******************\n'
'\n'
'The "if" statement is used for conditional execution:\n'
'(and no other part of the "if" statement is executed or evaluated).\n'
'If all expressions are false, the suite of the "else" clause, if\n'
'present, is executed.\n',
- 'imaginary': '\n'
- 'Imaginary literals\n'
+ 'imaginary': 'Imaginary literals\n'
'******************\n'
'\n'
'Imaginary literals are described by the following lexical '
'\n'
' 3.14j 10.j 10j .001j 1e100j 3.14e-10j '
'3.14_15_93j\n',
- 'import': '\n'
- 'The "import" statement\n'
+ 'import': 'The "import" statement\n'
'**********************\n'
'\n'
' import_stmt ::= "import" module ["as" name] ( "," module '
'\n'
' **PEP 236** - Back to the __future__\n'
' The original proposal for the __future__ mechanism.\n',
- 'in': '\n'
- 'Membership test operations\n'
+ 'in': 'Membership test operations\n'
'**************************\n'
'\n'
'The operators "in" and "not in" test for membership. "x in s"\n'
'\n'
'The operator "not in" is defined to have the inverse true value of\n'
'"in".\n',
- 'integers': '\n'
- 'Integer literals\n'
+ 'integers': 'Integer literals\n'
'****************\n'
'\n'
'Integer literals are described by the following lexical '
'Changed in version 3.6: Underscores are now allowed for '
'grouping\n'
'purposes in literals.\n',
- 'lambda': '\n'
- 'Lambdas\n'
+ 'lambda': 'Lambdas\n'
'*******\n'
'\n'
' lambda_expr ::= "lambda" [parameter_list]: expression\n'
'Note that functions created with lambda expressions cannot '
'contain\n'
'statements or annotations.\n',
- 'lists': '\n'
- 'List displays\n'
+ 'lists': 'List displays\n'
'*************\n'
'\n'
'A list display is a possibly empty series of expressions enclosed '
'from left to right and placed into the list object in that order.\n'
'When a comprehension is supplied, the list is constructed from the\n'
'elements resulting from the comprehension.\n',
- 'naming': '\n'
- 'Naming and binding\n'
+ 'naming': 'Naming and binding\n'
'******************\n'
'\n'
'\n'
'override the global and local namespace. If only one namespace '
'is\n'
'specified, it is used for both.\n',
- 'nonlocal': '\n'
- 'The "nonlocal" statement\n'
+ 'nonlocal': 'The "nonlocal" statement\n'
'************************\n'
'\n'
' nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*\n'
'\n'
' **PEP 3104** - Access to Names in Outer Scopes\n'
' The specification for the "nonlocal" statement.\n',
- 'numbers': '\n'
- 'Numeric literals\n'
+ 'numbers': 'Numeric literals\n'
'****************\n'
'\n'
'There are three types of numeric literals: integers, floating '
'is actually an expression composed of the unary operator \'"-"\' '
'and the\n'
'literal "1".\n',
- 'numeric-types': '\n'
- 'Emulating numeric types\n'
+ 'numeric-types': 'Emulating numeric types\n'
'***********************\n'
'\n'
'The following methods can be defined to emulate numeric '
' "__index__()" is defined "__int__()" should also be '
'defined, and\n'
' both should return the same value.\n',
- 'objects': '\n'
- 'Objects, values and types\n'
+ 'objects': 'Objects, values and types\n'
'*************************\n'
'\n'
"*Objects* are Python's abstraction for data. All data in a "
'created empty lists. (Note that "c = d = []" assigns the same '
'object\n'
'to both "c" and "d".)\n',
- 'operator-summary': '\n'
- 'Operator precedence\n'
+ 'operator-summary': 'Operator precedence\n'
'*******************\n'
'\n'
'The following table summarizes the operator precedence '
'arithmetic\n'
' or bitwise unary operator on its right, that is, '
'"2**-1" is "0.5".\n',
- 'pass': '\n'
- 'The "pass" statement\n'
+ 'pass': 'The "pass" statement\n'
'********************\n'
'\n'
' pass_stmt ::= "pass"\n'
' def f(arg): pass # a function that does nothing (yet)\n'
'\n'
' class C: pass # a class with no methods (yet)\n',
- 'power': '\n'
- 'The power operator\n'
+ 'power': 'The power operator\n'
'******************\n'
'\n'
'The power operator binds more tightly than unary operators on its\n'
'Raising a negative number to a fractional power results in a '
'"complex"\n'
'number. (In earlier versions it raised a "ValueError".)\n',
- 'raise': '\n'
- 'The "raise" statement\n'
+ 'raise': 'The "raise" statement\n'
'*********************\n'
'\n'
' raise_stmt ::= "raise" [expression ["from" expression]]\n'
'Exceptions, and information about handling exceptions is in '
'section\n'
'The try statement.\n',
- 'return': '\n'
- 'The "return" statement\n'
+ 'return': 'The "return" statement\n'
'**********************\n'
'\n'
' return_stmt ::= "return" [expression_list]\n'
'"StopAsyncIteration" to be raised. A non-empty "return" statement '
'is\n'
'a syntax error in an asynchronous generator function.\n',
- 'sequence-types': '\n'
- 'Emulating container types\n'
+ 'sequence-types': 'Emulating container types\n'
'*************************\n'
'\n'
'The following methods can be defined to implement '
' iteration protocol via "__getitem__()", see this '
'section in the\n'
' language reference.\n',
- 'shifting': '\n'
- 'Shifting operations\n'
+ 'shifting': 'Shifting operations\n'
'*******************\n'
'\n'
'The shifting operations have lower priority than the arithmetic\n'
'operand is\n'
' larger than "sys.maxsize" an "OverflowError" exception is '
'raised.\n',
- 'slicings': '\n'
- 'Slicings\n'
+ 'slicings': 'Slicings\n'
'********\n'
'\n'
'A slicing selects a range of items in a sequence object (e.g., '
'as lower bound, upper bound and stride, respectively, '
'substituting\n'
'"None" for missing expressions.\n',
- 'specialattrs': '\n'
- 'Special Attributes\n'
+ 'specialattrs': 'Special Attributes\n'
'******************\n'
'\n'
'The implementation adds a few special read-only attributes '
'[5] To format only a tuple you should therefore provide a\n'
' singleton tuple whose only element is the tuple to be '
'formatted.\n',
- 'specialnames': '\n'
- 'Special method names\n'
+ 'specialnames': 'Special method names\n'
'********************\n'
'\n'
'A class can implement certain operations that are invoked by '
'on members\n'
' of hashed collections including "set", "frozenset", and '
'"dict".\n'
- ' "__hash__()" should return an integer. The only required '
+ ' "__hash__()" should return an integer. The only required '
'property\n'
' is that objects which compare equal have the same hash '
'value; it is\n'
- ' advised to somehow mix together (e.g. using exclusive or) '
- 'the hash\n'
- ' values for the components of the object that also play a '
- 'part in\n'
- ' comparison of objects.\n'
+ ' advised to mix together the hash values of the components '
+ 'of the\n'
+ ' object that also play a part in comparison of objects by '
+ 'packing\n'
+ ' them into a tuple and hashing the tuple. Example:\n'
+ '\n'
+ ' def __hash__(self):\n'
+ ' return hash((self.name, self.nick, self.color))\n'
'\n'
' Note: "hash()" truncates the value returned from an '
"object's\n"
'special method *must* be set on the class object itself in '
'order to be\n'
'consistently invoked by the interpreter).\n',
- 'string-methods': '\n'
- 'String Methods\n'
+ 'string-methods': 'String Methods\n'
'**************\n'
'\n'
'Strings implement all of the common sequence operations, '
'characters\n'
' and there is at least one character, false otherwise. '
'Decimal\n'
- ' characters are those from general category "Nd". This '
- 'category\n'
- ' includes digit characters, and all characters that can '
- 'be used to\n'
- ' form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC '
- 'DIGIT ZERO.\n'
+ ' characters are those that can be used to form numbers '
+ 'in base 10,\n'
+ ' e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Formally a '
+ 'decimal character\n'
+ ' is a character in the Unicode General Category "Nd".\n'
'\n'
'str.isdigit()\n'
'\n'
'include decimal\n'
' characters and digits that need special handling, such '
'as the\n'
- ' compatibility superscript digits. Formally, a digit is '
- 'a character\n'
- ' that has the property value Numeric_Type=Digit or\n'
- ' Numeric_Type=Decimal.\n'
+ ' compatibility superscript digits. This covers digits '
+ 'which cannot\n'
+ ' be used to form numbers in base 10, like the Kharosthi '
+ 'numbers.\n'
+ ' Formally, a digit is a character that has the property '
+ 'value\n'
+ ' Numeric_Type=Digit or Numeric_Type=Decimal.\n'
'\n'
'str.isidentifier()\n'
'\n'
" '00042'\n"
' >>> "-42".zfill(5)\n'
" '-0042'\n",
- 'strings': '\n'
- 'String and Bytes literals\n'
+ 'strings': 'String and Bytes literals\n'
'*************************\n'
'\n'
'String literals are described by the following lexical '
'followed by a newline is interpreted as those two characters as '
'part\n'
'of the literal, *not* as a line continuation.\n',
- 'subscriptions': '\n'
- 'Subscriptions\n'
+ 'subscriptions': 'Subscriptions\n'
'*************\n'
'\n'
'A subscription selects an item of a sequence (string, tuple '
"A string's items are characters. A character is not a "
'separate data\n'
'type but a string of exactly one character.\n',
- 'truth': '\n'
- 'Truth Value Testing\n'
+ 'truth': 'Truth Value Testing\n'
'*******************\n'
'\n'
'Any object can be tested for truth value, for use in an "if" or\n'
'otherwise stated. (Important exception: the Boolean operations '
'"or"\n'
'and "and" always return one of their operands.)\n',
- 'try': '\n'
- 'The "try" statement\n'
+ 'try': 'The "try" statement\n'
'*******************\n'
'\n'
'The "try" statement specifies exception handlers and/or cleanup code\n'
'Exceptions, and information on using the "raise" statement to '
'generate\n'
'exceptions may be found in section The raise statement.\n',
- 'types': '\n'
- 'The standard type hierarchy\n'
+ 'types': 'The standard type hierarchy\n'
'***************************\n'
'\n'
'Below is a list of the types that are built into Python. '
'the\n'
' dictionary containing the class\'s namespace; "__bases__" is a '
'tuple\n'
- ' (possibly empty or a singleton) containing the base classes, in '
- 'the\n'
- ' order of their occurrence in the base class list; "__doc__" is '
- 'the\n'
- ' class\'s documentation string, or "None" if undefined;\n'
- ' "__annotations__" (optional) is a dictionary containing '
- '*variable\n'
- ' annotations* collected during class body execution.\n'
+ ' containing the base classes, in the order of their occurrence '
+ 'in\n'
+ ' the base class list; "__doc__" is the class\'s documentation '
+ 'string,\n'
+ ' or "None" if undefined; "__annotations__" (optional) is a\n'
+ ' dictionary containing *variable annotations* collected during '
+ 'class\n'
+ ' body execution.\n'
'\n'
'Class instances\n'
' A class instance is created by calling a class object (see '
' under "User-defined methods". Class method objects are '
'created\n'
' by the built-in "classmethod()" constructor.\n',
- 'typesfunctions': '\n'
- 'Functions\n'
+ 'typesfunctions': 'Functions\n'
'*********\n'
'\n'
'Function objects are created by function definitions. The '
'different object types.\n'
'\n'
'See Function definitions for more information.\n',
- 'typesmapping': '\n'
- 'Mapping Types --- "dict"\n'
+ 'typesmapping': 'Mapping Types --- "dict"\n'
'************************\n'
'\n'
'A *mapping* object maps *hashable* values to arbitrary '
" {'bacon'}\n"
" >>> keys ^ {'sausage', 'juice'}\n"
" {'juice', 'sausage', 'bacon', 'spam'}\n",
- 'typesmethods': '\n'
- 'Methods\n'
+ 'typesmethods': 'Methods\n'
'*******\n'
'\n'
'Methods are functions that are called using the attribute '
" 'my name is method'\n"
'\n'
'See The standard type hierarchy for more information.\n',
- 'typesmodules': '\n'
- 'Modules\n'
+ 'typesmodules': 'Modules\n'
'*******\n'
'\n'
'The only special operation on a module is attribute access: '
'written as\n'
'"<module \'os\' from '
'\'/usr/local/lib/pythonX.Y/os.pyc\'>".\n',
- 'typesseq': '\n'
- 'Sequence Types --- "list", "tuple", "range"\n'
+ 'typesseq': 'Sequence Types --- "list", "tuple", "range"\n'
'*******************************************\n'
'\n'
'There are three basic sequence types: lists, tuples, and range\n'
'\n'
'3. If *i* or *j* is negative, the index is relative to the end '
'of\n'
- ' the string: "len(s) + i" or "len(s) + j" is substituted. But '
- 'note\n'
- ' that "-0" is still "0".\n'
+ ' sequence *s*: "len(s) + i" or "len(s) + j" is substituted. '
+ 'But\n'
+ ' note that "-0" is still "0".\n'
'\n'
'4. The slice of *s* from *i* to *j* is defined as the sequence '
'of\n'
' (j-i)/k". In other words, the indices are "i", "i+k", '
'"i+2*k",\n'
' "i+3*k" and so on, stopping when *j* is reached (but never\n'
- ' including *j*). If *i* or *j* is greater than "len(s)", use\n'
- ' "len(s)". If *i* or *j* are omitted or "None", they become '
- '"end"\n'
- ' values (which end depends on the sign of *k*). Note, *k* '
- 'cannot be\n'
- ' zero. If *k* is "None", it is treated like "1".\n'
+ ' including *j*). When *k* is positive, *i* and *j* are '
+ 'reduced to\n'
+ ' "len(s)" if they are greater. When *k* is negative, *i* and '
+ '*j* are\n'
+ ' reduced to "len(s) - 1" if they are greater. If *i* or *j* '
+ 'are\n'
+ ' omitted or "None", they become "end" values (which end '
+ 'depends on\n'
+ ' the sign of *k*). Note, *k* cannot be zero. If *k* is '
+ '"None", it\n'
+ ' is treated like "1".\n'
'\n'
'6. Concatenating immutable sequences always results in a new\n'
' object. This means that building up a sequence by repeated\n'
' * The linspace recipe shows how to implement a lazy version '
'of\n'
' range that suitable for floating point applications.\n',
- 'typesseq-mutable': '\n'
- 'Mutable Sequence Types\n'
+ 'typesseq-mutable': 'Mutable Sequence Types\n'
'**********************\n'
'\n'
'The operations in the following table are defined on '
'referenced multiple\n'
' times, as explained for "s * n" under Common Sequence '
'Operations.\n',
- 'unary': '\n'
- 'Unary arithmetic and bitwise operations\n'
+ 'unary': 'Unary arithmetic and bitwise operations\n'
'***************************************\n'
'\n'
'All unary arithmetic and bitwise operations have the same '
'In all three cases, if the argument does not have the proper type, '
'a\n'
'"TypeError" exception is raised.\n',
- 'while': '\n'
- 'The "while" statement\n'
+ 'while': 'The "while" statement\n'
'*********************\n'
'\n'
'The "while" statement is used for repeated execution as long as an\n'
'executed in the first suite skips the rest of the suite and goes '
'back\n'
'to testing the expression.\n',
- 'with': '\n'
- 'The "with" statement\n'
+ 'with': 'The "with" statement\n'
'********************\n'
'\n'
'The "with" statement is used to wrap the execution of a block with\n'
' The specification, background, and examples for the Python '
'"with"\n'
' statement.\n',
- 'yield': '\n'
- 'The "yield" statement\n'
+ 'yield': 'The "yield" statement\n'
'*********************\n'
'\n'
' yield_stmt ::= yield_expression\n'
try:
i = self._randbelow(len(seq))
except ValueError:
- raise IndexError('Cannot choose from an empty sequence')
+ raise IndexError('Cannot choose from an empty sequence') from None
return seq[i]
def shuffle(self, x, random=None):
def randbelow(exclusive_upper_bound):
"""Return a random int in the range [0, n)."""
+ if exclusive_upper_bound <= 0:
+ raise ValueError("Upper bound must be positive.")
return _sysrand._randbelow(exclusive_upper_bound)
DEFAULT_ENTROPY = 32 # number of bytes to return by default
break # emit current token
else:
continue
- elif self.posix and nextchar in self.quotes:
- self.state = nextchar
- elif self.posix and nextchar in self.escape:
- escapedstate = 'a'
- self.state = nextchar
elif self.state == 'c':
if nextchar in self.punctuation_chars:
self.token += nextchar
self._pushback_chars.append(nextchar)
self.state = ' '
break
+ elif self.posix and nextchar in self.quotes:
+ self.state = nextchar
+ elif self.posix and nextchar in self.escape:
+ escapedstate = 'a'
+ self.state = nextchar
elif (nextchar in self.wordchars or nextchar in self.quotes
or self.whitespace_split):
self.token += nextchar
import fnmatch
import collections
import errno
-import tarfile
+
+try:
+ import zlib
+ del zlib
+ _ZLIB_SUPPORTED = True
+except ImportError:
+ _ZLIB_SUPPORTED = False
try:
import bz2
Returns the output filename.
"""
- tar_compression = {'gzip': 'gz', None: ''}
- compress_ext = {'gzip': '.gz'}
-
- if _BZ2_SUPPORTED:
- tar_compression['bzip2'] = 'bz2'
- compress_ext['bzip2'] = '.bz2'
-
- if _LZMA_SUPPORTED:
- tar_compression['xz'] = 'xz'
- compress_ext['xz'] = '.xz'
-
- # flags for compression program, each element of list will be an argument
- if compress is not None and compress not in compress_ext:
+ if compress is None:
+ tar_compression = ''
+ elif _ZLIB_SUPPORTED and compress == 'gzip':
+ tar_compression = 'gz'
+ elif _BZ2_SUPPORTED and compress == 'bzip2':
+ tar_compression = 'bz2'
+ elif _LZMA_SUPPORTED and compress == 'xz':
+ tar_compression = 'xz'
+ else:
raise ValueError("bad value for 'compress', or compression format not "
"supported : {0}".format(compress))
- archive_name = base_name + '.tar' + compress_ext.get(compress, '')
+ import tarfile # late import for breaking circular dependency
+
+ compress_ext = '.' + tar_compression if compress else ''
+ archive_name = base_name + '.tar' + compress_ext
archive_dir = os.path.dirname(archive_name)
if archive_dir and not os.path.exists(archive_dir):
return tarinfo
if not dry_run:
- tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
+ tar = tarfile.open(archive_name, 'w|%s' % tar_compression)
try:
tar.add(base_dir, filter=_set_uid_gid)
finally:
def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
"""Create a zip file from all the files under 'base_dir'.
- The output zip file will be named 'base_name' + ".zip". Uses either the
- "zipfile" Python module (if available) or the InfoZIP "zip" utility
- (if installed and found on the default search path). If neither tool is
- available, raises ExecError. Returns the name of the output zip
- file.
+ The output zip file will be named 'base_name' + ".zip". Returns the
+ name of the output zip file.
"""
- import zipfile
+ import zipfile # late import for breaking circular dependency
zip_filename = base_name + ".zip"
archive_dir = os.path.dirname(base_name)
return zip_filename
_ARCHIVE_FORMATS = {
- 'gztar': (_make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
'tar': (_make_tarball, [('compress', None)], "uncompressed tar file"),
- 'zip': (_make_zipfile, [], "ZIP file")
- }
+}
+
+if _ZLIB_SUPPORTED:
+ _ARCHIVE_FORMATS['gztar'] = (_make_tarball, [('compress', 'gzip')],
+ "gzip'ed tar-file")
+ _ARCHIVE_FORMATS['zip'] = (_make_zipfile, [], "ZIP file")
if _BZ2_SUPPORTED:
_ARCHIVE_FORMATS['bztar'] = (_make_tarball, [('compress', 'bzip2')],
"""Create an archive file (eg. zip or tar).
'base_name' is the name of the file to create, minus any format-specific
- extension; 'format' is the archive format: one of "zip", "tar", "bztar"
- or "gztar".
+ extension; 'format' is the archive format: one of "zip", "tar", "gztar",
+ "bztar", or "xztar". Or any other registered format.
'root_dir' is a directory that will be the root directory of the
archive; ie. we typically chdir into 'root_dir' before creating the
def _unpack_zipfile(filename, extract_dir):
"""Unpack zip `filename` to `extract_dir`
"""
- try:
- import zipfile
- except ImportError:
- raise ReadError('zlib not supported, cannot unpack this archive.')
+ import zipfile # late import for breaking circular dependency
if not zipfile.is_zipfile(filename):
raise ReadError("%s is not a zip file" % filename)
def _unpack_tarfile(filename, extract_dir):
"""Unpack tar/tar.gz/tar.bz2/tar.xz `filename` to `extract_dir`
"""
+ import tarfile # late import for breaking circular dependency
try:
tarobj = tarfile.open(filename)
except tarfile.TarError:
tarobj.close()
_UNPACK_FORMATS = {
- 'gztar': (['.tar.gz', '.tgz'], _unpack_tarfile, [], "gzip'ed tar-file"),
'tar': (['.tar'], _unpack_tarfile, [], "uncompressed tar file"),
- 'zip': (['.zip'], _unpack_zipfile, [], "ZIP file")
- }
+ 'zip': (['.zip'], _unpack_zipfile, [], "ZIP file"),
+}
+
+if _ZLIB_SUPPORTED:
+ _UNPACK_FORMATS['gztar'] = (['.tar.gz', '.tgz'], _unpack_tarfile, [],
+ "gzip'ed tar-file")
if _BZ2_SUPPORTED:
_UNPACK_FORMATS['bztar'] = (['.tar.bz2', '.tbz2'], _unpack_tarfile, [],
`extract_dir` is the name of the target directory, where the archive
is unpacked. If not provided, the current working directory is used.
- `format` is the archive format: one of "zip", "tar", or "gztar". Or any
- other registered format. If not provided, unpack_archive will use the
- filename extension and see if an unpacker was registered for that
- extension.
+ `format` is the archive format: one of "zip", "tar", "gztar", "bztar",
+ or "xztar". Or any other registered format. If not provided,
+ unpack_archive will use the filename extension and see if an unpacker
+ was registered for that extension.
In case none is found, a ValueError is raised.
"""
+++ /dev/null
-This directory exists so that 3rd party packages can be installed
-here. Read the source for site.py for more details.
result = self.con.execute("select * from test").fetchall()
self.assertEqual(result, [])
+ def CheckImmediateTransactionalDDL(self):
+ # You can achieve transactional DDL by issuing a BEGIN
+ # statement manually.
+ self.con.execute("begin immediate")
+ self.con.execute("create table test(i)")
+ self.con.rollback()
+ with self.assertRaises(sqlite.OperationalError):
+ self.con.execute("select * from test")
+
def CheckTransactionalDDL(self):
# You can achieve transactional DDL by issuing a BEGIN
# statement manually.
@unittest.skipIf(sqlite.sqlite_version_info < (3, 1),
'the date functions are available on 3.1 or later')
def CheckSqlTimestamp(self):
- # SQLite's current_timestamp uses UTC time, while datetime.datetime.now() uses local time.
- now = datetime.datetime.now()
+ now = datetime.datetime.utcnow()
self.cur.execute("insert into test(ts) values (current_timestamp)")
self.cur.execute("select ts from test")
ts = self.cur.fetchone()[0]
# Wait for the process to terminate, to avoid zombies.
self.wait()
- def __del__(self, _maxsize=sys.maxsize):
+ def __del__(self, _maxsize=sys.maxsize, _warn=warnings.warn):
if not self._child_created:
# We didn't get to successfully create a child process.
return
if self.returncode is None:
# Not reading subprocess exit status creates a zombi process which
# is only destroyed at the parent python process exit
- warnings.warn("subprocess %s is still running" % self.pid,
- ResourceWarning, source=self)
+ _warn("subprocess %s is still running" % self.pid,
+ ResourceWarning, source=self)
# In case the child hasn't been waited on, check if it's done.
self._internal_poll(_deadstate=_maxsize)
if self.returncode is None and _active is not None:
def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
_WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
- _WEXITSTATUS=os.WEXITSTATUS):
+ _WEXITSTATUS=os.WEXITSTATUS, _WIFSTOPPED=os.WIFSTOPPED,
+ _WSTOPSIG=os.WSTOPSIG):
"""All callers to this function MUST hold self._waitpid_lock."""
# This method is called (indirectly) by __del__, so it cannot
# refer to anything outside of its local scope.
self.returncode = -_WTERMSIG(sts)
elif _WIFEXITED(sts):
self.returncode = _WEXITSTATUS(sts)
+ elif _WIFSTOPPED(sts):
+ self.returncode = -_WSTOPSIG(sts)
else:
# Should never happen
raise SubprocessError("Unknown child exit status!")
import re
try:
- import grp, pwd
+ import pwd
except ImportError:
- grp = pwd = None
+ pwd = None
+try:
+ import grp
+except ImportError:
+ grp = None
# os.symlink on Windows prior to 6.0 raises NotImplementedError
symlink_exception = (AttributeError, NotImplementedError)
def chown(self, tarinfo, targetpath, numeric_owner):
"""Set owner of targetpath according to tarinfo. If numeric_owner
- is True, use .gid/.uid instead of .gname/.uname.
+ is True, use .gid/.uid instead of .gname/.uname. If numeric_owner
+ is False, fall back to .gid/.uid when the search based on name
+ fails.
"""
- if pwd and hasattr(os, "geteuid") and os.geteuid() == 0:
+ if hasattr(os, "geteuid") and os.geteuid() == 0:
# We have to be root to do so.
- if numeric_owner:
- g = tarinfo.gid
- u = tarinfo.uid
- else:
+ g = tarinfo.gid
+ u = tarinfo.uid
+ if not numeric_owner:
try:
- g = grp.getgrnam(tarinfo.gname)[2]
+ if grp:
+ g = grp.getgrnam(tarinfo.gname)[2]
except KeyError:
- g = tarinfo.gid
+ pass
try:
- u = pwd.getpwnam(tarinfo.uname)[2]
+ if pwd:
+ u = pwd.getpwnam(tarinfo.uname)[2]
except KeyError:
- u = tarinfo.uid
+ pass
try:
if tarinfo.issym() and hasattr(os, "lchown"):
os.lchown(targetpath, u, g)
self.assertTrue(methods == ['fork', 'spawn'] or
methods == ['fork', 'spawn', 'forkserver'])
+ def test_preload_resources(self):
+ if multiprocessing.get_start_method() != 'forkserver':
+ self.skipTest("test only relevant for 'forkserver' method")
+ name = os.path.join(os.path.dirname(__file__), 'mp_preload.py')
+ rc, out, err = test.support.script_helper.assert_python_ok(name)
+ out = out.decode()
+ err = err.decode()
+ if out.rstrip() != 'ok' or err != '':
+ print(out)
+ print(err)
+ self.fail("failed spawning forkserver or grandchild")
+
+
#
# Check that killing process does not leak named semaphores
#
self.assertEqual(t.second, 0)
self.assertEqual(t.microsecond, 7812)
+ def test_timestamp_limits(self):
+ # minimum timestamp
+ min_dt = self.theclass.min.replace(tzinfo=timezone.utc)
+ min_ts = min_dt.timestamp()
+ try:
+ # date 0001-01-01 00:00:00+00:00: timestamp=-62135596800
+ self.assertEqual(self.theclass.fromtimestamp(min_ts, tz=timezone.utc),
+ min_dt)
+ except (OverflowError, OSError) as exc:
+ # the date 0001-01-01 doesn't fit into 32-bit time_t,
+ # or platform doesn't support such very old date
+ self.skipTest(str(exc))
+
+ # maximum timestamp: set seconds to zero to avoid rounding issues
+ max_dt = self.theclass.max.replace(tzinfo=timezone.utc,
+ second=0, microsecond=0)
+ max_ts = max_dt.timestamp()
+ # date 9999-12-31 23:59:00+00:00: timestamp 253402300740
+ self.assertEqual(self.theclass.fromtimestamp(max_ts, tz=timezone.utc),
+ max_dt)
+
+ # number of seconds greater than 1 year: make sure that the new date
+ # is not valid in datetime.datetime limits
+ delta = 3600 * 24 * 400
+
+ # too small
+ ts = min_ts - delta
+ # converting a Python int to C time_t can raise a OverflowError,
+ # especially on 32-bit platforms.
+ with self.assertRaises((ValueError, OverflowError)):
+ self.theclass.fromtimestamp(ts)
+ with self.assertRaises((ValueError, OverflowError)):
+ self.theclass.utcfromtimestamp(ts)
+
+ # too big
+ ts = max_dt.timestamp() + delta
+ with self.assertRaises((ValueError, OverflowError)):
+ self.theclass.fromtimestamp(ts)
+ with self.assertRaises((ValueError, OverflowError)):
+ self.theclass.utcfromtimestamp(ts)
+
def test_insane_fromtimestamp(self):
# It's possible that some platform maps time_t to double,
# and that this test will fail there. This test should
import unittest
from test import support
+android_not_root = support.android_not_root
@contextlib.contextmanager
def kill_on_error(proc):
# https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=203162
@support.requires_freebsd_version(10, 3)
@unittest.skipUnless(hasattr(os, 'mkfifo'), 'needs mkfifo()')
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
def _test_open(self, do_open_close_reader, do_open_close_writer):
filename = support.TESTFN
self.stop_alarm()
self.assertGreaterEqual(dt, self.sleep_time)
+ @unittest.skipIf(sys.platform == "darwin",
+ "poll may fail on macOS; see issue #28087")
@unittest.skipUnless(hasattr(select, 'poll'), 'need select.poll')
def test_poll(self):
poller = select.poll()
if ns.single and ns.fromfile:
parser.error("-s and -f don't go together!")
- if ns.use_mp and ns.trace:
+ if ns.use_mp is not None and ns.trace:
parser.error("-T and -j don't go together!")
- if ns.use_mp and ns.findleaks:
+ if ns.use_mp is not None and ns.findleaks:
parser.error("-l and -j don't go together!")
if ns.failfast and not (ns.verbose or ns.verbose3):
parser.error("-G/--failfast needs either -v or -W")
--- /dev/null
+"""Module for testing the behavior of generics across different modules."""
+
+from typing import TypeVar, Generic
+
+T = TypeVar('T')
+
+
+class A(Generic[T]):
+ pass
+
+
+class B(Generic[T]):
+ class A(Generic[T]):
+ pass
--- /dev/null
+import multiprocessing
+
+multiprocessing.Lock()
+
+
+def f():
+ print("ok")
+
+
+if __name__ == "__main__":
+ ctx = multiprocessing.get_context("forkserver")
+ modname = "test.mp_preload"
+ # Make sure it's importable
+ __import__(modname)
+ ctx.set_forkserver_preload([modname])
+ proc = ctx.Process(target=f)
+ proc.start()
+ proc.join()
"check__all__", "requires_android_level", "requires_multiprocessing_queue",
# sys
"is_jython", "is_android", "check_impl_detail", "unix_shell",
+ "setswitchinterval", "android_not_root",
# network
"HOST", "IPV6_ENABLED", "find_unused_port", "bind_port", "open_urlresource",
+ "bind_unix_socket",
# processes
'temp_umask', "reap_children",
# logging
mode = 0
if stat.S_ISDIR(mode):
_waitfor(_rmtree_inner, fullname, waitall=True)
- _force_run(path, os.rmdir, fullname)
+ _force_run(fullname, os.rmdir, fullname)
else:
- _force_run(path, os.unlink, fullname)
+ _force_run(fullname, os.unlink, fullname)
_waitfor(_rmtree_inner, path, waitall=True)
_waitfor(lambda p: _force_run(p, os.rmdir, p), path)
else:
port = sock.getsockname()[1]
return port
+def bind_unix_socket(sock, addr):
+ """Bind a unix socket, raising SkipTest if PermissionError is raised."""
+ assert sock.family == socket.AF_UNIX
+ try:
+ sock.bind(addr)
+ except PermissionError:
+ sock.close()
+ raise unittest.SkipTest('cannot bind AF_UNIX sockets')
+
def _is_ipv6_enabled():
"""Check whether IPv6 is enabled on this host."""
if socket.has_ipv6:
_ANDROID_API_LEVEL = sysconfig.get_config_var('ANDROID_API_LEVEL')
is_android = (_ANDROID_API_LEVEL is not None and _ANDROID_API_LEVEL > 0)
+android_not_root = (is_android and os.geteuid() != 0)
if sys.platform != 'win32':
unix_shell = '/system/bin/sh' if is_android else '/bin/sh'
file.close()
unlink(TESTFN)
-def check_syntax_error(testcase, statement):
- testcase.assertRaises(SyntaxError, compile, statement,
- '<test string>', 'exec')
+def check_syntax_error(testcase, statement, *, lineno=None, offset=None):
+ with testcase.assertRaises(SyntaxError) as cm:
+ compile(statement, '<test string>', 'exec')
+ err = cm.exception
+ testcase.assertIsNotNone(err.lineno)
+ if lineno is not None:
+ testcase.assertEqual(err.lineno, lineno)
+ testcase.assertIsNotNone(err.offset)
+ if offset is not None:
+ testcase.assertEqual(err.offset, offset)
def open_urlresource(url, *args, **kw):
import urllib.request, urllib.parse
continue
if spawn.find_executable(cmd[0]) is None:
return cmd[0]
+
+
+_is_android_emulator = None
+def setswitchinterval(interval):
+ # Setting a very low gil interval on the Android emulator causes python
+ # to hang (issue #26939).
+ minimum_interval = 1e-5
+ if is_android and interval < minimum_interval:
+ global _is_android_emulator
+ if _is_android_emulator is None:
+ _is_android_emulator = (subprocess.check_output(
+ ['getprop', 'ro.kernel.qemu']).strip() == b'1')
+ if _is_android_emulator:
+ interval = minimum_interval
+ return sys.setswitchinterval(interval)
elif not env_vars and not env_required:
# ignore Python environment variables
cmd_line.append('-E')
- # Need to preserve the original environment, for in-place testing of
- # shared library builds.
- env = os.environ.copy()
- # set TERM='' unless the TERM environment variable is passed explicitly
- # see issues #11390 and #18300
- if 'TERM' not in env_vars:
- env['TERM'] = ''
+
# But a special flag that can be set to override -- in this case, the
# caller is responsible to pass the full environment.
if env_vars.pop('__cleanenv', None):
env = {}
+ if sys.platform == 'win32':
+ # Windows requires at least the SYSTEMROOT environment variable to
+ # start Python.
+ env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
+
+ # Other interesting environment variables, not copied currently:
+ # COMSPEC, HOME, PATH, TEMP, TMPDIR, TMP.
+ else:
+ # Need to preserve the original environment, for in-place testing of
+ # shared library builds.
+ env = os.environ.copy()
+
+ # set TERM='' unless the TERM environment variable is passed explicitly
+ # see issues #11390 and #18300
+ if 'TERM' not in env_vars:
+ env['TERM'] = ''
+
env.update(env_vars)
cmd_line.extend(args)
proc = subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
# than an AttributeError somewhere deep in CGIHTTPServer.
import _socket
- # rlcompleter needs special consideration; it import readline which
- # initializes GNU readline which calls setlocale(LC_CTYPE, "")... :-(
- import locale
- locale_tuple = locale.getlocale(locale.LC_CTYPE)
- try:
- import rlcompleter
- except ImportError:
- pass
- finally:
- locale.setlocale(locale.LC_CTYPE, locale_tuple)
-
ignored = []
failed_imports = []
lib_dir = os.path.dirname(os.path.dirname(__file__))
-from test.support import findfile, TESTFN, unlink
+from test.support import check_no_resource_warning, findfile, TESTFN, unlink
import unittest
+from unittest import mock
from test import audiotests
from audioop import byteswap
import io
#This file contains chunk types aifc doesn't recognize.
self.f = aifc.open(findfile('Sine-1000Hz-300ms.aif'))
+ def test_close_opened_files_on_error(self):
+ non_aifc_file = findfile('pluck-pcm8.wav', subdir='audiodata')
+ with check_no_resource_warning(self):
+ with self.assertRaises(aifc.Error):
+ # Try opening a non-AIFC file, with the expectation that
+ # `aifc.open` will fail (without raising a ResourceWarning)
+ self.f = aifc.open(non_aifc_file, 'rb')
+
+ # Aifc_write.initfp() won't raise in normal case. But some errors
+ # (e.g. MemoryError, KeyboardInterrupt, etc..) can happen.
+ with mock.patch.object(aifc.Aifc_write, 'initfp',
+ side_effect=RuntimeError):
+ with self.assertRaises(RuntimeError):
+ self.fout = aifc.open(TESTFN, 'wb')
+
def test_params_added(self):
f = self.f = aifc.open(TESTFN, 'wb')
f.aiff()
++foo foo help
'''))
+ def test_help_non_breaking_spaces(self):
+ parser = ErrorRaisingArgumentParser(
+ prog='PROG', description='main description')
+ parser.add_argument(
+ "--non-breaking", action='store_false',
+ help='help message containing non-breaking spaces shall not '
+ 'wrap\N{NO-BREAK SPACE}at non-breaking spaces')
+ self.assertEqual(parser.format_help(), textwrap.dedent('''\
+ usage: PROG [-h] [--non-breaking]
+
+ main description
+
+ optional arguments:
+ -h, --help show this help message and exit
+ --non-breaking help message containing non-breaking spaces shall not
+ wrap\N{NO-BREAK SPACE}at non-breaking spaces
+ '''))
def test_help_alternate_prefix_chars(self):
parser = self._get_parser(prefix_chars='+:/')
"""Tests for events.py."""
import collections.abc
+import concurrent.futures
import functools
import gc
import io
return version < (10, 5)
+def _test_get_event_loop_new_process__sub_proc():
+ async def doit():
+ return 'hello'
+
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+ return loop.run_until_complete(doit())
+
+
ONLYCERT = data_file('ssl_cert.pem')
ONLYKEY = data_file('ssl_key.pem')
SIGNED_CERTFILE = data_file('keycert3.pem')
asyncio.set_child_watcher(None)
super().tearDown()
+ def test_get_event_loop_new_process(self):
+ async def main():
+ pool = concurrent.futures.ProcessPoolExecutor()
+ return await self.loop.run_in_executor(
+ pool, _test_get_event_loop_new_process__sub_proc)
+
+ self.unpatch_get_running_loop()
+
+ self.assertEqual(
+ self.loop.run_until_complete(main()),
+ 'hello')
+
if hasattr(selectors, 'KqueueSelector'):
class KqueueEventLoopTests(UnixEventLoopTestsMixin,
SubprocessTestsMixin,
self.assertEqual(bag, [2])
self.assertEqual(f.result(), 'foo')
+ def test_remove_done_callbacks_list_mutation(self):
+ # see http://bugs.python.org/issue28963 for details
+
+ fut = self._new_future()
+ fut.add_done_callback(str)
+
+ for _ in range(63):
+ fut.add_done_callback(id)
+
+ class evil:
+ def __eq__(self, other):
+ fut.remove_done_callback(id)
+ return False
+
+ fut.remove_done_callback(evil())
+
+ def test_schedule_callbacks_list_mutation(self):
+ # see http://bugs.python.org/issue28963 for details
+
+ def mut(f):
+ f.remove_done_callback(str)
+
+ fut = self._new_future()
+ fut.add_done_callback(mut)
+ fut.add_done_callback(str)
+ fut.add_done_callback(str)
+ fut.set_result(1)
+ test_utils.run_briefly(self.loop)
+
@unittest.skipUnless(hasattr(futures, '_CFuture'),
'requires the C _asyncio module')
self.loop.run_until_complete(create)
self.assertEqual(warns, [])
+ def test_read_stdout_after_process_exit(self):
+ @asyncio.coroutine
+ def execute():
+ code = '\n'.join(['import sys',
+ 'for _ in range(64):',
+ ' sys.stdout.write("x" * 4096)',
+ 'sys.stdout.flush()',
+ 'sys.exit(1)'])
+
+ fut = asyncio.create_subprocess_exec(
+ sys.executable, '-c', code,
+ stdout=asyncio.subprocess.PIPE,
+ loop=self.loop)
+
+ process = yield from fut
+ while True:
+ data = yield from process.stdout.read(65536)
+ if data:
+ yield from asyncio.sleep(0.3, loop=self.loop)
+ else:
+ break
+
+ self.loop.run_until_complete(execute())
+
if sys.platform != 'win32':
# Unix
def coro(loop):
self.assertTrue(Task.current_task(loop=loop) is task)
+ # See http://bugs.python.org/issue29271 for details:
+ asyncio.set_event_loop(loop)
+ try:
+ self.assertIs(Task.current_task(None), task)
+ self.assertIs(Task.current_task(), task)
+ finally:
+ asyncio.set_event_loop(None)
+
task = self.new_task(self.loop, coro(self.loop))
self.loop.run_until_complete(task)
self.assertIsNone(Task.current_task(loop=self.loop))
# schedule the task
coro = kill_me(self.loop)
task = asyncio.ensure_future(coro, loop=self.loop)
+
self.assertEqual(Task.all_tasks(loop=self.loop), {task})
+ # See http://bugs.python.org/issue29271 for details:
+ asyncio.set_event_loop(self.loop)
+ try:
+ self.assertEqual(Task.all_tasks(), {task})
+ self.assertEqual(Task.all_tasks(None), {task})
+ finally:
+ asyncio.set_event_loop(None)
+
# execute the task so it waits for future
self.loop._run_once()
self.assertEqual(len(self.loop._ready), 0)
if HAS_UNIX_SOCKETS and sock.family == socket.AF_UNIX:
# Make sure the path doesn't exist.
support.unlink(addr)
- sock.bind(addr)
+ support.bind_unix_socket(sock, addr)
+ else:
+ sock.bind(addr)
class HelperFunctionTests(unittest.TestCase):
if HAS_UNIX_SOCKETS and self.family == socket.AF_UNIX:
self.skipTest("Not applicable to AF_UNIX sockets.")
+ if sys.platform == "darwin" and self.use_poll:
+ self.skipTest("poll may fail on macOS; see issue #28087")
+
class TestClient(BaseClient):
def handle_expt(self):
self.socket.recv(1024, socket.MSG_OOB)
int_data = memoryview(b"1234").cast('I')
self.assertRaises(TypeError, f, int_data)
+ def test_encodestring_warns(self):
+ with self.assertWarns(DeprecationWarning):
+ base64.encodestring(b"www.python.org")
+
+ def test_decodestring_warns(self):
+ with self.assertWarns(DeprecationWarning):
+ base64.decodestring(b"d3d3LnB5dGhvbi5vcmc=\n")
+
def test_encodebytes(self):
eq = self.assertEqual
eq(base64.encodebytes(b"www.python.org"), b"d3d3LnB5dGhvbi5vcmc=\n")
self.assertEqual(data, sorted(copy, reverse=1))
self.assertNotEqual(data, copy)
+ def test_bad_arguments(self):
+ # Issue #29327: The first argument is positional-only.
+ sorted([])
+ with self.assertRaises(TypeError):
+ sorted(iterable=[])
+ # Other arguments are keyword-only
+ sorted([], key=None)
+ with self.assertRaises(TypeError):
+ sorted([], None)
+
def test_inputtypes(self):
s = 'abracadabra'
types = [list, tuple, str]
the latter should be modernized).
"""
+import array
import os
import re
import sys
self.assertRaises(ValueError, self.type2test, [Indexable(-1)])
self.assertRaises(ValueError, self.type2test, [Indexable(256)])
+ def test_from_buffer(self):
+ a = self.type2test(array.array('B', [1, 2, 3]))
+ self.assertEqual(a, b"\x01\x02\x03")
+
+ # http://bugs.python.org/issue29159
+ # Fallback when __index__ raises exception other than OverflowError
+ class B(bytes):
+ def __index__(self):
+ raise TypeError
+
+ self.assertEqual(self.type2test(B(b"foobar")), b"foobar")
+
def test_from_ssize(self):
self.assertEqual(self.type2test(0), b'')
self.assertEqual(self.type2test(1), b'\x00')
import sys
import subprocess
import tempfile
-from test.support import script_helper
+from test.support import script_helper, is_android
from test.support.script_helper import (spawn_python, kill_python, assert_python_ok,
assert_python_failure)
if not stdout.startswith(pattern):
raise AssertionError("%a doesn't start with %a" % (stdout, pattern))
- @unittest.skipUnless(sys.platform == 'darwin', 'test specific to Mac OS X')
- def test_osx_utf8(self):
+ @unittest.skipUnless((sys.platform == 'darwin' or
+ is_android), 'test specific to Mac OS X and Android')
+ def test_osx_android_utf8(self):
def check_output(text):
decoded = text.decode('utf-8', 'surrogateescape')
expected = ascii(decoded).encode('ascii') + b'\n'
env = os.environ.copy()
# C locale gives ASCII locale encoding, but Python uses UTF-8
- # to parse the command line arguments on Mac OS X
+ # to parse the command line arguments on Mac OS X and Android.
env['LC_ALL'] = 'C'
p = subprocess.Popen(
import os.path
import py_compile
import subprocess
+import io
import textwrap
from test import support
text = stderr.decode('ascii')
self.assertEqual(text, "some text")
+ def test_syntaxerror_unindented_caret_position(self):
+ script = "1 + 1 = 2\n"
+ with support.temp_dir() as script_dir:
+ script_name = _make_test_script(script_dir, 'script', script)
+ exitcode, stdout, stderr = assert_python_failure(script_name)
+ text = io.TextIOWrapper(io.BytesIO(stderr), 'ascii').read()
+ # Confirm that the caret is located under the first 1 character
+ self.assertIn("\n 1 + 1 = 2\n ^", text)
+
+ def test_syntaxerror_indented_caret_position(self):
+ script = textwrap.dedent("""\
+ if True:
+ 1 + 1 = 2
+ """)
+ with support.temp_dir() as script_dir:
+ script_name = _make_test_script(script_dir, 'script', script)
+ exitcode, stdout, stderr = assert_python_failure(script_name)
+ text = io.TextIOWrapper(io.BytesIO(stderr), 'ascii').read()
+ # Confirm that the caret is located under the first 1 character
+ self.assertIn("\n 1 + 1 = 2\n ^", text)
+
+ # Try the same with a form feed at the start of the indented line
+ script = (
+ "if True:\n"
+ "\f 1 + 1 = 2\n"
+ )
+ script_name = _make_test_script(script_dir, "script", script)
+ exitcode, stdout, stderr = assert_python_failure(script_name)
+ text = io.TextIOWrapper(io.BytesIO(stderr), "ascii").read()
+ self.assertNotIn("\f", text)
+ self.assertIn("\n 1 + 1 = 2\n ^", text)
+
+ def test_consistent_sys_path_for_direct_execution(self):
+ # This test case ensures that the following all give the same
+ # sys.path configuration:
+ #
+ # ./python -s script_dir/__main__.py
+ # ./python -s script_dir
+ # ./python -I script_dir
+ script = textwrap.dedent("""\
+ import sys
+ for entry in sys.path:
+ print(entry)
+ """)
+ # Always show full path diffs on errors
+ self.maxDiff = None
+ with support.temp_dir() as work_dir, support.temp_dir() as script_dir:
+ script_name = _make_test_script(script_dir, '__main__', script)
+ # Reference output comes from directly executing __main__.py
+ # We omit PYTHONPATH and user site to align with isolated mode
+ p = spawn_python("-Es", script_name, cwd=work_dir)
+ out_by_name = kill_python(p).decode().splitlines()
+ self.assertEqual(out_by_name[0], script_dir)
+ self.assertNotIn(work_dir, out_by_name)
+ # Directory execution should give the same output
+ p = spawn_python("-Es", script_dir, cwd=work_dir)
+ out_by_dir = kill_python(p).decode().splitlines()
+ self.assertEqual(out_by_dir, out_by_name)
+ # As should directory execution in isolated mode
+ p = spawn_python("-I", script_dir, cwd=work_dir)
+ out_by_dir_isolated = kill_python(p).decode().splitlines()
+ self.assertEqual(out_by_dir_isolated, out_by_dir, out_by_name)
+
+ def test_consistent_sys_path_for_module_execution(self):
+ # This test case ensures that the following both give the same
+ # sys.path configuration:
+ # ./python -sm script_pkg.__main__
+ # ./python -sm script_pkg
+ #
+ # And that this fails as unable to find the package:
+ # ./python -Im script_pkg
+ script = textwrap.dedent("""\
+ import sys
+ for entry in sys.path:
+ print(entry)
+ """)
+ # Always show full path diffs on errors
+ self.maxDiff = None
+ with support.temp_dir() as work_dir:
+ script_dir = os.path.join(work_dir, "script_pkg")
+ os.mkdir(script_dir)
+ script_name = _make_test_script(script_dir, '__main__', script)
+ # Reference output comes from `-m script_pkg.__main__`
+ # We omit PYTHONPATH and user site to better align with the
+ # direct execution test cases
+ p = spawn_python("-sm", "script_pkg.__main__", cwd=work_dir)
+ out_by_module = kill_python(p).decode().splitlines()
+ self.assertEqual(out_by_module[0], '')
+ self.assertNotIn(script_dir, out_by_module)
+ # Package execution should give the same output
+ p = spawn_python("-sm", "script_pkg", cwd=work_dir)
+ out_by_package = kill_python(p).decode().splitlines()
+ self.assertEqual(out_by_package, out_by_module)
+ # Isolated mode should fail with an import error
+ exitcode, stdout, stderr = assert_python_failure(
+ "-Im", "script_pkg", cwd=work_dir
+ )
+ traceback_lines = stderr.decode().splitlines()
+ self.assertIn("No module named script_pkg", traceback_lines[-1])
def test_main():
support.run_unittest(CmdLineTest)
f1 = ns['f1']
f2 = ns['f2']
self.assertIsNot(f1.__code__, f2.__code__)
+ self.assertNotEqual(f1.__code__, f2.__code__)
self.check_constant(f1, const1)
self.check_constant(f2, const2)
self.assertEqual(repr(f1()), repr(const1))
check_different_constants(0, 0.0)
check_different_constants(+0.0, -0.0)
check_different_constants((0,), (0.0,))
+ check_different_constants('a', b'a')
+ check_different_constants(('a',), (b'a',))
# check_different_constants() cannot be used because repr(-0j) is
# '(-0-0j)', but when '(-0-0j)' is evaluated to 0j: we loose the sign.
self.assertAlmostEqual(complex(complex1(1j)), 2j)
self.assertRaises(TypeError, complex, complex2(1j))
+ @support.requires_IEEE_754
+ def test_constructor_special_numbers(self):
+ class complex2(complex):
+ pass
+ for x in 0.0, -0.0, INF, -INF, NAN:
+ for y in 0.0, -0.0, INF, -INF, NAN:
+ with self.subTest(x=x, y=y):
+ z = complex(x, y)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+ z = complex2(x, y)
+ self.assertIs(type(z), complex2)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+ z = complex(complex2(x, y))
+ self.assertIs(type(z), complex)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+ z = complex2(complex(x, y))
+ self.assertIs(type(z), complex2)
+ self.assertFloatsAreIdentical(z.real, x)
+ self.assertFloatsAreIdentical(z.imag, y)
+
def test_underscores(self):
# check underscores
for lit in VALID_UNDERSCORE_LITERALS:
import configparser
import io
import os
-import sys
+import pathlib
import textwrap
import unittest
import warnings
parsed_files = cf.read(file1)
self.assertEqual(parsed_files, [file1])
self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
+ # check when we pass only a Path object:
+ cf = self.newconfig()
+ parsed_files = cf.read(pathlib.Path(file1))
+ self.assertEqual(parsed_files, [file1])
+ self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
+ # check when we passed both a filename and a Path object:
+ cf = self.newconfig()
+ parsed_files = cf.read([pathlib.Path(file1), file1])
+ self.assertEqual(parsed_files, [file1, file1])
+ self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
# check when we pass only missing files:
cf = self.newconfig()
parsed_files = cf.read(["nonexistent-file"])
warnings.simplefilter("error")
run_async(foo())
+ def test_for_11(self):
+ class F:
+ def __aiter__(self):
+ return self
+ def __anext__(self):
+ return self
+ def __await__(self):
+ 1 / 0
+
+ async def main():
+ async for _ in F():
+ pass
+
+ with self.assertRaisesRegex(TypeError,
+ 'an invalid object from __anext__') as c:
+ main().send(None)
+
+ err = c.exception
+ self.assertIsInstance(err.__cause__, ZeroDivisionError)
+
+ def test_for_12(self):
+ class F:
+ def __aiter__(self):
+ return self
+ def __await__(self):
+ 1 / 0
+
+ async def main():
+ async for _ in F():
+ pass
+
+ with self.assertRaisesRegex(TypeError,
+ 'an invalid object from __aiter__') as c:
+ main().send(None)
+
+ err = c.exception
+ self.assertIsInstance(err.__cause__, ZeroDivisionError)
+
def test_for_tuple(self):
class Done(Exception): pass
curses = import_module('curses')
import_module('curses.panel')
import_module('curses.ascii')
+import_module('curses.textpad')
def requires_curses_func(name):
return unittest.skipUnless(hasattr(curses, name),
# Functions only available on a few platforms
def test_colors_funcs(self):
if not curses.has_colors():
- self.skip('requires colors support')
+ self.skipTest('requires colors support')
curses.start_color()
curses.init_pair(2, 1,1)
curses.color_content(1)
def test_getmouse(self):
(availmask, oldmask) = curses.mousemask(curses.BUTTON1_PRESSED)
if availmask == 0:
- self.skip('mouse stuff not available')
+ self.skipTest('mouse stuff not available')
curses.mouseinterval(10)
# just verify these don't cause errors
curses.ungetmouse(0, 0, 0, 0, curses.BUTTON1_PRESSED)
human_readable_signature = stdscr.addch.__doc__.split("\n")[0]
self.assertIn("[y, x,]", human_readable_signature)
+ def test_issue13051(self):
+ stdscr = self.stdscr
+ box = curses.textpad.Textbox(stdscr, insert_mode=True)
+ lines, cols = stdscr.getmaxyx()
+ stdscr.resize(lines-2, cols-2)
+ # this may cause infinite recursion, leading to a RuntimeError
+ box._insert_printable_char('a')
+
class MiscTests(unittest.TestCase):
check(curses.ascii.ispunct, c in string.punctuation)
check(curses.ascii.isxdigit, c in string.hexdigits)
+ for i in (-2, -1, 256, sys.maxunicode, sys.maxunicode+1):
+ self.assertFalse(curses.ascii.isalnum(i))
+ self.assertFalse(curses.ascii.isalpha(i))
+ self.assertFalse(curses.ascii.isdigit(i))
+ self.assertFalse(curses.ascii.islower(i))
+ self.assertFalse(curses.ascii.isspace(i))
+ self.assertFalse(curses.ascii.isupper(i))
+
+ self.assertFalse(curses.ascii.isascii(i))
+ self.assertFalse(curses.ascii.isctrl(i))
+ self.assertFalse(curses.ascii.iscntrl(i))
+ self.assertFalse(curses.ascii.isblank(i))
+ self.assertFalse(curses.ascii.isgraph(i))
+ self.assertFalse(curses.ascii.isprint(i))
+ self.assertFalse(curses.ascii.ispunct(i))
+ self.assertFalse(curses.ascii.isxdigit(i))
+
+ self.assertFalse(curses.ascii.ismeta(-1))
+
def test_ascii(self):
ascii = curses.ascii.ascii
self.assertEqual(ascii('\xc1'), 'A')
import io
import operator
import os
+import stat
import unittest
import warnings
import dbm.dumb as dumbdbm
f = dumbdbm.open(_fname, flag)
f.close()
+ @unittest.skipUnless(hasattr(os, 'chmod'), 'test needs os.chmod()')
+ def test_readonly_files(self):
+ with support.temp_dir() as dir:
+ fname = os.path.join(dir, 'db')
+ with dumbdbm.open(fname, 'n') as f:
+ self.assertEqual(list(f.keys()), [])
+ for key in self._dict:
+ f[key] = self._dict[key]
+ os.chmod(fname + ".dir", stat.S_IRUSR)
+ os.chmod(fname + ".dat", stat.S_IRUSR)
+ os.chmod(dir, stat.S_IRUSR|stat.S_IXUSR)
+ with dumbdbm.open(fname, 'r') as f:
+ self.assertEqual(sorted(f.keys()), sorted(self._dict))
+ f.close() # don't write
+
def tearDown(self):
_delete_files()
import sys
import types
import unittest
+import warnings
import weakref
from copy import deepcopy
self.assertEqual(b.foo, 3)
self.assertEqual(b.__class__, D)
+ @unittest.expectedFailure
+ def test_bad_new(self):
+ self.assertRaises(TypeError, object.__new__)
+ self.assertRaises(TypeError, object.__new__, '')
+ self.assertRaises(TypeError, list.__new__, object)
+ self.assertRaises(TypeError, object.__new__, list)
+ class C(object):
+ __new__ = list.__new__
+ self.assertRaises(TypeError, C)
+ class C(list):
+ __new__ = object.__new__
+ self.assertRaises(TypeError, C)
+
+ def test_object_new(self):
+ class A(object):
+ pass
+ object.__new__(A)
+ self.assertRaises(TypeError, object.__new__, A, 5)
+ object.__init__(A())
+ self.assertRaises(TypeError, object.__init__, A(), 5)
+
+ class A(object):
+ def __init__(self, foo):
+ self.foo = foo
+ object.__new__(A)
+ object.__new__(A, 5)
+ object.__init__(A(3))
+ self.assertRaises(TypeError, object.__init__, A(3), 5)
+
+ class A(object):
+ def __new__(cls, foo):
+ return object.__new__(cls)
+ object.__new__(A)
+ self.assertRaises(TypeError, object.__new__, A, 5)
+ object.__init__(A(3))
+ object.__init__(A(3), 5)
+
+ class A(object):
+ def __new__(cls, foo):
+ return object.__new__(cls)
+ def __init__(self, foo):
+ self.foo = foo
+ object.__new__(A)
+ self.assertRaises(TypeError, object.__new__, A, 5)
+ object.__init__(A(3))
+ self.assertRaises(TypeError, object.__init__, A(3), 5)
+
+ @unittest.expectedFailure
+ def test_restored_object_new(self):
+ class A(object):
+ def __new__(cls, *args, **kwargs):
+ raise AssertionError
+ self.assertRaises(AssertionError, A)
+ class B(A):
+ __new__ = object.__new__
+ def __init__(self, foo):
+ self.foo = foo
+ with warnings.catch_warnings():
+ warnings.simplefilter('error', DeprecationWarning)
+ b = B(3)
+ self.assertEqual(b.foo, 3)
+ self.assertEqual(b.__class__, B)
+ del B.__new__
+ self.assertRaises(AssertionError, B)
+ del A.__new__
+ with warnings.catch_warnings():
+ warnings.simplefilter('error', DeprecationWarning)
+ b = B(3)
+ self.assertEqual(b.foo, 3)
+ self.assertEqual(b.__class__, B)
+
def test_altmro(self):
# Testing mro() and overriding it...
class A(object):
self.assertIsInstance(d, D)
self.assertEqual(d.foo, 1)
+ class C(object):
+ @staticmethod
+ def __new__(*args):
+ return args
+ self.assertEqual(C(1, 2), (C, 1, 2))
+ class D(C):
+ pass
+ self.assertEqual(D(1, 2), (D, 1, 2))
+
+ class C(object):
+ @classmethod
+ def __new__(*args):
+ return args
+ self.assertEqual(C(1, 2), (C, C, 1, 2))
+ class D(C):
+ pass
+ self.assertEqual(D(1, 2), (D, D, 1, 2))
+
def test_imul_bug(self):
# Testing for __imul__ problems...
# SF bug 544647
from io import StringIO, BytesIO
from itertools import chain
from random import choice
+from socket import getfqdn
try:
from threading import Thread
except ImportError:
email.utils.make_msgid(domain='testdomain-string')[-19:],
'@testdomain-string>')
+ def test_make_msgid_idstring(self):
+ self.assertEqual(
+ email.utils.make_msgid(idstring='test-idstring',
+ domain='testdomain-string')[-33:],
+ '.test-idstring@testdomain-string>')
+
+ def test_make_msgid_default_domain(self):
+ self.assertTrue(
+ email.utils.make_msgid().endswith(
+ '@' + getfqdn() + '>'))
+
def test_Generator_linend(self):
# Issue 14645.
with openfile('msg_26.txt', newline='\n') as f:
from io import StringIO
from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
from test import support
+try:
+ import threading
+except ImportError:
+ threading = None
+
# for pickle tests
try:
d = 6
self.assertEqual(repr(Bizarre(7)), '<Bizarre.d|c|b: 7>')
+ @unittest.skipUnless(threading, 'Threading required for this test.')
+ @support.reap_threads
+ def test_unique_composite(self):
+ # override __eq__ to be identity only
+ class TestFlag(Flag):
+ one = auto()
+ two = auto()
+ three = auto()
+ four = auto()
+ five = auto()
+ six = auto()
+ seven = auto()
+ eight = auto()
+ def __eq__(self, other):
+ return self is other
+ def __hash__(self):
+ return hash(self._value_)
+ # have multiple threads competing to complete the composite members
+ seen = set()
+ failed = False
+ def cycle_enum():
+ nonlocal failed
+ try:
+ for i in range(256):
+ seen.add(TestFlag(i))
+ except Exception:
+ failed = True
+ threads = [
+ threading.Thread(target=cycle_enum)
+ for _ in range(8)
+ ]
+ with support.start_threads(threads):
+ pass
+ # check that only 248 members were created
+ self.assertFalse(
+ failed,
+ 'at least one thread failed while creating composite members')
+ self.assertEqual(256, len(seen), 'too many composite members created')
+
class TestIntFlag(unittest.TestCase):
"""Tests of the IntFlags."""
for f in Open:
self.assertEqual(bool(f.value), bool(f))
+ @unittest.skipUnless(threading, 'Threading required for this test.')
+ @support.reap_threads
+ def test_unique_composite(self):
+ # override __eq__ to be identity only
+ class TestFlag(IntFlag):
+ one = auto()
+ two = auto()
+ three = auto()
+ four = auto()
+ five = auto()
+ six = auto()
+ seven = auto()
+ eight = auto()
+ def __eq__(self, other):
+ return self is other
+ def __hash__(self):
+ return hash(self._value_)
+ # have multiple threads competing to complete the composite members
+ seen = set()
+ failed = False
+ def cycle_enum():
+ nonlocal failed
+ try:
+ for i in range(256):
+ seen.add(TestFlag(i))
+ except Exception:
+ failed = True
+ threads = [
+ threading.Thread(target=cycle_enum)
+ for _ in range(8)
+ ]
+ with support.start_threads(threads):
+ pass
+ # check that only 248 members were created
+ self.assertFalse(
+ failed,
+ 'at least one thread failed while creating composite members')
+ self.assertEqual(256, len(seen), 'too many composite members created')
+
+
class TestUnique(unittest.TestCase):
def test_unique_clean(self):
class TestIntEnumConvert(unittest.TestCase):
def test_convert_value_lookup_priority(self):
test_type = enum.IntEnum._convert(
- 'UnittestConvert', 'test.test_enum',
+ 'UnittestConvert',
+ ('test.test_enum', '__main__')[__name__=='__main__'],
filter=lambda x: x.startswith('CONVERT_TEST_'))
# We don't want the reverse lookup value to vary when there are
# multiple possible names for a given value. It should always
def test_convert(self):
test_type = enum.IntEnum._convert(
- 'UnittestConvert', 'test.test_enum',
+ 'UnittestConvert',
+ ('test.test_enum', '__main__')[__name__=='__main__'],
filter=lambda x: x.startswith('CONVERT_TEST_'))
# Ensure that test_type has all of the desired names and values.
self.assertEqual(test_type.CONVERT_TEST_NAME_F,
from weakref import proxy
from functools import wraps
-from test.support import TESTFN, check_warnings, run_unittest, make_bad_fd, cpython_only
+from test.support import (TESTFN, TESTFN_UNICODE, check_warnings, run_unittest,
+ make_bad_fd, cpython_only)
from collections import UserList
import _io # C implementation of io
finally:
os.unlink(TESTFN)
+ @unittest.skipIf(sys.getfilesystemencoding() != 'utf-8',
+ "test only works for utf-8 filesystems")
+ def testUtf8BytesOpen(self):
+ # Opening a UTF-8 bytes filename
+ try:
+ fn = TESTFN_UNICODE.encode("utf-8")
+ except UnicodeEncodeError:
+ self.skipTest('could not encode %r to utf-8' % TESTFN_UNICODE)
+ f = self.FileIO(fn, "w")
+ try:
+ f.write(b"abc")
+ f.close()
+ with open(TESTFN_UNICODE, "rb") as f:
+ self.assertEqual(f.read(), b"abc")
+ finally:
+ os.unlink(TESTFN_UNICODE)
+
def testConstructorHandlesNULChars(self):
fn_with_NUL = 'foo\0bar'
self.assertRaises(ValueError, self.FileIO, fn_with_NUL, 'w')
testcommon("%o", 100000000000, "1351035564000")
testcommon("%d", 10, "10")
testcommon("%d", 100000000000, "100000000000")
+
big = 123456789012345678901234567890
testcommon("%d", big, "123456789012345678901234567890")
testcommon("%d", -big, "-123456789012345678901234567890")
testcommon("%.31d", big, "0123456789012345678901234567890")
testcommon("%32.31d", big, " 0123456789012345678901234567890")
testcommon("%d", float(big), "123456________________________", 6)
+
big = 0x1234567890abcdef12345 # 21 hex digits
testcommon("%x", big, "1234567890abcdef12345")
testcommon("%x", -big, "-1234567890abcdef12345")
testcommon("%#X", big, "0X1234567890ABCDEF12345")
testcommon("%#x", big, "0x1234567890abcdef12345")
testcommon("%#x", -big, "-0x1234567890abcdef12345")
+ testcommon("%#27x", big, " 0x1234567890abcdef12345")
+ testcommon("%#-27x", big, "0x1234567890abcdef12345 ")
+ testcommon("%#027x", big, "0x00001234567890abcdef12345")
+ testcommon("%#.23x", big, "0x001234567890abcdef12345")
testcommon("%#.23x", -big, "-0x001234567890abcdef12345")
+ testcommon("%#27.23x", big, " 0x001234567890abcdef12345")
+ testcommon("%#-27.23x", big, "0x001234567890abcdef12345 ")
+ testcommon("%#027.23x", big, "0x00001234567890abcdef12345")
testcommon("%#+.23x", big, "+0x001234567890abcdef12345")
testcommon("%# .23x", big, " 0x001234567890abcdef12345")
testcommon("%#+.23X", big, "+0X001234567890ABCDEF12345")
- testcommon("%#-+.23X", big, "+0X001234567890ABCDEF12345")
- testcommon("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
- testcommon("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
- testcommon("%#+27.23X", big, " +0X001234567890ABCDEF12345")
# next one gets two leading zeroes from precision, and another from the
# 0 flag and the width
testcommon("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
+ testcommon("%# 027.23X", big, " 0X0001234567890ABCDEF12345")
# same, except no 0 flag
testcommon("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+ testcommon("%#-+27.23x", big, "+0x001234567890abcdef12345 ")
+ testcommon("%#- 27.23x", big, " 0x001234567890abcdef12345 ")
+
big = 0o12345670123456701234567012345670 # 32 octal digits
testcommon("%o", big, "12345670123456701234567012345670")
testcommon("%o", -big, "-12345670123456701234567012345670")
testcommon("%o", big, "12345670123456701234567012345670")
testcommon("%#o", big, "0o12345670123456701234567012345670")
testcommon("%#o", -big, "-0o12345670123456701234567012345670")
+ testcommon("%#38o", big, " 0o12345670123456701234567012345670")
+ testcommon("%#-38o", big, "0o12345670123456701234567012345670 ")
+ testcommon("%#038o", big, "0o000012345670123456701234567012345670")
+ testcommon("%#.34o", big, "0o0012345670123456701234567012345670")
testcommon("%#.34o", -big, "-0o0012345670123456701234567012345670")
+ testcommon("%#38.34o", big, " 0o0012345670123456701234567012345670")
+ testcommon("%#-38.34o", big, "0o0012345670123456701234567012345670 ")
+ testcommon("%#038.34o", big, "0o000012345670123456701234567012345670")
testcommon("%#+.34o", big, "+0o0012345670123456701234567012345670")
testcommon("%# .34o", big, " 0o0012345670123456701234567012345670")
- testcommon("%#+.34o", big, "+0o0012345670123456701234567012345670")
- testcommon("%#-+.34o", big, "+0o0012345670123456701234567012345670")
- testcommon("%#-+37.34o", big, "+0o0012345670123456701234567012345670")
- testcommon("%#+37.34o", big, "+0o0012345670123456701234567012345670")
+ testcommon("%#+38.34o", big, " +0o0012345670123456701234567012345670")
+ testcommon("%#-+38.34o", big, "+0o0012345670123456701234567012345670 ")
+ testcommon("%#- 38.34o", big, " 0o0012345670123456701234567012345670 ")
+ testcommon("%#+038.34o", big, "+0o00012345670123456701234567012345670")
+ testcommon("%# 038.34o", big, " 0o00012345670123456701234567012345670")
# next one gets one leading zero from precision
testcommon("%.33o", big, "012345670123456701234567012345670")
- # base marker shouldn't change that, since "0" is redundant
+ # base marker added in spite of leading zero (different to Python 2)
testcommon("%#.33o", big, "0o012345670123456701234567012345670")
- # but reduce precision, and base marker should add a zero
+ # reduce precision, and base marker is always added
testcommon("%#.32o", big, "0o12345670123456701234567012345670")
- # one leading zero from precision, and another from "0" flag & width
- testcommon("%034.33o", big, "0012345670123456701234567012345670")
- # base marker shouldn't change that
- testcommon("%0#34.33o", big, "0o012345670123456701234567012345670")
+ # one leading zero from precision, plus two from "0" flag & width
+ testcommon("%035.33o", big, "00012345670123456701234567012345670")
+ # base marker shouldn't change the size
+ testcommon("%0#35.33o", big, "0o012345670123456701234567012345670")
+
# Some small ints, in both Python int and flavors).
testcommon("%d", 42, "42")
testcommon("%d", -42, "-42")
- testcommon("%d", 42, "42")
- testcommon("%d", -42, "-42")
testcommon("%d", 42.0, "42")
testcommon("%#x", 1, "0x1")
- testcommon("%#x", 1, "0x1")
testcommon("%#X", 1, "0X1")
- testcommon("%#X", 1, "0X1")
- testcommon("%#o", 1, "0o1")
testcommon("%#o", 1, "0o1")
testcommon("%#o", 0, "0o0")
- testcommon("%#o", 0, "0o0")
- testcommon("%o", 0, "0")
testcommon("%o", 0, "0")
testcommon("%d", 0, "0")
- testcommon("%d", 0, "0")
testcommon("%#x", 0, "0x0")
- testcommon("%#x", 0, "0x0")
- testcommon("%#X", 0, "0X0")
testcommon("%#X", 0, "0X0")
testcommon("%x", 0x42, "42")
testcommon("%x", -0x42, "-42")
- testcommon("%x", 0x42, "42")
- testcommon("%x", -0x42, "-42")
- testcommon("%o", 0o42, "42")
- testcommon("%o", -0o42, "-42")
testcommon("%o", 0o42, "42")
testcommon("%o", -0o42, "-42")
# alternate float formatting
else:
raise TestFailed('"%*d"%(maxsize, -127) should fail')
+ def test_nul(self):
+ # test the null character
+ testcommon("a\0b", (), 'a\0b')
+ testcommon("a%cb", (0,), 'a\0b')
+ testformat("a%sb", ('c\0d',), 'ac\0db')
+ testcommon(b"a%sb", (b'c\0d',), b'ac\0db')
+
def test_non_ascii(self):
testformat("\u20ac=%f", (1.0,), "\u20ac=1.000000")
# Make sure x was called.
self.assertTrue(x.called)
- def test_literal_eval(self):
- # With no expressions, an f-string is okay.
- self.assertEqual(ast.literal_eval("f'x'"), 'x')
- self.assertEqual(ast.literal_eval("f'x' 'y'"), 'xy')
-
- # But this should raise an error.
- with self.assertRaisesRegex(ValueError, 'malformed node or string'):
- ast.literal_eval("f'x{3}'")
+ def test_docstring(self):
+ def f():
+ f'''Not a docstring'''
+ self.assertIsNone(f.__doc__)
+ def g():
+ '''Not a docstring''' \
+ f''
+ self.assertIsNone(g.__doc__)
- # As should this, which uses a different ast node
+ def test_literal_eval(self):
with self.assertRaisesRegex(ValueError, 'malformed node or string'):
- ast.literal_eval("f'{3}'")
+ ast.literal_eval("f'x'")
def test_ast_compile_time_concat(self):
x = ['']
import abc
+import builtins
import collections
import copy
from itertools import permutations
from random import choice
import sys
from test import support
+import time
import unittest
from weakref import proxy
import contextlib
p(b=7)
self.assertEqual(d, {'a':3})
+ def test_kwargs_copy(self):
+ # Issue #29532: Altering a kwarg dictionary passed to a constructor
+ # should not affect a partial object after creation
+ d = {'a': 3}
+ p = self.partial(capture, **d)
+ self.assertEqual(p(), ((), {'a': 3}))
+ d['a'] = 5
+ self.assertEqual(p(), ((), {'a': 3}))
+
def test_arg_combinations(self):
# exercise special code paths for zero args in either partial
# object or the caller
self.assertEqual(misses, 4)
self.assertEqual(currsize, 2)
+ def test_lru_reentrancy_with_len(self):
+ # Test to make sure the LRU cache code isn't thrown-off by
+ # caching the built-in len() function. Since len() can be
+ # cached, we shouldn't use it inside the lru code itself.
+ old_len = builtins.len
+ try:
+ builtins.len = self.module.lru_cache(4)(len)
+ for i in [0, 0, 1, 2, 3, 3, 4, 5, 6, 1, 7, 2, 1]:
+ self.assertEqual(len('abcdefghijklmn'[:i]), i)
+ finally:
+ builtins.len = old_len
+
def test_lru_type_error(self):
# Regression test for issue #28653.
# lru_cache was leaking when one of the arguments
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=0, misses=0, maxsize=None, currsize=0))
+ def test_kwargs_order(self):
+ # PEP 468: Preserving Keyword Argument Order
+ @self.module.lru_cache(maxsize=10)
+ def f(**kwargs):
+ return list(kwargs.items())
+ self.assertEqual(f(a=1, b=2), [('a', 1), ('b', 2)])
+ self.assertEqual(f(b=2, a=1), [('b', 2), ('a', 1)])
+ self.assertEqual(f.cache_info(),
+ self.module._CacheInfo(hits=0, misses=2, maxsize=10, currsize=2))
+
def test_lru_cache_decoration(self):
def f(zomg: 'zomg_annotation'):
"""f doc string"""
f.cache_clear()
orig_si = sys.getswitchinterval()
- sys.setswitchinterval(1e-6)
+ support.setswitchinterval(1e-6)
try:
# create n threads in order to fill cache
threads = [threading.Thread(target=full, args=[k])
pause.reset()
self.assertEqual(f.cache_info(), (0, (i+1)*n, m*n, i+1))
+ @unittest.skipUnless(threading, 'This test requires threading.')
+ def test_lru_cache_threaded3(self):
+ @self.module.lru_cache(maxsize=2)
+ def f(x):
+ time.sleep(.01)
+ return 3 * x
+ def test(i, x):
+ with self.subTest(thread=i):
+ self.assertEqual(f(x), 3 * x, i)
+ threads = [threading.Thread(target=test, args=(i, v))
+ for i, v in enumerate([1, 2, 2, 3, 2])]
+ with support.start_threads(threads):
+ pass
+
def test_need_for_rlock(self):
# This will deadlock on an LRU cache that uses a regular lock
import unittest
from test import support
+import os
import re
rx = re.compile(r'\((\S+).py, line (\d+)')
class FutureTest(unittest.TestCase):
+ def check_syntax_error(self, err, basename, lineno, offset=0):
+ self.assertIn('%s.py, line %d' % (basename, lineno), str(err))
+ self.assertEqual(os.path.basename(err.filename), basename + '.py')
+ self.assertEqual(err.lineno, lineno)
+ self.assertEqual(err.offset, offset)
+
def test_future1(self):
with support.CleanImport('future_test1'):
from test import future_test1
from test import test_future3
def test_badfuture3(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future3
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future3", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future3", 3)
def test_badfuture4(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future4
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future4", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future4", 3)
def test_badfuture5(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future5
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future5", '4'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future5", 4)
def test_badfuture6(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future6
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future6", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future6", 3)
def test_badfuture7(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future7
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future7", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future7", 3, 53)
def test_badfuture8(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future8
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future8", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future8", 3)
def test_badfuture9(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future9
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future9", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future9", 3, 0)
def test_badfuture10(self):
- try:
+ with self.assertRaises(SyntaxError) as cm:
from test import badsyntax_future10
- except SyntaxError as msg:
- self.assertEqual(get_error_location(msg), ("badsyntax_future10", '3'))
- else:
- self.fail("expected exception didn't occur")
+ self.check_syntax_error(cm.exception, "badsyntax_future10", 3, 0)
def test_parserhack(self):
# test that the parser.c::future_hack function works as expected
import unittest
import warnings
from test import support
+android_not_root = support.android_not_root
def create_file(filename, data=b'foo'):
def test_samefile_on_symlink(self):
self._test_samefile_on_link_func(os.symlink)
+ @unittest.skipIf(android_not_root, "hard links not allowed, non root user")
def test_samefile_on_link(self):
self._test_samefile_on_link_func(os.link)
def test_samestat_on_symlink(self):
self._test_samestat_on_link_func(os.symlink)
+ @unittest.skipIf(android_not_root, "hard links not allowed, non root user")
def test_samestat_on_link(self):
self._test_samestat_on_link_func(os.link)
global a
global b
"""
- check_syntax_error(self, prog_text_1)
+ check_syntax_error(self, prog_text_1, lineno=4, offset=4)
def test2(self):
prog_text_2 = """\
print(x)
global x
"""
- check_syntax_error(self, prog_text_2)
+ check_syntax_error(self, prog_text_2, lineno=3, offset=4)
def test3(self):
prog_text_3 = """\
x = 2
global x
"""
- check_syntax_error(self, prog_text_3)
+ check_syntax_error(self, prog_text_3, lineno=4, offset=4)
def test4(self):
prog_text_4 = """\
import socketserver
import time
import calendar
+import inspect
from test.support import (reap_threads, verbose, transient_internet,
run_with_tz, run_with_locale)
import unittest
+from unittest import mock
from datetime import datetime, timezone, timedelta
try:
import ssl
self._send_tagged(tag, 'OK', 'LOGIN completed')
+class NewIMAPTestsMixin():
+ client = None
+
+ def _setup(self, imap_handler, connect=True):
+ """
+ Sets up imap_handler for tests. imap_handler should inherit from either:
+ - SimpleIMAPHandler - for testing IMAP commands,
+ - socketserver.StreamRequestHandler - if raw access to stream is needed.
+ Returns (client, server).
+ """
+ class TestTCPServer(self.server_class):
+ def handle_error(self, request, client_address):
+ """
+ End request and raise the error if one occurs.
+ """
+ self.close_request(request)
+ self.server_close()
+ raise
+
+ self.addCleanup(self._cleanup)
+ self.server = self.server_class((support.HOST, 0), imap_handler)
+ self.thread = threading.Thread(
+ name=self._testMethodName+'-server',
+ target=self.server.serve_forever,
+ # Short poll interval to make the test finish quickly.
+ # Time between requests is short enough that we won't wake
+ # up spuriously too many times.
+ kwargs={'poll_interval': 0.01})
+ self.thread.daemon = True # In case this function raises.
+ self.thread.start()
+
+ if connect:
+ self.client = self.imap_class(*self.server.server_address)
+
+ return self.client, self.server
+
+ def _cleanup(self):
+ """
+ Cleans up the test server. This method should not be called manually,
+ it is added to the cleanup queue in the _setup method already.
+ """
+ # if logout was called already we'd raise an exception trying to
+ # shutdown the client once again
+ if self.client is not None and self.client.state != 'LOGOUT':
+ self.client.shutdown()
+ # cleanup the server
+ self.server.shutdown()
+ self.server.server_close()
+ self.thread.join(3.0)
+
+ def test_EOF_without_complete_welcome_message(self):
+ # http://bugs.python.org/issue5949
+ class EOFHandler(socketserver.StreamRequestHandler):
+ def handle(self):
+ self.wfile.write(b'* OK')
+ _, server = self._setup(EOFHandler, connect=False)
+ self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
+ *server.server_address)
+
+ def test_line_termination(self):
+ class BadNewlineHandler(SimpleIMAPHandler):
+ def cmd_CAPABILITY(self, tag, args):
+ self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
+ self._send_tagged(tag, 'OK', 'CAPABILITY completed')
+ _, server = self._setup(BadNewlineHandler, connect=False)
+ self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
+ *server.server_address)
+
+ def test_enable_raises_error_if_not_AUTH(self):
+ class EnableHandler(SimpleIMAPHandler):
+ capabilities = 'AUTH ENABLE UTF8=ACCEPT'
+ client, _ = self._setup(EnableHandler)
+ self.assertFalse(client.utf8_enabled)
+ with self.assertRaisesRegex(imaplib.IMAP4.error, 'ENABLE.*NONAUTH'):
+ client.enable('foo')
+ self.assertFalse(client.utf8_enabled)
+
+ def test_enable_raises_error_if_no_capability(self):
+ client, _ = self._setup(SimpleIMAPHandler)
+ with self.assertRaisesRegex(imaplib.IMAP4.error,
+ 'does not support ENABLE'):
+ client.enable('foo')
+
+ def test_enable_UTF8_raises_error_if_not_supported(self):
+ client, _ = self._setup(SimpleIMAPHandler)
+ typ, data = client.login('user', 'pass')
+ self.assertEqual(typ, 'OK')
+ with self.assertRaisesRegex(imaplib.IMAP4.error,
+ 'does not support ENABLE'):
+ client.enable('UTF8=ACCEPT')
+
+ def test_enable_UTF8_True_append(self):
+ class UTF8AppendServer(SimpleIMAPHandler):
+ capabilities = 'ENABLE UTF8=ACCEPT'
+ def cmd_ENABLE(self, tag, args):
+ self._send_tagged(tag, 'OK', 'ENABLE successful')
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+')
+ self.server.response = yield
+ self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+ def cmd_APPEND(self, tag, args):
+ self._send_textline('+')
+ self.server.response = yield
+ self._send_tagged(tag, 'OK', 'okay')
+ client, server = self._setup(UTF8AppendServer)
+ self.assertEqual(client._encoding, 'ascii')
+ code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+ self.assertEqual(code, 'OK')
+ self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
+ code, _ = client.enable('UTF8=ACCEPT')
+ self.assertEqual(code, 'OK')
+ self.assertEqual(client._encoding, 'utf-8')
+ msg_string = 'Subject: üñí©öðé'
+ typ, data = client.append(None, None, None, msg_string.encode('utf-8'))
+ self.assertEqual(typ, 'OK')
+ self.assertEqual(server.response,
+ ('UTF8 (%s)\r\n' % msg_string).encode('utf-8'))
+
+ def test_search_disallows_charset_in_utf8_mode(self):
+ class UTF8Server(SimpleIMAPHandler):
+ capabilities = 'AUTH ENABLE UTF8=ACCEPT'
+ def cmd_ENABLE(self, tag, args):
+ self._send_tagged(tag, 'OK', 'ENABLE successful')
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+')
+ self.server.response = yield
+ self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+ client, _ = self._setup(UTF8Server)
+ typ, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+ self.assertEqual(typ, 'OK')
+ typ, _ = client.enable('UTF8=ACCEPT')
+ self.assertEqual(typ, 'OK')
+ self.assertTrue(client.utf8_enabled)
+ with self.assertRaisesRegex(imaplib.IMAP4.error, 'charset.*UTF8'):
+ client.search('foo', 'bar')
+
+ def test_bad_auth_name(self):
+ class MyServer(SimpleIMAPHandler):
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_tagged(tag, 'NO',
+ 'unrecognized authentication type {}'.format(args[0]))
+ client, _ = self._setup(MyServer)
+ with self.assertRaisesRegex(imaplib.IMAP4.error,
+ 'unrecognized authentication type METHOD'):
+ client.authenticate('METHOD', lambda: 1)
+
+ def test_invalid_authentication(self):
+ class MyServer(SimpleIMAPHandler):
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+')
+ self.response = yield
+ self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
+ client, _ = self._setup(MyServer)
+ with self.assertRaisesRegex(imaplib.IMAP4.error,
+ r'\[AUTHENTICATIONFAILED\] invalid'):
+ client.authenticate('MYAUTH', lambda x: b'fake')
+
+ def test_valid_authentication_bytes(self):
+ class MyServer(SimpleIMAPHandler):
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+')
+ self.server.response = yield
+ self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+ client, server = self._setup(MyServer)
+ code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+ self.assertEqual(code, 'OK')
+ self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
+
+ def test_valid_authentication_plain_text(self):
+ class MyServer(SimpleIMAPHandler):
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+')
+ self.server.response = yield
+ self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+ client, server = self._setup(MyServer)
+ code, _ = client.authenticate('MYAUTH', lambda x: 'fake')
+ self.assertEqual(code, 'OK')
+ self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
+
+ def test_login_cram_md5_bytes(self):
+ class AuthHandler(SimpleIMAPHandler):
+ capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
+ 'VzdG9uLm1jaS5uZXQ=')
+ r = yield
+ if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
+ b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
+ self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
+ else:
+ self._send_tagged(tag, 'NO', 'No access')
+ client, _ = self._setup(AuthHandler)
+ self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
+ ret, _ = client.login_cram_md5("tim", b"tanstaaftanstaaf")
+ self.assertEqual(ret, "OK")
+
+ def test_login_cram_md5_plain_text(self):
+ class AuthHandler(SimpleIMAPHandler):
+ capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
+ 'VzdG9uLm1jaS5uZXQ=')
+ r = yield
+ if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
+ b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
+ self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
+ else:
+ self._send_tagged(tag, 'NO', 'No access')
+ client, _ = self._setup(AuthHandler)
+ self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
+ ret, _ = client.login_cram_md5("tim", "tanstaaftanstaaf")
+ self.assertEqual(ret, "OK")
+
+ def test_aborted_authentication(self):
+ class MyServer(SimpleIMAPHandler):
+ def cmd_AUTHENTICATE(self, tag, args):
+ self._send_textline('+')
+ self.response = yield
+ if self.response == b'*\r\n':
+ self._send_tagged(
+ tag,
+ 'NO',
+ '[AUTHENTICATIONFAILED] aborted')
+ else:
+ self._send_tagged(tag, 'OK', 'MYAUTH successful')
+ client, _ = self._setup(MyServer)
+ with self.assertRaisesRegex(imaplib.IMAP4.error,
+ r'\[AUTHENTICATIONFAILED\] aborted'):
+ client.authenticate('MYAUTH', lambda x: None)
+
+ @mock.patch('imaplib._MAXLINE', 10)
+ def test_linetoolong(self):
+ class TooLongHandler(SimpleIMAPHandler):
+ def handle(self):
+ # send response line longer than the limit set in the next line
+ self.wfile.write(b'* OK ' + 11 * b'x' + b'\r\n')
+ _, server = self._setup(TooLongHandler, connect=False)
+ with self.assertRaisesRegex(imaplib.IMAP4.error,
+ 'got more than 10 bytes'):
+ self.imap_class(*server.server_address)
+
+ def test_simple_with_statement(self):
+ _, server = self._setup(SimpleIMAPHandler, connect=False)
+ with self.imap_class(*server.server_address):
+ pass
+
+ def test_with_statement(self):
+ _, server = self._setup(SimpleIMAPHandler, connect=False)
+ with self.imap_class(*server.server_address) as imap:
+ imap.login('user', 'pass')
+ self.assertEqual(server.logged, 'user')
+ self.assertIsNone(server.logged)
+
+ def test_with_statement_logout(self):
+ # It is legal to log out explicitly inside the with block
+ _, server = self._setup(SimpleIMAPHandler, connect=False)
+ with self.imap_class(*server.server_address) as imap:
+ imap.login('user', 'pass')
+ self.assertEqual(server.logged, 'user')
+ imap.logout()
+ self.assertIsNone(server.logged)
+ self.assertIsNone(server.logged)
+
+ # command tests
+
+ def test_login(self):
+ client, _ = self._setup(SimpleIMAPHandler)
+ typ, data = client.login('user', 'pass')
+ self.assertEqual(typ, 'OK')
+ self.assertEqual(data[0], b'LOGIN completed')
+ self.assertEqual(client.state, 'AUTH')
+
+ def test_logout(self):
+ client, _ = self._setup(SimpleIMAPHandler)
+ typ, data = client.login('user', 'pass')
+ self.assertEqual(typ, 'OK')
+ self.assertEqual(data[0], b'LOGIN completed')
+ typ, data = client.logout()
+ self.assertEqual(typ, 'BYE')
+ self.assertEqual(data[0], b'IMAP4ref1 Server logging out')
+ self.assertEqual(client.state, 'LOGOUT')
+
+ def test_lsub(self):
+ class LsubCmd(SimpleIMAPHandler):
+ def cmd_LSUB(self, tag, args):
+ self._send_textline('* LSUB () "." directoryA')
+ return self._send_tagged(tag, 'OK', 'LSUB completed')
+ client, _ = self._setup(LsubCmd)
+ client.login('user', 'pass')
+ typ, data = client.lsub()
+ self.assertEqual(typ, 'OK')
+ self.assertEqual(data[0], b'() "." directoryA')
+
+
+class NewIMAPTests(NewIMAPTestsMixin, unittest.TestCase):
+ imap_class = imaplib.IMAP4
+ server_class = socketserver.TCPServer
+
+
+@unittest.skipUnless(ssl, "SSL not available")
+class NewIMAPSSLTests(NewIMAPTestsMixin, unittest.TestCase):
+ imap_class = IMAP4_SSL
+ server_class = SecureTCPServer
+
+ def test_ssl_raises(self):
+ ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+ ssl_context.verify_mode = ssl.CERT_REQUIRED
+ ssl_context.check_hostname = True
+ ssl_context.load_verify_locations(CAFILE)
+
+ with self.assertRaisesRegex(ssl.CertificateError,
+ "hostname '127.0.0.1' doesn't match 'localhost'"):
+ _, server = self._setup(SimpleIMAPHandler)
+ client = self.imap_class(*server.server_address,
+ ssl_context=ssl_context)
+ client.shutdown()
+
+ def test_ssl_verified(self):
+ ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+ ssl_context.verify_mode = ssl.CERT_REQUIRED
+ ssl_context.check_hostname = True
+ ssl_context.load_verify_locations(CAFILE)
+
+ _, server = self._setup(SimpleIMAPHandler)
+ client = self.imap_class("localhost", server.server_address[1],
+ ssl_context=ssl_context)
+ client.shutdown()
+
class ThreadedNetworkedTests(unittest.TestCase):
server_class = socketserver.TCPServer
imap_class = imaplib.IMAP4
def setUp(self):
try:
self.old_switchinterval = sys.getswitchinterval()
- sys.setswitchinterval(0.000001)
+ support.setswitchinterval(0.000001)
except AttributeError:
self.old_switchinterval = None
# Check filename override
self.assertEqual(inspect.getmodule(None, modfile), mod)
+ def test_getframeinfo_get_first_line(self):
+ frame_info = inspect.getframeinfo(self.fodderModule.fr, 50)
+ self.assertEqual(frame_info.code_context[0], "# line 1\n")
+ self.assertEqual(frame_info.code_context[1], "'A module docstring.'\n")
+
def test_getsource(self):
self.assertSourceEqual(git.abuse, 29, 39)
self.assertSourceEqual(mod.StupidGit, 21, 51)
-from test.support import verbose
+from test.support import verbose, is_android
import unittest
import locale
import sys
enc = codecs.lookup(locale.getpreferredencoding(False) or 'ascii').name
if enc not in ('utf-8', 'iso8859-1', 'cp1252'):
raise unittest.SkipTest('encoding not suitable')
- if enc != 'iso8859-1' and (sys.platform == 'darwin' or
+ if enc != 'iso8859-1' and (sys.platform == 'darwin' or is_android or
sys.platform.startswith('freebsd')):
raise unittest.SkipTest('wcscoll/wcsxfrm have known bugs')
BaseLocalizedTest.setUp(self)
-# Copyright 2001-2016 by Vinay Sajip. All Rights Reserved.
+# Copyright 2001-2017 by Vinay Sajip. All Rights Reserved.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose and without fee is hereby granted,
"""Test harness for the logging module. Run all tests.
-Copyright (C) 2001-2016 Vinay Sajip. All Rights Reserved.
+Copyright (C) 2001-2017 Vinay Sajip. All Rights Reserved.
"""
import logging
fatal = logging.getLevelName('FATAL')
self.assertEqual(fatal, logging.FATAL)
+ def test_regression_29220(self):
+ """See issue #29220 for more information."""
+ logging.addLevelName(logging.INFO, '')
+ self.addCleanup(logging.addLevelName, logging.INFO, 'INFO')
+ self.assertEqual(logging.getLevelName(logging.INFO), '')
+ self.assertEqual(logging.getLevelName(logging.NOTSET), 'NOTSET')
+ self.assertEqual(logging.getLevelName('NOTSET'), logging.NOTSET)
+
class BasicFilterTest(BaseTest):
"""Test the bundled Filter class."""
"""Set up a TCP server to receive log messages, and a SocketHandler
pointing to that server's address and port."""
BaseTest.setUp(self)
- self.server = server = self.server_class(self.address,
- self.handle_socket, 0.01)
- server.start()
+ # Issue #29177: deal with errors that happen during setup
+ self.server = self.sock_hdlr = self.server_exception = None
+ try:
+ self.server = server = self.server_class(self.address,
+ self.handle_socket, 0.01)
+ server.start()
+ # Uncomment next line to test error recovery in setUp()
+ # raise OSError('dummy error raised')
+ except OSError as e:
+ self.server_exception = e
+ return
server.ready.wait()
hcls = logging.handlers.SocketHandler
if isinstance(server.server_address, tuple):
def tearDown(self):
"""Shutdown the TCP server."""
try:
- self.server.stop(2.0)
- self.root_logger.removeHandler(self.sock_hdlr)
- self.sock_hdlr.close()
+ if self.server:
+ self.server.stop(2.0)
+ if self.sock_hdlr:
+ self.root_logger.removeHandler(self.sock_hdlr)
+ self.sock_hdlr.close()
finally:
BaseTest.tearDown(self)
def test_output(self):
# The log message sent to the SocketHandler is properly received.
+ if self.server_exception:
+ self.skipTest(self.server_exception)
logger = logging.getLogger("tcp")
logger.error("spam")
self.handled.acquire()
self.assertEqual(self.log_output, "spam\neggs\n")
def test_noserver(self):
+ if self.server_exception:
+ self.skipTest(self.server_exception)
# Avoid timing-related failures due to SocketHandler's own hard-wired
# one-second timeout on socket.create_connection() (issue #16264).
self.sock_hdlr.retryStart = 2.5
def tearDown(self):
SocketHandlerTest.tearDown(self)
- os.remove(self.address)
+ support.unlink(self.address)
@unittest.skipUnless(threading, 'Threading required for this test.')
class DatagramHandlerTest(BaseTest):
"""Set up a UDP server to receive log messages, and a DatagramHandler
pointing to that server's address and port."""
BaseTest.setUp(self)
- self.server = server = self.server_class(self.address,
- self.handle_datagram, 0.01)
- server.start()
+ # Issue #29177: deal with errors that happen during setup
+ self.server = self.sock_hdlr = self.server_exception = None
+ try:
+ self.server = server = self.server_class(self.address,
+ self.handle_datagram, 0.01)
+ server.start()
+ # Uncomment next line to test error recovery in setUp()
+ # raise OSError('dummy error raised')
+ except OSError as e:
+ self.server_exception = e
+ return
server.ready.wait()
hcls = logging.handlers.DatagramHandler
if isinstance(server.server_address, tuple):
def tearDown(self):
"""Shutdown the UDP server."""
try:
- self.server.stop(2.0)
- self.root_logger.removeHandler(self.sock_hdlr)
- self.sock_hdlr.close()
+ if self.server:
+ self.server.stop(2.0)
+ if self.sock_hdlr:
+ self.root_logger.removeHandler(self.sock_hdlr)
+ self.sock_hdlr.close()
finally:
BaseTest.tearDown(self)
def test_output(self):
# The log message sent to the DatagramHandler is properly received.
+ if self.server_exception:
+ self.skipTest(self.server_exception)
logger = logging.getLogger("udp")
logger.error("spam")
self.handled.wait()
def tearDown(self):
DatagramHandlerTest.tearDown(self)
- os.remove(self.address)
+ support.unlink(self.address)
@unittest.skipUnless(threading, 'Threading required for this test.')
class SysLogHandlerTest(BaseTest):
"""Set up a UDP server to receive log messages, and a SysLogHandler
pointing to that server's address and port."""
BaseTest.setUp(self)
- self.server = server = self.server_class(self.address,
- self.handle_datagram, 0.01)
- server.start()
+ # Issue #29177: deal with errors that happen during setup
+ self.server = self.sl_hdlr = self.server_exception = None
+ try:
+ self.server = server = self.server_class(self.address,
+ self.handle_datagram, 0.01)
+ server.start()
+ # Uncomment next line to test error recovery in setUp()
+ # raise OSError('dummy error raised')
+ except OSError as e:
+ self.server_exception = e
+ return
server.ready.wait()
hcls = logging.handlers.SysLogHandler
if isinstance(server.server_address, tuple):
self.handled = threading.Event()
def tearDown(self):
- """Shutdown the UDP server."""
+ """Shutdown the server."""
try:
- self.server.stop(2.0)
- self.root_logger.removeHandler(self.sl_hdlr)
- self.sl_hdlr.close()
+ if self.server:
+ self.server.stop(2.0)
+ if self.sl_hdlr:
+ self.root_logger.removeHandler(self.sl_hdlr)
+ self.sl_hdlr.close()
finally:
BaseTest.tearDown(self)
self.handled.set()
def test_output(self):
+ if self.server_exception:
+ self.skipTest(self.server_exception)
# The log message sent to the SysLogHandler is properly received.
logger = logging.getLogger("slh")
logger.error("sp\xe4m")
def tearDown(self):
SysLogHandlerTest.tearDown(self)
- os.remove(self.address)
+ support.unlink(self.address)
@unittest.skipUnless(threading, 'Threading required for this test.')
class HTTPHandlerTest(BaseTest):
if mbox:
fp.write(FROM_)
fp.write(DUMMY_MESSAGE)
- if hasattr(os, "link"):
+ try:
os.link(tmpname, newname)
- else:
+ except (AttributeError, PermissionError):
with open(newname, "w") as fp:
fp.write(DUMMY_MESSAGE)
self._msgfiles.append(newname)
self.assertLessEqual(art_num, last)
self._check_art_dict(art_dict)
+ @unittest.skipIf(True, 'temporarily skipped until a permanent solution'
+ ' is found for issue #28971')
def test_over(self):
resp, count, first, last, name = self.server.group(self.GROUP_NAME)
start = last - 10
self.assertEqual(list(d.items()),
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
+ def test_468(self):
+ OrderedDict = self.OrderedDict
+ items = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)]
+ shuffle(items)
+ argdict = OrderedDict(items)
+ d = OrderedDict(**argdict)
+ self.assertEqual(list(d.items()), items)
+
def test_update(self):
OrderedDict = self.OrderedDict
with self.assertRaises(TypeError):
import unittest
from test import support
+android_not_root = support.android_not_root
TESTFN = support.TESTFN
try:
self.assertTrue(p.exists())
self.assertEqual(p.stat().st_ctime, st_ctime_first)
+ @only_nt # XXX: not sure how to test this on POSIX
+ def test_mkdir_with_unknown_drive(self):
+ for d in 'ZYXWVUTSRQPONMLKJIHGFEDCBA':
+ p = self.cls(d + ':\\')
+ if not p.is_dir():
+ break
+ else:
+ self.skipTest("cannot find a drive that doesn't exist")
+ with self.assertRaises(OSError):
+ (p / 'child' / 'path').mkdir(parents=True)
+
def test_mkdir_with_child_file(self):
p = self.cls(BASE, 'dirB', 'fileB')
self.assertTrue(p.exists())
self.assertFalse((P / 'fileA' / 'bah').is_fifo())
@unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
def test_is_fifo_true(self):
P = self.cls(BASE, 'myfifo')
os.mkfifo(str(P))
try:
sock.bind(str(P))
except OSError as e:
- if "AF_UNIX path too long" in str(e):
+ if (isinstance(e, PermissionError) or
+ "AF_UNIX path too long" in str(e)):
self.skipTest("cannot bind Unix socket: " + str(e))
self.assertTrue(P.is_socket())
self.assertFalse(P.is_fifo())
self.assertEqual(given, expect)
self.assertEqual(set(p.rglob("FILEd*")), set())
+ @unittest.skipUnless(hasattr(pwd, 'getpwall'),
+ 'pwd module does not expose getpwall()')
def test_expanduser(self):
P = self.cls
support.import_module('pwd')
def setUp(self):
self.save_version = sys.version
- self.save_mercurial = sys._mercurial
+ self.save_git = sys._git
self.save_platform = sys.platform
def tearDown(self):
sys.version = self.save_version
- sys._mercurial = self.save_mercurial
+ sys._git = self.save_git
sys.platform = self.save_platform
def test_sys_version(self):
('CPython', '2.4.3', '', '', 'truncation', '', 'GCC')),
):
# branch and revision are not "parsed", but fetched
- # from sys._mercurial. Ignore them
+ # from sys._git. Ignore them
(name, version, branch, revision, buildno, builddate, compiler) \
= platform._sys_version(input)
self.assertEqual(
sys_versions.items():
sys.version = version_tag
if subversion is None:
- if hasattr(sys, "_mercurial"):
- del sys._mercurial
+ if hasattr(sys, "_git"):
+ del sys._git
else:
- sys._mercurial = subversion
+ sys._git = subversion
if sys_platform is not None:
sys.platform = sys_platform
self.assertEqual(platform.python_implementation(), info[0])
"Test posix functions"
from test import support
+android_not_root = support.android_not_root
# Skip these tests if there is no posix module.
posix = support.import_module('posix')
posix.stat, list(os.fsencode(support.TESTFN)))
@unittest.skipUnless(hasattr(posix, 'mkfifo'), "don't have mkfifo()")
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
def test_mkfifo(self):
support.unlink(support.TESTFN)
posix.mkfifo(support.TESTFN, stat.S_IRUSR | stat.S_IWUSR)
@unittest.skipUnless(hasattr(posix, 'mknod') and hasattr(stat, 'S_IFIFO'),
"don't have mknod()/S_IFIFO")
+ @unittest.skipIf(android_not_root, "mknod not allowed, non root user")
def test_mknod(self):
# Test using mknod() to create a FIFO (the only use specified
# by POSIX).
posix.close(f)
@unittest.skipUnless(os.link in os.supports_dir_fd, "test needs dir_fd support in os.link()")
+ @unittest.skipIf(android_not_root, "hard link not allowed, non root user")
def test_link_dir_fd(self):
f = posix.open(posix.getcwd(), posix.O_RDONLY)
try:
@unittest.skipUnless((os.mknod in os.supports_dir_fd) and hasattr(stat, 'S_IFIFO'),
"test requires both stat.S_IFIFO and dir_fd support for os.mknod()")
+ @unittest.skipIf(android_not_root, "mknod not allowed, non root user")
def test_mknod_dir_fd(self):
# Test using mknodat() to create a FIFO (the only use specified
# by POSIX).
posix.close(f)
@unittest.skipUnless(os.mkfifo in os.supports_dir_fd, "test needs dir_fd support in os.mkfifo()")
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
def test_mkfifo_dir_fd(self):
support.unlink(support.TESTFN)
f = posix.open(posix.getcwd(), posix.O_RDONLY)
def test_powint(self):
self.powtest(int)
- def test_powlong(self):
- self.powtest(int)
-
def test_powfloat(self):
self.powtest(float)
pwd = support.import_module('pwd')
+def _getpwall():
+ # Android does not have getpwall.
+ if hasattr(pwd, 'getpwall'):
+ return pwd.getpwall()
+ elif hasattr(pwd, 'getpwuid'):
+ return [pwd.getpwuid(0)]
+ else:
+ return []
+
class PwdTest(unittest.TestCase):
def test_values(self):
- entries = pwd.getpwall()
+ entries = _getpwall()
for e in entries:
self.assertEqual(len(e), 7)
# and check afterwards (done in test_values_extended)
def test_values_extended(self):
- entries = pwd.getpwall()
+ entries = _getpwall()
entriesbyname = {}
entriesbyuid = {}
self.assertRaises(TypeError, pwd.getpwuid, 3.14)
self.assertRaises(TypeError, pwd.getpwnam)
self.assertRaises(TypeError, pwd.getpwnam, 42)
- self.assertRaises(TypeError, pwd.getpwall, 42)
+ if hasattr(pwd, 'getpwall'):
+ self.assertRaises(TypeError, pwd.getpwall, 42)
# try to get some errors
bynames = {}
byuids = {}
- for (n, p, u, g, gecos, d, s) in pwd.getpwall():
+ for (n, p, u, g, gecos, d, s) in _getpwall():
bynames[n] = u
byuids[u] = n
# loop, say), pwd.getpwuid() might still be able to find data for that
# uid. Using sys.maxint may provoke the same problems, but hopefully
# it will be a more repeatable failure.
+ # Android accepts a very large span of uids including sys.maxsize and
+ # -1; it raises KeyError with 1 or 2 for example.
fakeuid = sys.maxsize
self.assertNotIn(fakeuid, byuids)
- self.assertRaises(KeyError, pwd.getpwuid, fakeuid)
+ if not support.is_android:
+ self.assertRaises(KeyError, pwd.getpwuid, fakeuid)
# -1 shouldn't be a valid uid because it has a special meaning in many
# uid-related functions
- self.assertRaises(KeyError, pwd.getpwuid, -1)
+ if not support.is_android:
+ self.assertRaises(KeyError, pwd.getpwuid, -1)
# should be out of uid_t range
self.assertRaises(KeyError, pwd.getpwuid, 2**128)
self.assertRaises(KeyError, pwd.getpwuid, -2**128)
def test_locale_flag(self):
import locale
- _, enc = locale.getlocale(locale.LC_CTYPE)
+ enc = locale.getpreferredencoding(False)
# Search non-ASCII letter
for i in range(128, 256):
try:
warnings.simplefilter('error', BytesWarning)
self.assertNotEqual(pattern3, pattern1)
+ def test_bug_29444(self):
+ s = bytearray(b'abcdefgh')
+ m = re.search(b'[a-h]+', s)
+ m2 = re.search(b'[e-h]+', s)
+ self.assertEqual(m.group(), b'abcdefgh')
+ self.assertEqual(m2.group(), b'efgh')
+ s[:] = b'xyz'
+ self.assertEqual(m.group(), b'xyz')
+ self.assertEqual(m2.group(), b'')
+
class PatternReprTests(unittest.TestCase):
def check(self, pattern, expected):
self.checkError([opt, 'foo'], 'invalid int value')
self.checkError([opt, '2', '-T'], "don't go together")
self.checkError([opt, '2', '-l'], "don't go together")
+ self.checkError([opt, '0', '-T'], "don't go together")
+ self.checkError([opt, '0', '-l'], "don't go together")
def test_coverage(self):
for opt in '-T', '--coverage':
self.assertEqual(resource.prlimit(0, resource.RLIMIT_AS, limit),
limit)
+ # Issue 20191: Reference counting bug
+ @unittest.skipUnless(hasattr(resource, 'prlimit'), 'no prlimit')
+ @support.requires_linux_version(2, 6, 36)
+ def test_prlimit_refcount(self):
+ class BadSeq:
+ def __len__(self):
+ return 2
+ def __getitem__(self, key):
+ return limits[key] - 1 # new reference
+
+ limits = resource.getrlimit(resource.RLIMIT_AS)
+ self.assertEqual(resource.prlimit(0, resource.RLIMIT_AS, BadSeq()),
+ limits)
+
def test_main(verbose=None):
support.run_unittest(ResourceTest)
for i in range(2, 10):
self.assertIn(secrets.randbelow(i), range(i))
self.assertRaises(ValueError, secrets.randbelow, 0)
+ self.assertRaises(ValueError, secrets.randbelow, -1)
class Token_Tests(unittest.TestCase):
# white space
self.assertEqual(list(s), ['a', '&&', 'b', '||', 'c'])
+ def testPunctuationWithPosix(self):
+ """Test that punctuation_chars and posix behave correctly together."""
+ # see Issue #29132
+ s = shlex.shlex('f >"abc"', posix=True, punctuation_chars=True)
+ self.assertEqual(list(s), ['f', '>', 'abc'])
+ s = shlex.shlex('f >\\"abc\\"', posix=True, punctuation_chars=True)
+ self.assertEqual(list(s), ['f', '>', '"abc"'])
+
def testEmptyStringHandling(self):
"""Test that parsing of empty strings is correctly handled."""
# see Issue #21999
unregister_unpack_format, get_unpack_formats,
SameFileError)
import tarfile
+import zipfile
import warnings
from test import support
-from test.support import TESTFN, check_warnings, captured_stdout, requires_zlib
-
-try:
- import bz2
- BZ2_SUPPORTED = True
-except ImportError:
- BZ2_SUPPORTED = False
-
-try:
- import lzma
- LZMA_SUPPORTED = True
-except ImportError:
- LZMA_SUPPORTED = False
+from test.support import (TESTFN, check_warnings, captured_stdout,
+ android_not_root)
TESTFN2 = TESTFN + "2"
except ImportError:
UID_GID_SUPPORT = False
-try:
- import zipfile
- ZIP_SUPPORT = True
-except ImportError:
- ZIP_SUPPORT = shutil.which('zip')
-
def _fake_rename(*args, **kwargs):
# Pretend the destination path is on a different filesystem.
raise OSError(getattr(errno, 'EXDEV', 18), "Invalid cross-device link")
@unittest.skipIf(os.name == 'nt', 'temporarily disabled on Windows')
@unittest.skipUnless(hasattr(os, 'link'), 'requires os.link')
+ @unittest.skipIf(android_not_root, "hard links not allowed, non root user")
def test_dont_copy_file_onto_link_to_itself(self):
# bug 851123.
os.mkdir(TESTFN)
# Issue #3002: copyfile and copytree block indefinitely on named pipes
@unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
def test_copyfile_named_pipe(self):
os.mkfifo(TESTFN)
try:
finally:
os.remove(TESTFN)
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
@unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
@support.skip_unless_symlink
def test_copytree_named_pipe(self):
self.assertEqual(getattr(file1_stat, 'st_flags'),
getattr(file2_stat, 'st_flags'))
- @requires_zlib
+ @support.requires_zlib
def test_make_tarball(self):
# creating something to tar
root_dir, base_dir = self._create_files('')
write_file((root_dir, 'outer'), 'xxx')
return root_dir, base_dir
- @requires_zlib
+ @support.requires_zlib
@unittest.skipUnless(shutil.which('tar'),
'Need the tar command to run')
def test_tarfile_vs_tar(self):
self.assertEqual(tarball, base_name + '.tar')
self.assertTrue(os.path.isfile(tarball))
- @requires_zlib
- @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
+ @support.requires_zlib
def test_make_zipfile(self):
# creating something to zip
root_dir, base_dir = self._create_files()
['dist/', 'dist/sub/', 'dist/sub2/',
'dist/file1', 'dist/file2', 'dist/sub/file3'])
- @requires_zlib
- @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
+ @support.requires_zlib
@unittest.skipUnless(shutil.which('zip'),
'Need the zip command to run')
def test_zipfile_vs_zip(self):
names2 = zf.namelist()
self.assertEqual(sorted(names), sorted(names2))
- @requires_zlib
- @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
+ @support.requires_zlib
@unittest.skipUnless(shutil.which('unzip'),
'Need the unzip command to run')
def test_unzip_zipfile(self):
base_name = os.path.join(tmpdir, 'archive')
self.assertRaises(ValueError, make_archive, base_name, 'xxx')
- @requires_zlib
+ @support.requires_zlib
def test_make_archive_owner_group(self):
# testing make_archive with owner and group, with various combinations
# this works even if there's not gid/uid support
self.assertTrue(os.path.isfile(res))
- @requires_zlib
+ @support.requires_zlib
@unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
def test_tarfile_root_owner(self):
root_dir, base_dir = self._create_files()
self.assertEqual(make_archive('test', 'tar'), 'test.tar')
self.assertTrue(os.path.isfile('test.tar'))
- @requires_zlib
+ @support.requires_zlib
def test_make_zipfile_in_curdir(self):
# Issue #21280
root_dir = self.mkdtemp()
formats = [name for name, params in get_archive_formats()]
self.assertNotIn('xxx', formats)
- @requires_zlib
- def test_unpack_archive(self):
- formats = ['tar', 'gztar', 'zip']
- if BZ2_SUPPORTED:
- formats.append('bztar')
- if LZMA_SUPPORTED:
- formats.append('xztar')
-
+ def check_unpack_archive(self, format):
root_dir, base_dir = self._create_files()
expected = rlistdir(root_dir)
expected.remove('outer')
- for format in formats:
- base_name = os.path.join(self.mkdtemp(), 'archive')
- filename = make_archive(base_name, format, root_dir, base_dir)
-
- # let's try to unpack it now
- tmpdir2 = self.mkdtemp()
- unpack_archive(filename, tmpdir2)
- self.assertEqual(rlistdir(tmpdir2), expected)
-
- # and again, this time with the format specified
- tmpdir3 = self.mkdtemp()
- unpack_archive(filename, tmpdir3, format=format)
- self.assertEqual(rlistdir(tmpdir3), expected)
+
+ base_name = os.path.join(self.mkdtemp(), 'archive')
+ filename = make_archive(base_name, format, root_dir, base_dir)
+
+ # let's try to unpack it now
+ tmpdir2 = self.mkdtemp()
+ unpack_archive(filename, tmpdir2)
+ self.assertEqual(rlistdir(tmpdir2), expected)
+
+ # and again, this time with the format specified
+ tmpdir3 = self.mkdtemp()
+ unpack_archive(filename, tmpdir3, format=format)
+ self.assertEqual(rlistdir(tmpdir3), expected)
+
self.assertRaises(shutil.ReadError, unpack_archive, TESTFN)
self.assertRaises(ValueError, unpack_archive, TESTFN, format='xxx')
+ def test_unpack_archive_tar(self):
+ self.check_unpack_archive('tar')
+
+ @support.requires_zlib
+ def test_unpack_archive_gztar(self):
+ self.check_unpack_archive('gztar')
+
+ @support.requires_bz2
+ def test_unpack_archive_bztar(self):
+ self.check_unpack_archive('bztar')
+
+ @support.requires_lzma
+ def test_unpack_archive_xztar(self):
+ self.check_unpack_archive('xztar')
+
+ @support.requires_zlib
+ def test_unpack_archive_zip(self):
+ self.check_unpack_archive('zip')
+
def test_unpack_registry(self):
formats = get_unpack_formats()
os.unlink(_pth_file)
os.unlink(exe_file)
+ @classmethod
+ def _calc_sys_path_for_underpth_nosite(self, sys_prefix, lines):
+ sys_path = []
+ for line in lines:
+ if not line or line[0] == '#':
+ continue
+ abs_path = os.path.abspath(os.path.join(sys_prefix, line))
+ sys_path.append(abs_path)
+ return sys_path
+
@unittest.skipUnless(sys.platform == 'win32', "only supported on Windows")
def test_underpth_nosite_file(self):
libpath = os.path.dirname(os.path.dirname(encodings.__file__))
exe_prefix = os.path.dirname(sys.executable)
- exe_file = self._create_underpth_exe([
+ pth_lines = [
'fake-path-name',
*[libpath for _ in range(200)],
+ '',
'# comment',
- 'import site'
- ])
+ ]
+ exe_file = self._create_underpth_exe(pth_lines)
+ sys_path = self._calc_sys_path_for_underpth_nosite(
+ os.path.dirname(exe_file),
+ pth_lines)
try:
env = os.environ.copy()
rc = subprocess.call([exe_file, '-c',
'import sys; sys.exit(sys.flags.no_site and '
'len(sys.path) > 200 and '
- '%r in sys.path and %r in sys.path and %r not in sys.path)' % (
- os.path.join(sys.prefix, 'fake-path-name'),
- libpath,
- os.path.join(sys.prefix, 'from-env'),
- )], env=env)
+ 'sys.path == %r)' % sys_path,
+ ], env=env)
finally:
self._cleanup_underpth_exe(exe_file)
- self.assertEqual(rc, 0)
+ self.assertTrue(rc, "sys.path is incorrect")
@unittest.skipUnless(sys.platform == 'win32', "only supported on Windows")
def test_underpth_file(self):
exe_file = self._create_underpth_exe([
'fake-path-name',
*[libpath for _ in range(200)],
+ '',
'# comment',
'import site'
])
+ sys_prefix = os.path.dirname(exe_file)
try:
env = os.environ.copy()
env['PYTHONPATH'] = 'from-env'
env['PATH'] = '{};{}'.format(exe_prefix, os.getenv('PATH'))
rc = subprocess.call([exe_file, '-c',
'import sys; sys.exit(not sys.flags.no_site and '
- '%r in sys.path and %r in sys.path and %r not in sys.path)' % (
- os.path.join(sys.prefix, 'fake-path-name'),
+ '%r in sys.path and %r in sys.path and %r not in sys.path and '
+ 'all("\\r" not in p and "\\n" not in p for p in sys.path))' % (
+ os.path.join(sys_prefix, 'fake-path-name'),
libpath,
- os.path.join(sys.prefix, 'from-env'),
+ os.path.join(sys_prefix, 'from-env'),
)], env=env)
finally:
self._cleanup_underpth_exe(exe_file)
- self.assertEqual(rc, 0)
+ self.assertTrue(rc, "sys.path is incorrect")
if __name__ == "__main__":
def clientRun(self, test_func):
self.server_ready.wait()
- self.clientSetUp()
- self.client_ready.set()
+ try:
+ self.clientSetUp()
+ except BaseException as e:
+ self.queue.put(e)
+ self.clientTearDown()
+ return
+ finally:
+ self.client_ready.set()
if self.server_crashed:
self.clientTearDown()
return
self.serv_conn = self.cli
def clientTearDown(self):
- self.serv_conn.close()
- self.serv_conn = None
+ try:
+ self.serv_conn.close()
+ self.serv_conn = None
+ except AttributeError:
+ pass
super().clientTearDown()
def bindSock(self, sock):
path = tempfile.mktemp(dir=self.dir_path)
- sock.bind(path)
+ support.bind_unix_socket(sock, path)
self.addCleanup(support.unlink, path)
class UnixStreamBase(UnixSocketTestBase):
def bind(self, sock, path):
# Bind the socket
try:
- sock.bind(path)
+ support.bind_unix_socket(sock, path)
except OSError as e:
if str(e) == "AF_UNIX path too long":
self.skipTest(
"""
if not hasattr(socket, "AF_TIPC"):
return False
- if not os.path.isfile("/proc/modules"):
+ try:
+ f = open("/proc/modules")
+ except (FileNotFoundError, IsADirectoryError, PermissionError):
+ # It's ok if the file does not exist, is a directory or if we
+ # have not the permission to read it.
return False
- with open("/proc/modules") as f:
+ with f:
for line in f:
if line.startswith("tipc "):
return True
import unittest
import os
import sys
-from test.support import TESTFN, import_fresh_module
+from test.support import TESTFN, import_fresh_module, android_not_root
c_stat = import_fresh_module('stat', fresh=['_stat'])
py_stat = import_fresh_module('stat', blocked=['_stat'])
self.assertS_IS("LNK", st_mode)
@unittest.skipUnless(hasattr(os, 'mkfifo'), 'os.mkfifo not available')
+ @unittest.skipIf(android_not_root, "mkfifo not allowed, non root user")
def test_fifo(self):
os.mkfifo(TESTFN, 0o700)
st_mode, modestr = self.get_mode()
for i in range(6, len(test_string) + 1):
self.assertRaises(struct.error, struct.unpack_from, fmt, data, i)
+ # keyword arguments
+ self.assertEqual(s.unpack_from(buffer=test_string, offset=2),
+ (b'cd01',))
+
def test_pack_into(self):
test_string = b'Reykjavik rocks, eow!'
writable_buf = array.array('b', b' '*100)
from test import support
import subprocess
import sys
+import platform
import signal
import io
import os
import textwrap
try:
+ import ctypes
+except ImportError:
+ ctypes = None
+
+try:
import threading
except ImportError:
threading = None
temp_dir = self._normalize_cwd(temp_dir)
self._assert_cwd(temp_dir, sys.executable, cwd=temp_dir)
+ def test_cwd_with_pathlike(self):
+ temp_dir = tempfile.gettempdir()
+ temp_dir = self._normalize_cwd(temp_dir)
+
+ class _PathLikeObj:
+ def __fspath__(self):
+ return temp_dir
+
+ self._assert_cwd(temp_dir, sys.executable, cwd=_PathLikeObj())
+
@unittest.skipIf(mswindows, "pending resolution of issue #15533")
def test_cwd_with_relative_arg(self):
# Check that Popen looks for args[0] relative to cwd if args[0]
proc.communicate(timeout=999)
mock_proc_stdin.close.assert_called_once_with()
+ _libc_file_extensions = {
+ 'Linux': 'so.6',
+ 'Darwin': 'dylib',
+ }
+ @unittest.skipIf(not ctypes, 'ctypes module required.')
+ @unittest.skipIf(platform.uname()[0] not in _libc_file_extensions,
+ 'Test requires a libc this code can load with ctypes.')
+ @unittest.skipIf(not sys.executable, 'Test requires sys.executable.')
+ def test_child_terminated_in_stopped_state(self):
+ """Test wait() behavior when waitpid returns WIFSTOPPED; issue29335."""
+ PTRACE_TRACEME = 0 # From glibc and MacOS (PT_TRACE_ME).
+ libc_name = 'libc.' + self._libc_file_extensions[platform.uname()[0]]
+ libc = ctypes.CDLL(libc_name)
+ if not hasattr(libc, 'ptrace'):
+ raise unittest.SkipTest('ptrace() required.')
+ test_ptrace = subprocess.Popen(
+ [sys.executable, '-c', """if True:
+ import ctypes
+ libc = ctypes.CDLL({libc_name!r})
+ libc.ptrace({PTRACE_TRACEME}, 0, 0)
+ """.format(libc_name=libc_name, PTRACE_TRACEME=PTRACE_TRACEME)
+ ])
+ if test_ptrace.wait() != 0:
+ raise unittest.SkipTest('ptrace() failed - unable to test.')
+ child = subprocess.Popen(
+ [sys.executable, '-c', """if True:
+ import ctypes
+ libc = ctypes.CDLL({libc_name!r})
+ libc.ptrace({PTRACE_TRACEME}, 0, 0)
+ libc.printf(ctypes.c_char_p(0xdeadbeef)) # Crash the process.
+ """.format(libc_name=libc_name, PTRACE_TRACEME=PTRACE_TRACEME)
+ ])
+ try:
+ returncode = child.wait()
+ except Exception as e:
+ child.kill() # Clean up the hung stopped process.
+ raise e
+ self.assertNotEqual(0, returncode)
+ self.assertLess(returncode, 0) # signal death, likely SIGSEGV.
+
@unittest.skipUnless(mswindows, "Windows specific tests")
class Win32ProcessTestCase(BaseTestCase):
self.assertEqual(cm.exception.errno, errno.EBADF)
def test_check_syntax_error(self):
- support.check_syntax_error(self, "def class")
+ support.check_syntax_error(self, "def class", lineno=1, offset=9)
with self.assertRaises(AssertionError):
support.check_syntax_error(self, "x=1")
def test_filename_correct(self):
### Bug tickler: SyntaxError file name correct whether error raised
### while parsing or building symbol table.
- def checkfilename(brokencode):
+ def checkfilename(brokencode, offset):
try:
symtable.symtable(brokencode, "spam", "exec")
except SyntaxError as e:
self.assertEqual(e.filename, "spam")
+ self.assertEqual(e.lineno, 1)
+ self.assertEqual(e.offset, offset)
else:
self.fail("no SyntaxError for %r" % (brokencode,))
- checkfilename("def f(x): foo)(") # parse-time
- checkfilename("def f(x): global x") # symtable-build-time
+ checkfilename("def f(x): foo)(", 14) # parse-time
+ checkfilename("def f(x): global x", 10) # symtable-build-time
symtable.symtable("pass", b"spam", "exec")
with self.assertWarns(DeprecationWarning), \
self.assertRaises(TypeError):
class SyntaxTestCase(unittest.TestCase):
def _check_error(self, code, errtext,
- filename="<testcase>", mode="exec", subclass=None):
+ filename="<testcase>", mode="exec", subclass=None, lineno=None, offset=None):
"""Check that compiling code raises SyntaxError with errtext.
errtest is a regular expression that must be present in the
mo = re.search(errtext, str(err))
if mo is None:
self.fail("SyntaxError did not contain '%r'" % (errtext,))
+ self.assertEqual(err.filename, filename)
+ if lineno is not None:
+ self.assertEqual(err.lineno, lineno)
+ if offset is not None:
+ self.assertEqual(err.offset, offset)
else:
self.fail("compile() did not raise SyntaxError")
self._check_error("del f()", "delete")
def test_global_err_then_warn(self):
- # Bug tickler: The SyntaxError raised for one global statement
+ # Bug #763201: The SyntaxError raised for one global statement
# shouldn't be clobbered by a SyntaxWarning issued for a later one.
source = """if 1:
def error(a):
import shutil
from copy import copy
-from test.support import (run_unittest, TESTFN, unlink, check_warnings,
+from test.support import (run_unittest,
+ import_module, TESTFN, unlink, check_warnings,
captured_stdout, skip_unless_symlink, change_cwd)
import sysconfig
self.assertIsNotNone(vars['SO'])
self.assertEqual(vars['SO'], vars['EXT_SUFFIX'])
- @unittest.skipUnless(sys.platform == 'linux', 'Linux-specific test')
+ @unittest.skipUnless(sys.platform == 'linux' and
+ hasattr(sys.implementation, '_multiarch'),
+ 'multiarch-specific test')
def test_triplet_in_ext_suffix(self):
- import ctypes, platform, re
+ ctypes = import_module('ctypes')
+ import platform, re
machine = platform.machine()
suffix = sysconfig.get_config_var('EXT_SUFFIX')
if re.match('(aarch64|arm|mips|ppc|powerpc|s390|sparc)', machine):
if re.match('(i[3-6]86|x86_64)$', machine):
if ctypes.sizeof(ctypes.c_char_p()) == 4:
self.assertTrue(suffix.endswith('i386-linux-gnu.so') or
- suffix.endswith('i686-linux-android.so') or
suffix.endswith('x86_64-linux-gnux32.so'),
suffix)
else: # 8 byte pointer size
mutex.acquire()
self.assertIn(tid, threading._active)
self.assertIsInstance(threading._active[tid], threading._DummyThread)
+ #Issue 29376
+ self.assertTrue(threading._active[tid].is_alive())
+ self.assertRegex(repr(threading._active[tid]), '_DummyThread')
del threading._active[tid]
# PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)
self.addCleanup(sys.setswitchinterval, old_interval)
# Make the bug more likely to manifest.
- sys.setswitchinterval(1e-6)
+ test.support.setswitchinterval(1e-6)
for i in range(20):
t = threading.Thread(target=lambda: None)
from typing import Union, Optional
from typing import Tuple, List, MutableMapping
from typing import Callable
-from typing import Generic, ClassVar
+from typing import Generic, ClassVar, GenericMeta
from typing import cast
from typing import get_type_hints
from typing import no_type_check, no_type_check_decorator
from typing import Pattern, Match
import abc
import typing
+import weakref
try:
import collections.abc as collections_abc
except ImportError:
with self.assertRaises(TypeError):
TypeVar('X', str, float, bound=Employee)
+ def test_no_bivariant(self):
+ with self.assertRaises(ValueError):
+ TypeVar('T', covariant=True, contravariant=True)
+
class UnionTests(BaseTestCase):
self.assertEqual(repr(u), 'typing.Union[%s.Employee, int]' % __name__)
u = Union[int, Employee]
self.assertEqual(repr(u), 'typing.Union[int, %s.Employee]' % __name__)
+ T = TypeVar('T')
+ u = Union[T, int][int]
+ self.assertEqual(repr(u), repr(int))
+ u = Union[List[int], int]
+ self.assertEqual(repr(u), 'typing.Union[typing.List[int], int]')
def test_cannot_subclass(self):
with self.assertRaises(TypeError):
self.assertFalse(Union[str, typing.Iterable[int]] == typing.Iterable[int])
self.assertTrue(Union[str, typing.Iterable] == typing.Iterable)
+ def test_union_compare_other(self):
+ self.assertNotEqual(Union, object)
+ self.assertNotEqual(Union, Any)
+ self.assertNotEqual(ClassVar, Union)
+ self.assertNotEqual(Optional, Union)
+ self.assertNotEqual([None], Optional)
+ self.assertNotEqual(Optional, typing.Mapping)
+ self.assertNotEqual(Optional[typing.MutableMapping], Union)
+
def test_optional(self):
o = Optional[int]
u = Union[int, None]
with self.assertRaises(TypeError):
isinstance(42, Union[int, str])
+ def test_no_eval_union(self):
+ u = Union[int, str]
+ def f(x: u): ...
+ self.assertIs(get_type_hints(f)['x'], u)
+
+ def test_function_repr_union(self):
+ def fun() -> int: ...
+ self.assertEqual(repr(Union[fun, int]), 'typing.Union[fun, int]')
+
def test_union_str_pattern(self):
# Shouldn't crash; see http://bugs.python.org/issue25390
A = Union[str, Pattern]
Callable[[()], int]
with self.assertRaises(TypeError):
Callable[[int, 1], 2]
+ with self.assertRaises(TypeError):
+ Callable[int]
def test_callable_instance_works(self):
def f():
Y[str]
with self.assertRaises(TypeError):
Y[str, str]
+ self.assertIsSubclass(SimpleMapping[str, int], SimpleMapping)
def test_generic_errors(self):
T = TypeVar('T')
+ S = TypeVar('S')
with self.assertRaises(TypeError):
Generic[T]()
with self.assertRaises(TypeError):
+ Generic[T][T]
+ with self.assertRaises(TypeError):
+ Generic[T][S]
+ with self.assertRaises(TypeError):
isinstance([], List[int])
with self.assertRaises(TypeError):
issubclass(list, List[int])
+ with self.assertRaises(TypeError):
+ class NewGeneric(Generic): ...
+ with self.assertRaises(TypeError):
+ class MyGeneric(Generic[T], Generic[S]): ...
+ with self.assertRaises(TypeError):
+ class MyGeneric(List[T], Generic[S]): ...
def test_init(self):
T = TypeVar('T')
self.assertEqual(repr(typing.Mapping[T, TS][TS, T]), 'typing.Mapping[~TS, ~T]')
self.assertEqual(repr(List[Tuple[T, TS]][int, T]),
'typing.List[typing.Tuple[int, ~T]]')
- self.assertEqual(repr(List[Tuple[T, T]][List[int]]),
- 'typing.List[typing.Tuple[typing.List[int], typing.List[int]]]')
+ self.assertEqual(
+ repr(List[Tuple[T, T]][List[int]]),
+ 'typing.List[typing.Tuple[typing.List[int], typing.List[int]]]'
+ )
def test_new_repr_bare(self):
T = TypeVar('T')
c.bar = 'abc'
self.assertEqual(c.__dict__, {'bar': 'abc'})
+ def test_subscripted_generics_as_proxies(self):
+ T = TypeVar('T')
+ class C(Generic[T]):
+ x = 'def'
+ self.assertEqual(C[int].x, 'def')
+ self.assertEqual(C[C[int]].x, 'def')
+ C[C[int]].x = 'changed'
+ self.assertEqual(C.x, 'changed')
+ self.assertEqual(C[str].x, 'changed')
+ C[List[str]].z = 'new'
+ self.assertEqual(C.z, 'new')
+ self.assertEqual(C[Tuple[int]].z, 'new')
+
+ self.assertEqual(C().x, 'changed')
+ self.assertEqual(C[Tuple[str]]().z, 'new')
+
+ class D(C[T]):
+ pass
+ self.assertEqual(D[int].x, 'changed')
+ self.assertEqual(D.z, 'new')
+ D.z = 'from derived z'
+ D[int].x = 'from derived x'
+ self.assertEqual(C.x, 'changed')
+ self.assertEqual(C[int].z, 'new')
+ self.assertEqual(D.x, 'from derived x')
+ self.assertEqual(D[str].z, 'from derived z')
+
+ def test_abc_registry_kept(self):
+ T = TypeVar('T')
+ class C(Generic[T]): ...
+ C.register(int)
+ self.assertIsInstance(1, C)
+ C[int]
+ self.assertIsInstance(1, C)
+
def test_false_subclasses(self):
class MyMapping(MutableMapping[str, str]): pass
self.assertNotIsInstance({}, MyMapping)
raise NotImplementedError
if tp.__args__:
KT, VT = tp.__args__
- return all(isinstance(k, KT) and isinstance(v, VT)
- for k, v in obj.items())
+ return all(
+ isinstance(k, KT) and isinstance(v, VT)
+ for k, v in obj.items()
+ )
self.assertTrue(naive_dict_check({'x': 1}, typing.Dict[str, int]))
self.assertFalse(naive_dict_check({1: 'x'}, typing.Dict[str, int]))
with self.assertRaises(NotImplementedError):
self.assertFalse(naive_generic_check(Node[str](), Node[int]))
self.assertFalse(naive_generic_check(Node[str](), List))
with self.assertRaises(NotImplementedError):
- naive_generic_check([1,2,3], Node[int])
+ naive_generic_check([1, 2, 3], Node[int])
def naive_list_base_check(obj, tp):
# Check if list conforms to a List subclass
self.assertEqual(C.__orig_bases__, (List[T][U][V],))
self.assertEqual(D.__orig_bases__, (C, List[T][U][V]))
+ def test_subscript_meta(self):
+ T = TypeVar('T')
+ self.assertEqual(Type[GenericMeta], Type[GenericMeta])
+ self.assertEqual(Union[T, int][GenericMeta], Union[GenericMeta, int])
+ self.assertEqual(Callable[..., GenericMeta].__args__, (Ellipsis, GenericMeta))
+
+ def test_generic_hashes(self):
+ try:
+ from test import mod_generics_cache
+ except ImportError: # for Python 3.4 and previous versions
+ import mod_generics_cache
+ class A(Generic[T]):
+ ...
+
+ class B(Generic[T]):
+ class A(Generic[T]):
+ ...
+
+ self.assertEqual(A, A)
+ self.assertEqual(mod_generics_cache.A[str], mod_generics_cache.A[str])
+ self.assertEqual(B.A, B.A)
+ self.assertEqual(mod_generics_cache.B.A[B.A[str]],
+ mod_generics_cache.B.A[B.A[str]])
+
+ self.assertNotEqual(A, B.A)
+ self.assertNotEqual(A, mod_generics_cache.A)
+ self.assertNotEqual(A, mod_generics_cache.B.A)
+ self.assertNotEqual(B.A, mod_generics_cache.A)
+ self.assertNotEqual(B.A, mod_generics_cache.B.A)
+
+ self.assertNotEqual(A[str], B.A[str])
+ self.assertNotEqual(A[List[Any]], B.A[List[Any]])
+ self.assertNotEqual(A[str], mod_generics_cache.A[str])
+ self.assertNotEqual(A[str], mod_generics_cache.B.A[str])
+ self.assertNotEqual(B.A[int], mod_generics_cache.A[int])
+ self.assertNotEqual(B.A[List[Any]], mod_generics_cache.B.A[List[Any]])
+
+ self.assertNotEqual(Tuple[A[str]], Tuple[B.A[str]])
+ self.assertNotEqual(Tuple[A[List[Any]]], Tuple[B.A[List[Any]]])
+ self.assertNotEqual(Union[str, A[str]], Union[str, mod_generics_cache.A[str]])
+ self.assertNotEqual(Union[A[str], A[str]],
+ Union[A[str], mod_generics_cache.A[str]])
+ self.assertNotEqual(typing.FrozenSet[A[str]],
+ typing.FrozenSet[mod_generics_cache.B.A[str]])
+
+ if sys.version_info[:2] > (3, 2):
+ self.assertTrue(repr(Tuple[A[str]]).endswith('<locals>.A[str]]'))
+ self.assertTrue(repr(Tuple[B.A[str]]).endswith('<locals>.B.A[str]]'))
+ self.assertTrue(repr(Tuple[mod_generics_cache.A[str]])
+ .endswith('mod_generics_cache.A[str]]'))
+ self.assertTrue(repr(Tuple[mod_generics_cache.B.A[str]])
+ .endswith('mod_generics_cache.B.A[str]]'))
+
def test_extended_generic_rules_eq(self):
T = TypeVar('T')
U = TypeVar('U')
def test_generic_forward_ref(self):
def foobar(x: List[List['CC']]): ...
class CC: ...
- self.assertEqual(get_type_hints(foobar, globals(), locals()), {'x': List[List[CC]]})
+ self.assertEqual(
+ get_type_hints(foobar, globals(), locals()),
+ {'x': List[List[CC]]}
+ )
T = TypeVar('T')
AT = Tuple[T, ...]
def barfoo(x: AT): ...
Tuple[Generic[T]]
with self.assertRaises(TypeError):
List[typing._Protocol]
+ with self.assertRaises(TypeError):
+ isinstance(1, Generic)
def test_type_erasure_special(self):
T = TypeVar('T')
class MyDef(typing.DefaultDict[str, T]): ...
self.assertIs(MyDef[int]().__class__, MyDef)
self.assertIs(MyDef[int]().__orig_class__, MyDef[int])
+ # ChainMap was added in 3.3
+ if sys.version_info >= (3, 3):
+ class MyChain(typing.ChainMap[str, T]): ...
+ self.assertIs(MyChain[int]().__class__, MyChain)
+ self.assertIs(MyChain[int]().__orig_class__, MyChain[int])
def test_all_repr_eq_any(self):
objs = (getattr(typing, el) for el in typing.__all__)
self.assertEqual(t, copy(t))
self.assertEqual(t, deepcopy(t))
+ def test_weakref_all(self):
+ T = TypeVar('T')
+ things = [Any, Union[T, int], Callable[..., T], Tuple[Any, Any],
+ Optional[List[int]], typing.Mapping[int, str],
+ typing.re.Match[bytes], typing.Iterable['whatever']]
+ for t in things:
+ self.assertEqual(weakref.ref(t)(), t)
+
def test_parameterized_slots(self):
T = TypeVar('T')
class C(Generic[T]):
with self.assertRaises(Exception):
D[T]
+
class ClassVarTests(BaseTestCase):
def test_basics(self):
with self.assertRaises(TypeError):
isinstance(42, fr)
+ def test_forwardref_subclass_type_error(self):
+ fr = typing._ForwardRef('int')
+ with self.assertRaises(TypeError):
+ issubclass(int, fr)
+
+ def test_forward_equality(self):
+ fr = typing._ForwardRef('int')
+ self.assertEqual(fr, typing._ForwardRef('int'))
+ self.assertNotEqual(List['int'], List[int])
+
+ def test_forward_repr(self):
+ self.assertEqual(repr(List['int']), "typing.List[_ForwardRef('int')]")
+
def test_union_forward(self):
def foo(a: Union['T']):
ith = get_type_hints(C().foo)
self.assertEqual(ith, {})
+ def test_no_type_check_no_bases(self):
+ class C:
+ def meth(self, x: int): ...
+ @no_type_check
+ class D(C):
+ c = C
+ # verify that @no_type_check never affects bases
+ self.assertEqual(get_type_hints(C.meth), {'x': int})
+
def test_meta_no_type_check(self):
@no_type_check_decorator
class OverloadTests(BaseTestCase):
- def test_overload_exists(self):
- from typing import overload
-
def test_overload_fails(self):
from typing import overload
exec(ASYNCIO_TESTS)
except ImportError:
ASYNCIO = False
+else:
+ # fake names for the sake of static analysis
+ asyncio = None
+ AwaitableWrapper = AsyncIteratorWrapper = object
PY36 = sys.version_info[:2] >= (3, 6)
class B(A):
x: ClassVar[Optional['B']] = None
y: int
+ b: int
class CSub(B):
z: ClassVar['CSub'] = B()
class G(Generic[T]):
lst: ClassVar[List[T]] = []
+class NoneAndForward:
+ parent: 'NoneAndForward'
+ meaning: None
+
class CoolEmployee(NamedTuple):
name: str
cool: int
+
+class CoolEmployeeWithDefault(NamedTuple):
+ name: str
+ cool: int = 0
+
+class XMeth(NamedTuple):
+ x: int
+ def double(self):
+ return 2 * self.x
+
+class XRepr(NamedTuple):
+ x: int
+ y: int = 1
+ def __str__(self):
+ return f'{self.x} -> {self.y}'
+ def __add__(self, other):
+ return 0
"""
if PY36:
exec(PY36_TESTS)
+else:
+ # fake names for the sake of static analysis
+ ann_module = ann_module2 = ann_module3 = None
+ A = B = CSub = G = CoolEmployee = CoolEmployeeWithDefault = object
+ XMeth = XRepr = NoneAndForward = object
gth = get_type_hints
+
class GetTypeHintTests(BaseTestCase):
def test_get_type_hints_from_various_objects(self):
# For invalid objects should fail with TypeError (not AttributeError etc).
@skipUnless(PY36, 'Python 3.6 required')
def test_get_type_hints_modules(self):
- self.assertEqual(gth(ann_module), {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str})
+ ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str}
+ self.assertEqual(gth(ann_module), ann_module_type_hints)
self.assertEqual(gth(ann_module2), {})
self.assertEqual(gth(ann_module3), {})
{'y': Optional[ann_module.C]})
self.assertEqual(gth(ann_module.S), {'x': str, 'y': str})
self.assertEqual(gth(ann_module.foo), {'x': int})
+ self.assertEqual(gth(NoneAndForward, globals()),
+ {'parent': NoneAndForward, 'meaning': type(None)})
@skipUnless(PY36, 'Python 3.6 required')
def test_respect_no_type_check(self):
class Der(ABase): ...
self.assertEqual(gth(ABase.meth), {'x': int})
- def test_get_type_hints_for_builins(self):
+ def test_get_type_hints_for_builtins(self):
# Should not fail for built-in classes and functions.
self.assertEqual(gth(int), {})
self.assertEqual(gth(type), {})
self.assertEqual(gth(dir), {})
self.assertEqual(gth(len), {})
+ self.assertEqual(gth(object.__str__), {})
+ self.assertEqual(gth(object().__str__), {})
+ self.assertEqual(gth(str.join), {})
def test_previous_behavior(self):
def testf(x, y): ...
testf.__annotations__['x'] = 'int'
self.assertEqual(gth(testf), {'x': int})
+ def testg(x: None): ...
+ self.assertEqual(gth(testg), {'x': type(None)})
def test_get_type_hints_for_object_with_annotations(self):
class A: ...
self.assertEqual(gth(ann_module2.CV, ann_module2.__dict__),
{'var': typing.ClassVar[ann_module2.CV]})
self.assertEqual(gth(B, globals()),
- {'y': int, 'x': ClassVar[Optional[B]]})
+ {'y': int, 'x': ClassVar[Optional[B]], 'b': int})
self.assertEqual(gth(CSub, globals()),
- {'z': ClassVar[CSub], 'y': int, 'x': ClassVar[Optional[B]]})
+ {'z': ClassVar[CSub], 'y': int, 'b': int,
+ 'x': ClassVar[Optional[B]]})
self.assertEqual(gth(G), {'lst': ClassVar[List[T]]})
def test_list(self):
self.assertIsSubclass(list, typing.List)
+ def test_deque(self):
+ self.assertIsSubclass(collections.deque, typing.Deque)
+ class MyDeque(typing.Deque[int]): ...
+ self.assertIsInstance(MyDeque(), collections.deque)
+
+ def test_counter(self):
+ self.assertIsSubclass(collections.Counter, typing.Counter)
+
def test_set(self):
self.assertIsSubclass(set, typing.Set)
self.assertNotIsSubclass(frozenset, typing.Set)
self.assertIsSubclass(MyDict, dict)
self.assertNotIsSubclass(dict, MyDict)
- def test_no_defaultdict_instantiation(self):
- with self.assertRaises(TypeError):
- typing.DefaultDict()
- with self.assertRaises(TypeError):
- typing.DefaultDict[KT, VT]()
- with self.assertRaises(TypeError):
- typing.DefaultDict[str, int]()
+ def test_defaultdict_instantiation(self):
+ self.assertIs(type(typing.DefaultDict()), collections.defaultdict)
+ self.assertIs(type(typing.DefaultDict[KT, VT]()), collections.defaultdict)
+ self.assertIs(type(typing.DefaultDict[str, int]()), collections.defaultdict)
def test_defaultdict_subclass(self):
self.assertIsSubclass(MyDefDict, collections.defaultdict)
self.assertNotIsSubclass(collections.defaultdict, MyDefDict)
+ @skipUnless(sys.version_info >= (3, 3), 'ChainMap was added in 3.3')
+ def test_chainmap_instantiation(self):
+ self.assertIs(type(typing.ChainMap()), collections.ChainMap)
+ self.assertIs(type(typing.ChainMap[KT, VT]()), collections.ChainMap)
+ self.assertIs(type(typing.ChainMap[str, int]()), collections.ChainMap)
+ class CM(typing.ChainMap[KT, VT]): ...
+ self.assertIs(type(CM[int, str]()), CM)
+
+ @skipUnless(sys.version_info >= (3, 3), 'ChainMap was added in 3.3')
+ def test_chainmap_subclass(self):
+
+ class MyChainMap(typing.ChainMap[str, int]):
+ pass
+
+ cm = MyChainMap()
+ self.assertIsInstance(cm, MyChainMap)
+
+ self.assertIsSubclass(MyChainMap, collections.ChainMap)
+ self.assertNotIsSubclass(collections.ChainMap, MyChainMap)
+
+ def test_deque_instantiation(self):
+ self.assertIs(type(typing.Deque()), collections.deque)
+ self.assertIs(type(typing.Deque[T]()), collections.deque)
+ self.assertIs(type(typing.Deque[int]()), collections.deque)
+ class D(typing.Deque[T]): ...
+ self.assertIs(type(D[int]()), D)
+
+ def test_counter_instantiation(self):
+ self.assertIs(type(typing.Counter()), collections.Counter)
+ self.assertIs(type(typing.Counter[T]()), collections.Counter)
+ self.assertIs(type(typing.Counter[int]()), collections.Counter)
+ class C(typing.Counter[T]): ...
+ self.assertIs(type(C[int]()), C)
+
+ def test_counter_subclass_instantiation(self):
+
+ class MyCounter(typing.Counter[int]):
+ pass
+
+ d = MyCounter()
+ self.assertIsInstance(d, MyCounter)
+ self.assertIsInstance(d, typing.Counter)
+ self.assertIsInstance(d, collections.Counter)
+
def test_no_set_instantiation(self):
with self.assertRaises(TypeError):
typing.Set()
with self.assertRaises(TypeError):
typing.Generator[int, int, int]()
+ @skipUnless(PY36, 'Python 3.6 required')
+ def test_async_generator(self):
+ ns = {}
+ exec("async def f():\n"
+ " yield 42\n", globals(), ns)
+ g = ns['f']()
+ self.assertIsSubclass(type(g), typing.AsyncGenerator)
+
+ @skipUnless(PY36, 'Python 3.6 required')
+ def test_no_async_generator_instantiation(self):
+ with self.assertRaises(TypeError):
+ typing.AsyncGenerator()
+ with self.assertRaises(TypeError):
+ typing.AsyncGenerator[T, T]()
+ with self.assertRaises(TypeError):
+ typing.AsyncGenerator[int, int]()
+
def test_subclassing(self):
class MMA(typing.MutableMapping):
self.assertIsSubclass(G, collections.Iterable)
self.assertNotIsSubclass(type(g), G)
+ @skipUnless(PY36, 'Python 3.6 required')
+ def test_subclassing_async_generator(self):
+ class G(typing.AsyncGenerator[int, int]):
+ def asend(self, value):
+ pass
+ def athrow(self, typ, val=None, tb=None):
+ pass
+
+ ns = {}
+ exec('async def g(): yield 0', globals(), ns)
+ g = ns['g']
+ self.assertIsSubclass(G, typing.AsyncGenerator)
+ self.assertIsSubclass(G, typing.AsyncIterable)
+ self.assertIsSubclass(G, collections.AsyncGenerator)
+ self.assertIsSubclass(G, collections.AsyncIterable)
+ self.assertNotIsSubclass(type(g), G)
+
+ instance = G()
+ self.assertIsInstance(instance, typing.AsyncGenerator)
+ self.assertIsInstance(instance, typing.AsyncIterable)
+ self.assertIsInstance(instance, collections.AsyncGenerator)
+ self.assertIsInstance(instance, collections.AsyncIterable)
+ self.assertNotIsInstance(type(g), G)
+ self.assertNotIsInstance(g, G)
+
def test_subclassing_subclasshook(self):
class Base(typing.Iterable):
def new_user(user_class: Type[User]) -> User:
return user_class()
- joe = new_user(BasicUser)
+ new_user(BasicUser)
def test_type_typevar(self):
def new_user(user_class: Type[U]) -> U:
return user_class()
- joe = new_user(BasicUser)
+ new_user(BasicUser)
def test_type_optional(self):
A = Optional[Type[BaseException]]
self.assertEqual(jim.id, 1)
self.assertEqual(Emp.__name__, 'Emp')
self.assertEqual(Emp._fields, ('name', 'id'))
- self.assertEqual(Emp._field_types, dict(name=str, id=int))
+ self.assertEqual(Emp.__annotations__,
+ collections.OrderedDict([('name', str), ('id', int)]))
+ self.assertIs(Emp._field_types, Emp.__annotations__)
+
+ def test_namedtuple_pyversion(self):
+ if sys.version_info[:2] < (3, 6):
+ with self.assertRaises(TypeError):
+ NamedTuple('Name', one=int, other=str)
+ with self.assertRaises(TypeError):
+ class NotYet(NamedTuple):
+ whatever = 0
@skipUnless(PY36, 'Python 3.6 required')
def test_annotation_usage(self):
self.assertEqual(tim.cool, 9000)
self.assertEqual(CoolEmployee.__name__, 'CoolEmployee')
self.assertEqual(CoolEmployee._fields, ('name', 'cool'))
- self.assertEqual(CoolEmployee._field_types, dict(name=str, cool=int))
+ self.assertEqual(CoolEmployee.__annotations__,
+ collections.OrderedDict(name=str, cool=int))
+ self.assertIs(CoolEmployee._field_types, CoolEmployee.__annotations__)
+
+ @skipUnless(PY36, 'Python 3.6 required')
+ def test_annotation_usage_with_default(self):
+ jelle = CoolEmployeeWithDefault('Jelle')
+ self.assertIsInstance(jelle, CoolEmployeeWithDefault)
+ self.assertIsInstance(jelle, tuple)
+ self.assertEqual(jelle.name, 'Jelle')
+ self.assertEqual(jelle.cool, 0)
+ cooler_employee = CoolEmployeeWithDefault('Sjoerd', 1)
+ self.assertEqual(cooler_employee.cool, 1)
+
+ self.assertEqual(CoolEmployeeWithDefault.__name__, 'CoolEmployeeWithDefault')
+ self.assertEqual(CoolEmployeeWithDefault._fields, ('name', 'cool'))
+ self.assertEqual(CoolEmployeeWithDefault._field_types, dict(name=str, cool=int))
+ self.assertEqual(CoolEmployeeWithDefault._field_defaults, dict(cool=0))
+
+ with self.assertRaises(TypeError):
+ exec("""
+class NonDefaultAfterDefault(NamedTuple):
+ x: int = 3
+ y: int
+""")
+
+ @skipUnless(PY36, 'Python 3.6 required')
+ def test_annotation_usage_with_methods(self):
+ self.assertEqual(XMeth(1).double(), 2)
+ self.assertEqual(XMeth(42).x, XMeth(42)[0])
+ self.assertEqual(str(XRepr(42)), '42 -> 1')
+ self.assertEqual(XRepr(1, 2) + XRepr(3), 0)
+
+ with self.assertRaises(AttributeError):
+ exec("""
+class XMethBad(NamedTuple):
+ x: int
+ def _fields(self):
+ return 'no chance for this'
+""")
@skipUnless(PY36, 'Python 3.6 required')
def test_namedtuple_keyword_usage(self):
self.assertEqual(nick.name, 'Nick')
self.assertEqual(LocalEmployee.__name__, 'LocalEmployee')
self.assertEqual(LocalEmployee._fields, ('name', 'age'))
- self.assertEqual(LocalEmployee._field_types, dict(name=str, age=int))
+ self.assertEqual(LocalEmployee.__annotations__, dict(name=str, age=int))
+ self.assertIs(LocalEmployee._field_types, LocalEmployee.__annotations__)
with self.assertRaises(TypeError):
NamedTuple('Name', [('x', int)], y=str)
with self.assertRaises(TypeError):
self.assertIsInstance(mat, Match)
# these should just work
- p = Pattern[Union[str, bytes]]
- m = Match[Union[bytes, str]]
+ Pattern[Union[str, bytes]]
+ Match[Union[bytes, str]]
+
+ def test_alias_equality(self):
+ self.assertEqual(Pattern[str], Pattern[str])
+ self.assertNotEqual(Pattern[str], Pattern[bytes])
+ self.assertNotEqual(Pattern[str], Match[str])
+ self.assertNotEqual(Pattern[str], str)
def test_errors(self):
with self.assertRaises(TypeError):
with self.assertRaises(TypeError):
# We don't support isinstance().
isinstance(42, Pattern[str])
+ with self.assertRaises(TypeError):
+ # We don't support issubclass().
+ issubclass(Pattern[bytes], Pattern[str])
def test_repr(self):
self.assertEqual(repr(Pattern), 'Pattern[~AnyStr]')
self.checkraises(TypeError, ' ', 'join', [1, 2, 3])
self.checkraises(TypeError, ' ', 'join', ['1', '2', 3])
+ @unittest.skipIf(sys.maxsize > 2**32,
+ 'needs too much memory on a 64-bit platform')
+ def test_join_overflow(self):
+ size = int(sys.maxsize**0.5) + 1
+ seq = ('A' * size,) * size
+ self.assertRaises(OverflowError, ''.join, seq)
+
def test_replace(self):
string_tests.CommonTest.test_replace(self)
with self.assertRaises(ValueError):
result = format_string % 2.34
+ def test_issue28598_strsubclass_rhs(self):
+ # A subclass of str with an __rmod__ method should be able to hook
+ # into the % operator
+ class SubclassedStr(str):
+ def __rmod__(self, other):
+ return 'Success, self.__rmod__({!r}) was called'.format(other)
+ self.assertEqual('lhs %% %r' % SubclassedStr('rhs'),
+ "Success, self.__rmod__('lhs %% %r') was called")
+
@support.cpython_only
def test_formatting_huge_precision_c_limits(self):
from _testcapi import INT_MAX
b'repr=%V', None, b'abc\xff')
# not supported: copy the raw format string. these tests are just here
- # to check for crashs and should not be considered as specifications
+ # to check for crashes and should not be considered as specifications
check_format('%s',
b'%1%s', b'abc')
check_format('%1abc',
def test_proxy_bypass_environment_host_match(self):
bypass = urllib.request.proxy_bypass_environment
self.env.set('NO_PROXY',
- 'localhost, anotherdomain.com, newdomain.com:1234')
+ 'localhost, anotherdomain.com, newdomain.com:1234, .d.o.t')
self.assertTrue(bypass('localhost'))
self.assertTrue(bypass('LocalHost')) # MixedCase
self.assertTrue(bypass('LOCALHOST')) # UPPERCASE
self.assertTrue(bypass('newdomain.com:1234'))
+ self.assertTrue(bypass('foo.d.o.t')) # issue 29142
self.assertTrue(bypass('anotherdomain.com:8888'))
self.assertTrue(bypass('www.newdomain.com:1234'))
self.assertFalse(bypass('prelocalhost'))
badtype(lambda: setattr(u, 'clock_seq_low', 0))
badtype(lambda: setattr(u, 'node', 0))
+ # Comparison with a non-UUID object
+ badtype(lambda: u < object())
+ badtype(lambda: u > object())
+
def test_getnode(self):
node1 = uuid.getnode()
self.assertTrue(0 < node1 < (1 << 48), '%012x' % node1)
else:
self.assertTrue(os.path.exists(os.devnull))
-
- @unittest.skipUnless(threading, 'some dependencies of pip import threading'
- ' module unconditionally')
- # Issue #26610: pip/pep425tags.py requires ctypes
- @unittest.skipUnless(ctypes, 'pip requires ctypes')
- def test_with_pip(self):
+ def do_test_with_pip(self, system_site_packages):
rmtree(self.env_dir)
with EnvironmentVarGuard() as envvars:
# pip's cross-version compatibility may trigger deprecation
# config in place to ensure we ignore it
try:
self.run_with_capture(venv.create, self.env_dir,
+ system_site_packages=system_site_packages,
with_pip=True)
except subprocess.CalledProcessError as exc:
# The output this produces can be a little hard to read,
out = out.decode("latin-1") # Force to text, prevent decoding errors
self.assertIn("Successfully uninstalled pip", out)
self.assertIn("Successfully uninstalled setuptools", out)
- # Check pip is now gone from the virtual environment
- self.assert_pip_not_installed()
+ # Check pip is now gone from the virtual environment. This only
+ # applies in the system_site_packages=False case, because in the
+ # other case, pip may still be available in the system site-packages
+ if not system_site_packages:
+ self.assert_pip_not_installed()
+ @unittest.skipUnless(threading, 'some dependencies of pip import threading'
+ ' module unconditionally')
+ # Issue #26610: pip/pep425tags.py requires ctypes
+ @unittest.skipUnless(ctypes, 'pip requires ctypes')
+ def test_with_pip(self):
+ self.do_test_with_pip(False)
+ self.do_test_with_pip(True)
if __name__ == "__main__":
unittest.main()
import operator
import contextlib
import copy
+import time
from test import support
from test.support import script_helper
self.cbcalled += 1
+@contextlib.contextmanager
+def collect_in_thread(period=0.0001):
+ """
+ Ensure GC collections happen in a different thread, at a high frequency.
+ """
+ threading = support.import_module('threading')
+ please_stop = False
+
+ def collect():
+ while not please_stop:
+ time.sleep(period)
+ gc.collect()
+
+ with support.disable_gc():
+ t = threading.Thread(target=collect)
+ t.start()
+ try:
+ yield
+ finally:
+ please_stop = True
+ t.join()
+
+
class ReferencesTestCase(TestBase):
def test_basic_ref(self):
dict = weakref.WeakKeyDictionary()
self.assertRegex(repr(dict), '<WeakKeyDictionary at 0x.*>')
+ def test_threaded_weak_valued_setdefault(self):
+ d = weakref.WeakValueDictionary()
+ with collect_in_thread():
+ for i in range(100000):
+ x = d.setdefault(10, RefCycle())
+ self.assertIsNot(x, None) # we never put None in there!
+ del x
+
+ def test_threaded_weak_valued_pop(self):
+ d = weakref.WeakValueDictionary()
+ with collect_in_thread():
+ for i in range(100000):
+ d[10] = RefCycle()
+ x = d.pop(10, 10)
+ self.assertIsNot(x, None) # we never put None in there!
+
+ def test_threaded_weak_valued_consistency(self):
+ # Issue #28427: old keys should not remove new values from
+ # WeakValueDictionary when collecting from another thread.
+ d = weakref.WeakValueDictionary()
+ with collect_in_thread():
+ for i in range(200000):
+ o = RefCycle()
+ d[10] = o
+ # o is still alive, so the dict can't be empty
+ self.assertEqual(len(d), 1)
+ o = None # lose ref
+
+
from test import mapping_tests
class WeakValueDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
'''
import io
-import unittest
+import os
import sys
+import tempfile
+import unittest
+from test import support
if sys.platform != 'win32':
raise unittest.SkipTest("test only relevant on win32")
self.assertFalse(issubclass(ConIO, io.TextIOBase))
def test_open_fd(self):
+ self.assertRaisesRegex(ValueError,
+ "negative file descriptor", ConIO, -1)
+
+ fd, _ = tempfile.mkstemp()
+ try:
+ # Windows 10: "Cannot open non-console file"
+ # Earlier: "Cannot open console output buffer for reading"
+ self.assertRaisesRegex(ValueError,
+ "Cannot open (console|non-console file)", ConIO, fd)
+ finally:
+ os.close(fd)
+
try:
f = ConIO(0)
except ValueError:
f.close()
def test_open_name(self):
+ self.assertRaises(ValueError, ConIO, sys.executable)
+
f = ConIO("CON")
self.assertTrue(f.readable())
self.assertFalse(f.writable())
f.close()
f.close()
+ f = open('C:/con', 'rb', buffering=0)
+ self.assertIsInstance(f, ConIO)
+ f.close()
+
+ @unittest.skipIf(sys.getwindowsversion()[:2] <= (6, 1),
+ "test does not work on Windows 7 and earlier")
+ def test_conin_conout_names(self):
+ f = open(r'\\.\conin$', 'rb', buffering=0)
+ self.assertIsInstance(f, ConIO)
+ f.close()
+
+ f = open('//?/conout$', 'wb', buffering=0)
+ self.assertIsInstance(f, ConIO)
+ f.close()
+
+ def test_conout_path(self):
+ temp_path = tempfile.mkdtemp()
+ self.addCleanup(support.rmtree, temp_path)
+
+ conout_path = os.path.join(temp_path, 'CONOUT$')
+
+ with open(conout_path, 'wb', buffering=0) as f:
+ if sys.getwindowsversion()[:2] > (6, 1):
+ self.assertIsInstance(f, ConIO)
+ else:
+ self.assertNotIsInstance(f, ConIO)
+
def assertStdinRoundTrip(self, text):
stdin = open('CONIN$', 'r')
old_stdin = sys.stdin
def delete_tree(self, root, subkey):
try:
- hkey = OpenKey(root, subkey, KEY_ALL_ACCESS)
+ hkey = OpenKey(root, subkey, 0, KEY_ALL_ACCESS)
except OSError:
# subkey does not exist
return
finally:
DeleteKey(HKEY_CURRENT_USER, test_key_name)
+ def test_read_string_containing_null(self):
+ # Test for issue 25778: REG_SZ should not contain null characters
+ try:
+ with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+ self.assertNotEqual(ck.handle, 0)
+ test_val = "A string\x00 with a null"
+ SetValueEx(ck, "test_name", 0, REG_SZ, test_val)
+ ret_val, ret_type = QueryValueEx(ck, "test_name")
+ self.assertEqual(ret_type, REG_SZ)
+ self.assertEqual(ret_val, "A string")
+ finally:
+ DeleteKey(HKEY_CURRENT_USER, test_key_name)
@unittest.skipUnless(REMOTE_NAME, "Skipping remote registry tests")
fresh=['_elementtree', 'xml.etree'])
+@unittest.skipUnless(cET, 'requires _elementtree')
class MiscTests(unittest.TestCase):
# Issue #8651.
@support.bigmemtest(size=support._2G + 100, memuse=1, dry_run=False)
del element.attrib
self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
+ def test_trashcan(self):
+ # If this test fails, it will most likely die via segfault.
+ e = root = cET.Element('root')
+ for i in range(200000):
+ e = cET.SubElement(e, 'x')
+ del e
+ del root
+ support.gc_collect()
+
@unittest.skipUnless(cET, 'requires _elementtree')
class TestAliasWorking(unittest.TestCase):
def _stop(self):
pass
+ def is_alive(self):
+ assert not self._is_stopped and self._started.is_set()
+ return True
+
def join(self, timeout=None):
assert False, "cannot join a dummy thread"
return r
def autorange(self, callback=None):
- """Return the number of loops so that total time >= 0.2.
+ """Return the number of loops and time taken so that total time >= 0.2.
Calls the timeit method with *number* set to successive powers of
ten (10, 100, 1000, ...) up to a maximum of one billion, until
-# -*-mode: python; fill-column: 75; tab-width: 8 -*-
-#
-# $Id$
-#
# Tix.py -- Tix widget wrappers.
#
# For Tix, see http://tix.sourceforge.net
import collections.abc as collections_abc
except ImportError:
import collections as collections_abc # Fallback for PY3.2.
+try:
+ from types import SlotWrapperType, MethodWrapperType, MethodDescriptorType
+except ImportError:
+ SlotWrapperType = type(object.__init__)
+ MethodWrapperType = type(object().__str__)
+ MethodDescriptorType = type(str.join)
# Please keep __all__ alphabetized within each category.
# ABCs (from collections.abc).
'AbstractSet', # collections.abc.Set.
+ 'GenericMeta', # subclass of abc.ABCMeta and a metaclass
+ # for 'Generic' and ABCs below.
'ByteString',
'Container',
'Hashable',
# AsyncIterable,
# Coroutine,
# Collection,
- # ContextManager
+ # ContextManager,
+ # AsyncGenerator,
# Structural checks, a.k.a. protocols.
'Reversible',
'SupportsRound',
# Concrete collection types.
+ 'Counter',
+ 'Deque',
'Dict',
'DefaultDict',
'List',
def _trim_name(nm):
- if nm.startswith('_') and nm not in ('_TypeAlias',
- '_ForwardRef', '_TypingBase', '_FinalTypingBase'):
+ whitelist = ('_TypeAlias', '_ForwardRef', '_TypingBase', '_FinalTypingBase')
+ if nm.startswith('_') and nm not in whitelist:
nm = nm[1:]
return nm
class _TypingBase(metaclass=TypingMeta, _root=True):
"""Internal indicator of special typing constructs."""
- __slots__ = ()
+ __slots__ = ('__weakref__',)
def __init__(self, *args, **kwds):
pass
return type(None)
if isinstance(arg, str):
arg = _ForwardRef(arg)
- if (isinstance(arg, _TypingBase) and type(arg).__name__ == '_ClassVar' or
- not isinstance(arg, (type, _TypingBase)) and not callable(arg)):
+ if (
+ isinstance(arg, _TypingBase) and type(arg).__name__ == '_ClassVar' or
+ not isinstance(arg, (type, _TypingBase)) and not callable(arg)
+ ):
raise TypeError(msg + " Got %.100r." % (arg,))
# Bare Union etc. are not valid as type arguments
- if (type(arg).__name__ in ('_Union', '_Optional')
- and not getattr(arg, '__origin__', None)
- or isinstance(arg, TypingMeta) and _gorg(arg) in (Generic, _Protocol)):
+ if (
+ type(arg).__name__ in ('_Union', '_Optional') and
+ not getattr(arg, '__origin__', None) or
+ isinstance(arg, TypingMeta) and _gorg(arg) in (Generic, _Protocol)
+ ):
raise TypeError("Plain %s is not valid as type argument" % arg)
return arg
'__covariant__', '__contravariant__')
def __init__(self, name, *constraints, bound=None,
- covariant=False, contravariant=False):
+ covariant=False, contravariant=False):
super().__init__(name, *constraints, bound=bound,
covariant=covariant, contravariant=contravariant)
self.__name__ = name
if tvars is None:
tvars = []
- if hasattr(arg, '_subs_tree'):
+ if hasattr(arg, '_subs_tree') and isinstance(arg, (GenericMeta, _TypingBase)):
return arg._subs_tree(tvars, args)
if isinstance(arg, TypeVar):
for i, tvar in enumerate(tvars):
return arg
+# Special typing constructs Union, Optional, Generic, Callable and Tuple
+# use three special attributes for internal bookkeeping of generic types:
+# * __parameters__ is a tuple of unique free type parameters of a generic
+# type, for example, Dict[T, T].__parameters__ == (T,);
+# * __origin__ keeps a reference to a type that was subscripted,
+# e.g., Union[T, int].__origin__ == Union;
+# * __args__ is a tuple of all arguments used in subscripting,
+# e.g., Dict[T, int].__args__ == (T, int).
+
+
def _subs_tree(cls, tvars=None, args=None):
"""An internal helper function: calculate substitution tree
for generic cls after replacing its type parameters with
# ... then continue replacing down the origin chain.
for ocls in orig_chain:
new_tree_args = []
- for i, arg in enumerate(ocls.__args__):
+ for arg in ocls.__args__:
new_tree_args.append(_replace_arg(arg, ocls.__parameters__, tree_args))
tree_args = new_tree_args
return tree_args
cached = functools.lru_cache()(func)
_cleanups.append(cached.cache_clear)
+
@functools.wraps(func)
def inner(*args, **kwds):
try:
return (Union,) + tree_args
def __eq__(self, other):
- if not isinstance(other, _Union):
+ if isinstance(other, _Union):
+ return self.__tree_hash__ == other.__tree_hash__
+ elif self is not Union:
return self._subs_tree() == other
- return self.__tree_hash__ == other.__tree_hash__
+ else:
+ return self is other
def __hash__(self):
return self.__tree_hash__
# Look for the last occurrence of Generic or Generic[...].
for i, c in enumerate(cls.__mro__[:-1]):
if isinstance(c, GenericMeta) and _gorg(c) is Generic:
- next_in_mro = cls.__mro__[i+1]
+ next_in_mro = cls.__mro__[i + 1]
return next_in_mro
-def _valid_for_check(cls):
- """An internal helper to prohibit isinstance([1], List[str]) etc."""
- if cls is Generic:
- raise TypeError("Class %r cannot be used with class "
- "or instance checks" % cls)
- if (cls.__origin__ is not None and
- sys._getframe(3).f_globals['__name__'] not in ['abc', 'functools']):
- raise TypeError("Parameterized generics cannot be used with class "
- "or instance checks")
-
-
def _make_subclasshook(cls):
"""Construct a __subclasshook__ callable that incorporates
the associated __extra__ class in subclass checks performed
# Registered classes need not be checked here because
# cls and its extra share the same _abc_registry.
def __extrahook__(subclass):
- _valid_for_check(cls)
res = cls.__extra__.__subclasshook__(subclass)
if res is not NotImplemented:
return res
else:
# For non-ABC extras we'll just call issubclass().
def __extrahook__(subclass):
- _valid_for_check(cls)
if cls.__extra__ and issubclass(subclass, cls.__extra__):
return True
return NotImplemented
class GenericMeta(TypingMeta, abc.ABCMeta):
- """Metaclass for generic types."""
+ """Metaclass for generic types.
+
+ This is a metaclass for typing.Generic and generic ABCs defined in
+ typing module. User defined subclasses of GenericMeta can override
+ __new__ and invoke super().__new__. Note that GenericMeta.__new__
+ has strict rules on what is allowed in its bases argument:
+ * plain Generic is disallowed in bases;
+ * Generic[...] should appear in bases at most once;
+ * if Generic[...] is present, then it should list all type variables
+ that appear in other bases.
+ In addition, type of all generic bases is erased, e.g., C[int] is
+ stripped to plain C.
+ """
def __new__(cls, name, bases, namespace,
tvars=None, args=None, origin=None, extra=None, orig_bases=None):
+ """Create a new generic class. GenericMeta.__new__ accepts
+ keyword arguments that are used for internal bookkeeping, therefore
+ an override should pass unused keyword arguments to super().
+ """
if tvars is not None:
# Called from __getitem__() below.
assert origin is not None
# remove bare Generic from bases if there are other generic bases
if any(isinstance(b, GenericMeta) and b is not Generic for b in bases):
bases = tuple(b for b in bases if b is not Generic)
+ namespace.update({'__origin__': origin, '__extra__': extra})
self = super().__new__(cls, name, bases, namespace, _root=True)
self.__parameters__ = tvars
self.__args__ = tuple(... if a is _TypingEllipsis else
() if a is _TypingEmpty else
a for a in args) if args else None
- self.__origin__ = origin
- self.__extra__ = extra
# Speed hack (https://github.com/python/typing/issues/196).
self.__next_in_mro__ = _next_in_mro(self)
# Preserve base classes on subclassing (__bases__ are type erased now).
# This allows unparameterized generic collections to be used
# with issubclass() and isinstance() in the same way as their
# collections.abc counterparts (e.g., isinstance([], Iterable)).
- if ('__subclasshook__' not in namespace and extra # allow overriding
- or hasattr(self.__subclasshook__, '__name__') and
- self.__subclasshook__.__name__ == '__extrahook__'):
+ if (
+ '__subclasshook__' not in namespace and extra or
+ # allow overriding
+ getattr(self.__subclasshook__, '__name__', '') == '__extrahook__'
+ ):
self.__subclasshook__ = _make_subclasshook(self)
if isinstance(extra, abc.ABCMeta):
self._abc_registry = extra._abc_registry
+ self._abc_cache = extra._abc_cache
+ elif origin is not None:
+ self._abc_registry = origin._abc_registry
+ self._abc_cache = origin._abc_cache
if origin and hasattr(origin, '__qualname__'): # Fix for Python 3.2.
self.__qualname__ = origin.__qualname__
- self.__tree_hash__ = hash(self._subs_tree()) if origin else hash((self.__name__,))
+ self.__tree_hash__ = (hash(self._subs_tree()) if origin else
+ super(GenericMeta, self).__hash__())
return self
+ # _abc_negative_cache and _abc_negative_cache_version
+ # realised as descriptors, since GenClass[t1, t2, ...] always
+ # share subclass info with GenClass.
+ # This is an important memory optimization.
+ @property
+ def _abc_negative_cache(self):
+ if isinstance(self.__extra__, abc.ABCMeta):
+ return self.__extra__._abc_negative_cache
+ return _gorg(self)._abc_generic_negative_cache
+
+ @_abc_negative_cache.setter
+ def _abc_negative_cache(self, value):
+ if self.__origin__ is None:
+ if isinstance(self.__extra__, abc.ABCMeta):
+ self.__extra__._abc_negative_cache = value
+ else:
+ self._abc_generic_negative_cache = value
+
+ @property
+ def _abc_negative_cache_version(self):
+ if isinstance(self.__extra__, abc.ABCMeta):
+ return self.__extra__._abc_negative_cache_version
+ return _gorg(self)._abc_generic_negative_cache_version
+
+ @_abc_negative_cache_version.setter
+ def _abc_negative_cache_version(self, value):
+ if self.__origin__ is None:
+ if isinstance(self.__extra__, abc.ABCMeta):
+ self.__extra__._abc_negative_cache_version = value
+ else:
+ self._abc_generic_negative_cache_version = value
+
def _get_type_vars(self, tvars):
if self.__origin__ and self.__parameters__:
_get_type_vars(self.__parameters__, tvars)
_check_generic(self, params)
tvars = _type_vars(params)
args = params
+
+ prepend = (self,) if self.__origin__ is None else ()
return self.__class__(self.__name__,
- self.__bases__,
+ prepend + self.__bases__,
_no_slots_copy(self.__dict__),
tvars=tvars,
args=args,
extra=self.__extra__,
orig_bases=self.__orig_bases__)
+ def __subclasscheck__(self, cls):
+ if self.__origin__ is not None:
+ if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools']:
+ raise TypeError("Parameterized generics cannot be used with class "
+ "or instance checks")
+ return False
+ if self is Generic:
+ raise TypeError("Class %r cannot be used with class "
+ "or instance checks" % self)
+ return super().__subclasscheck__(cls)
+
def __instancecheck__(self, instance):
# Since we extend ABC.__subclasscheck__ and
# ABC.__instancecheck__ inlines the cache checking done by the
self.__parameters__, self.__args__, self.__origin__,
self.__extra__, self.__orig_bases__)
+ def __setattr__(self, attr, value):
+ # We consider all the subscripted genrics as proxies for original class
+ if (
+ attr.startswith('__') and attr.endswith('__') or
+ attr.startswith('_abc_')
+ ):
+ super(GenericMeta, self).__setattr__(attr, value)
+ else:
+ super(GenericMeta, _gorg(self)).__setattr__(attr, value)
+
# Prevent checks for Generic to crash when defining Generic.
Generic = None
return super().__getitem__(parameters)
def __instancecheck__(self, obj):
- if self.__args__ == None:
+ if self.__args__ is None:
return isinstance(obj, tuple)
raise TypeError("Parameterized Tuple cannot be used "
"with isinstance().")
def __subclasscheck__(self, cls):
- if self.__args__ == None:
+ if self.__args__ is None:
return issubclass(cls, tuple)
raise TypeError("Parameterized Tuple cannot be used "
"with issubclass().")
with hashable arguments to improve speed.
"""
- if self.__origin__ is not None or not _geqv(self, Callable):
+ if self.__origin__ is not None or not _geqv(self, Callable):
return super().__getitem__(parameters)
if not isinstance(parameters, tuple) or len(parameters) != 2:
raise TypeError("Callable must be used as "
return super().__getitem__(parameters)
-class Callable(extra=collections_abc.Callable, metaclass = CallableMeta):
+class Callable(extra=collections_abc.Callable, metaclass=CallableMeta):
"""Callable type; Callable[[int], str] is a function of (int) -> str.
The subscription syntax must always be used with exactly two
return res
+_allowed_types = (types.FunctionType, types.BuiltinFunctionType,
+ types.MethodType, types.ModuleType,
+ SlotWrapperType, MethodWrapperType, MethodDescriptorType)
+
+
def get_type_hints(obj, globalns=None, localns=None):
"""Return type hints for an object.
hints = getattr(obj, '__annotations__', None)
if hints is None:
# Return empty annotations for something that _could_ have them.
- if (isinstance(obj, types.FunctionType) or
- isinstance(obj, types.BuiltinFunctionType) or
- isinstance(obj, types.MethodType) or
- isinstance(obj, types.ModuleType)):
+ if isinstance(obj, _allowed_types):
return {}
else:
raise TypeError('{!r} is not a module, class, method, '
no_type_check(obj)
try:
arg.__no_type_check__ = True
- except TypeError: # built-in classes
+ except TypeError: # built-in classes
pass
return arg
class MutableMapping(Mapping[KT, VT], extra=collections_abc.MutableMapping):
__slots__ = ()
+
if hasattr(collections_abc, 'Reversible'):
if hasattr(collections_abc, 'Collection'):
class Sequence(Reversible[T_co], Collection[T_co],
- extra=collections_abc.Sequence):
+ extra=collections_abc.Sequence):
__slots__ = ()
else:
class Sequence(Sized, Reversible[T_co], Container[T_co],
- extra=collections_abc.Sequence):
+ extra=collections_abc.Sequence):
__slots__ = ()
else:
class Sequence(Sized, Iterable[T_co], Container[T_co],
return _generic_new(list, cls, *args, **kwds)
+class Deque(collections.deque, MutableSequence[T], extra=collections.deque):
+
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, Deque):
+ return collections.deque(*args, **kwds)
+ return _generic_new(collections.deque, cls, *args, **kwds)
+
+
class Set(set, MutableSet[T], extra=set):
__slots__ = ()
"use dict() instead")
return _generic_new(dict, cls, *args, **kwds)
+
class DefaultDict(collections.defaultdict, MutableMapping[KT, VT],
extra=collections.defaultdict):
def __new__(cls, *args, **kwds):
if _geqv(cls, DefaultDict):
- raise TypeError("Type DefaultDict cannot be instantiated; "
- "use collections.defaultdict() instead")
+ return collections.defaultdict(*args, **kwds)
return _generic_new(collections.defaultdict, cls, *args, **kwds)
+
+class Counter(collections.Counter, Dict[T, int], extra=collections.Counter):
+
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, Counter):
+ return collections.Counter(*args, **kwds)
+ return _generic_new(collections.Counter, cls, *args, **kwds)
+
+
+if hasattr(collections, 'ChainMap'):
+ # ChainMap only exists in 3.3+
+ __all__.append('ChainMap')
+
+ class ChainMap(collections.ChainMap, MutableMapping[KT, VT],
+ extra=collections.ChainMap):
+
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, ChainMap):
+ return collections.ChainMap(*args, **kwds)
+ return _generic_new(collections.ChainMap, cls, *args, **kwds)
+
+
# Determine what base class to use for Generator.
if hasattr(collections_abc, 'Generator'):
# Sufficiently recent versions of 3.5 have a Generator ABC.
return _generic_new(_G_base, cls, *args, **kwds)
+if hasattr(collections_abc, 'AsyncGenerator'):
+ class AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra],
+ extra=collections_abc.AsyncGenerator):
+ __slots__ = ()
+
+ __all__.append('AsyncGenerator')
+
+
# Internal type variable used for Type[].
CT_co = TypeVar('CT_co', covariant=True, bound=type)
msg = "NamedTuple('Name', [(f0, t0), (f1, t1), ...]); each t must be a type"
types = [(n, _type_check(t, msg)) for n, t in types]
nm_tpl = collections.namedtuple(name, [n for n, t in types])
- nm_tpl._field_types = dict(types)
+ # Prior to PEP 526, only _field_types attribute was assigned.
+ # Now, both __annotations__ and _field_types are used to maintain compatibility.
+ nm_tpl.__annotations__ = nm_tpl._field_types = collections.OrderedDict(types)
try:
nm_tpl.__module__ = sys._getframe(2).f_globals.get('__name__', '__main__')
except (AttributeError, ValueError):
_PY36 = sys.version_info[:2] >= (3, 6)
+# attributes prohibited to set in NamedTuple class syntax
+_prohibited = ('__new__', '__init__', '__slots__', '__getnewargs__',
+ '_fields', '_field_defaults', '_field_types',
+ '_make', '_replace', '_asdict')
+
+_special = ('__module__', '__name__', '__qualname__', '__annotations__')
+
class NamedTupleMeta(type):
raise TypeError("Class syntax for NamedTuple is only supported"
" in Python 3.6+")
types = ns.get('__annotations__', {})
- return _make_nmtuple(typename, types.items())
+ nm_tpl = _make_nmtuple(typename, types.items())
+ defaults = []
+ defaults_dict = {}
+ for field_name in types:
+ if field_name in ns:
+ default_value = ns[field_name]
+ defaults.append(default_value)
+ defaults_dict[field_name] = default_value
+ elif defaults:
+ raise TypeError("Non-default namedtuple field {field_name} cannot "
+ "follow default field(s) {default_names}"
+ .format(field_name=field_name,
+ default_names=', '.join(defaults_dict.keys())))
+ nm_tpl.__new__.__defaults__ = tuple(defaults)
+ nm_tpl._field_defaults = defaults_dict
+ # update from user namespace without overriding special namedtuple attributes
+ for key in ns:
+ if key in _prohibited:
+ raise AttributeError("Cannot overwrite NamedTuple attribute " + key)
+ elif key not in _special and key not in nm_tpl._fields:
+ setattr(nm_tpl, key, ns[key])
+ return nm_tpl
+
class NamedTuple(metaclass=NamedTupleMeta):
"""Typed version of namedtuple.
Employee = collections.namedtuple('Employee', ['name', 'id'])
- The resulting class has one extra attribute: _field_types,
- giving a dict mapping field names to types. (The field names
+ The resulting class has extra __annotations__ and _field_types
+ attributes, giving an ordered dict mapping field names to types.
+ __annotations__ should be preferred, while _field_types
+ is kept to maintain pre PEP 526 compatibility. (The field names
are in the _fields attribute, which is part of the namedtuple
API.) Alternative equivalent keyword syntax is also accepted::
TextIO = TextIO
BinaryIO = BinaryIO
+
io.__name__ = __name__ + '.io'
sys.modules[io.__name__] = io
Pattern = Pattern
Match = Match
+
re.__name__ = __name__ + '.re'
sys.modules[re.__name__] = re
self._loading_packages = set()
def loadTestsFromTestCase(self, testCaseClass):
- """Return a suite of all tests cases contained in testCaseClass"""
+ """Return a suite of all test cases contained in testCaseClass"""
if issubclass(testCaseClass, suite.TestSuite):
raise TypeError("Test cases should not be derived from "
"TestSuite. Maybe you meant to derive from "
# XXX After Python 3.5, remove backward compatibility hacks for
# use_load_tests deprecation via *args and **kws. See issue 16662.
def loadTestsFromModule(self, module, *args, pattern=None, **kws):
- """Return a suite of all tests cases contained in the given module"""
+ """Return a suite of all test cases contained in the given module"""
# This method used to take an undocumented and unofficial
# use_load_tests argument. For backward compatibility, we still
# accept the argument (which can also be the first position) but we
return tests
def loadTestsFromName(self, name, module=None):
- """Return a suite of all tests cases given a string specifier.
+ """Return a suite of all test cases given a string specifier.
The name may resolve either to a module, a test case class, a
test method within a test case class, or a callable object which
raise TypeError("don't know how to make test from: %s" % obj)
def loadTestsFromNames(self, names, module=None):
- """Return a suite of all tests cases found using the given sequence
+ """Return a suite of all test cases found using the given sequence
of string specifiers. See 'loadTestsFromName()'.
"""
suites = [self.loadTestsFromName(name, module) for name in names]
def assert_called_once_with(_mock_self, *args, **kwargs):
- """assert that the mock was called exactly once and with the specified
- arguments."""
+ """assert that the mock was called exactly once and that that call was
+ with the specified arguments."""
self = _mock_self
if not self.call_count == 1:
msg = ("Expected '%s' to be called once. Called %s times." %
ret_val = self.__eq__._mock_return_value
if ret_val is not DEFAULT:
return ret_val
- return self is other
+ if self is other:
+ return True
+ return NotImplemented
return __eq__
def _get_ne(self):
def __ne__(other):
if self.__ne__._mock_return_value is not DEFAULT:
return DEFAULT
- return self is not other
+ if self is other:
+ return False
+ return NotImplemented
return __ne__
def _get_iter(self):
If the _Call has no name then it will match any name.
"""
- def __new__(cls, value=(), name=None, parent=None, two=False,
+ def __new__(cls, value=(), name='', parent=None, two=False,
from_kall=True):
- name = ''
args = ()
kwargs = {}
_len = len(value)
### Tests for TestLoader.loadTestsFromTestCase
################################################################
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
def test_loadTestsFromTestCase(self):
class Foo(unittest.TestCase):
loader = unittest.TestLoader()
self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
#
# Make sure it does the right thing even if no tests were found
loader = unittest.TestLoader()
self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite)
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
#
# What happens if loadTestsFromTestCase() is given an object
else:
self.fail('Should raise TypeError')
- # "Return a suite of all tests cases contained in the TestCase-derived
+ # "Return a suite of all test cases contained in the TestCase-derived
# class testCaseClass"
#
# Make sure loadTestsFromTestCase() picks up the default test method
other_args = _Call(((1, 2), {'a': 3}))
self.assertEqual(args, other_args)
+ def test_call_with_name(self):
+ self.assertEqual(_Call((), 'foo')[0], 'foo')
+ self.assertEqual(_Call((('bar', 'barz'),),)[0], '')
+ self.assertEqual(_Call((('bar', 'barz'), {'hello': 'world'}),)[0], '')
+
class SpecSignatureTest(unittest.TestCase):
def test_calls_equal_with_any(self):
- call1 = mock.call(mock.MagicMock())
- call2 = mock.call(mock.ANY)
-
# Check that equality and non-equality is consistent even when
# comparing with mock.ANY
+ mm = mock.MagicMock()
+ self.assertTrue(mm == mm)
+ self.assertFalse(mm != mm)
+ self.assertFalse(mm == mock.MagicMock())
+ self.assertTrue(mm != mock.MagicMock())
+ self.assertTrue(mm == mock.ANY)
+ self.assertFalse(mm != mock.ANY)
+ self.assertTrue(mock.ANY == mm)
+ self.assertFalse(mock.ANY != mm)
+
+ call1 = mock.call(mock.MagicMock())
+ call2 = mock.call(mock.ANY)
self.assertTrue(call1 == call2)
self.assertFalse(call1 != call2)
+ self.assertTrue(call2 == call1)
+ self.assertFalse(call2 != call1)
def test_assert_called_with(self):
no_proxy_list = [proxy.strip() for proxy in no_proxy.split(',')]
for name in no_proxy_list:
if name:
+ name = name.lstrip('.') # ignore leading dots
name = re.escape(name)
pattern = r'(.+\.)?%s$' % name
if (re.match(pattern, hostonly, re.I)
"""
env_dir = os.path.abspath(env_dir)
context = self.ensure_directories(env_dir)
+ # See issue 24875. We need system_site_packages to be False
+ # until after pip is installed.
+ true_system_site_packages = self.system_site_packages
+ self.system_site_packages = False
self.create_configuration(context)
self.setup_python(context)
if self.with_pip:
if not self.upgrade:
self.setup_scripts(context)
self.post_setup(context)
+ if true_system_site_packages:
+ # We had set it to False before, now
+ # restore it and rewrite the configuration
+ self.system_site_packages = True
+ self.create_configuration(context)
def clear_directory(self, path):
for fn in os.listdir(path):
dstfile = os.path.join(dstdir, f)
with open(srcfile, 'rb') as f:
data = f.read()
- if srcfile.endswith('.exe'):
- mode = 'wb'
- else:
- mode = 'w'
+ if not srcfile.endswith('.exe'):
try:
data = data.decode('utf-8')
data = self.replace_variables(data, context)
- except UnicodeDecodeError as e:
+ data = data.encode('utf-8')
+ except UnicodeError as e:
data = None
logger.warning('unable to copy script %r, '
'may be binary: %s', srcfile, e)
if data is not None:
- with open(dstfile, mode) as f:
+ with open(dstfile, 'wb') as f:
f.write(data)
shutil.copymode(srcfile, dstfile)
}\r
\r
deactivate -nondestructive\r
-
+\r
$env:VIRTUAL_ENV="__VENV_DIR__"\r
\r
-# Set the prompt to include the env name\r
-# Make sure _OLD_VIRTUAL_PROMPT is global\r
-function global:_OLD_VIRTUAL_PROMPT {""}\r
-copy-item function:prompt function:_OLD_VIRTUAL_PROMPT\r
-function global:prompt {\r
- Write-Host -NoNewline -ForegroundColor Green '__VENV_PROMPT__'\r
- _OLD_VIRTUAL_PROMPT\r
+if (! $env:VIRTUAL_ENV_DISABLE_PROMPT) {\r
+ # Set the prompt to include the env name\r
+ # Make sure _OLD_VIRTUAL_PROMPT is global\r
+ function global:_OLD_VIRTUAL_PROMPT {""}\r
+ copy-item function:prompt function:_OLD_VIRTUAL_PROMPT\r
+ function global:prompt {\r
+ Write-Host -NoNewline -ForegroundColor Green '__VENV_PROMPT__'\r
+ _OLD_VIRTUAL_PROMPT\r
+ }\r
}\r
\r
# Clear PYTHONHOME\r
proxy,
CallableProxyType,
ProxyType,
- ReferenceType)
+ ReferenceType,
+ _remove_dead_weakref)
from _weakrefset import WeakSet, _IterationGuard
self, *args = args
if len(args) > 1:
raise TypeError('expected at most 1 arguments, got %d' % len(args))
- def remove(wr, selfref=ref(self)):
+ def remove(wr, selfref=ref(self), _atomic_removal=_remove_dead_weakref):
self = selfref()
if self is not None:
if self._iterating:
self._pending_removals.append(wr.key)
else:
- del self.data[wr.key]
+ # Atomic removal is necessary since this function
+ # can be called asynchronously by the GC
+ _atomic_removal(d, wr.key)
self._remove = remove
# A list of keys to be removed
self._pending_removals = []
# We shouldn't encounter any KeyError, because this method should
# always be called *before* mutating the dict.
while l:
- del d[l.pop()]
+ key = l.pop()
+ _remove_dead_weakref(d, key)
def __getitem__(self, key):
+ if self._pending_removals:
+ self._commit_removals()
o = self.data[key]()
if o is None:
raise KeyError(key)
del self.data[key]
def __len__(self):
- return len(self.data) - len(self._pending_removals)
+ if self._pending_removals:
+ self._commit_removals()
+ return len(self.data)
def __contains__(self, key):
+ if self._pending_removals:
+ self._commit_removals()
try:
o = self.data[key]()
except KeyError:
self.data[key] = KeyedRef(value, self._remove, key)
def copy(self):
+ if self._pending_removals:
+ self._commit_removals()
new = WeakValueDictionary()
for key, wr in self.data.items():
o = wr()
def __deepcopy__(self, memo):
from copy import deepcopy
+ if self._pending_removals:
+ self._commit_removals()
new = self.__class__()
for key, wr in self.data.items():
o = wr()
return new
def get(self, key, default=None):
+ if self._pending_removals:
+ self._commit_removals()
try:
wr = self.data[key]
except KeyError:
return o
def items(self):
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for k, wr in self.data.items():
v = wr()
yield k, v
def keys(self):
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for k, wr in self.data.items():
if wr() is not None:
keep the values around longer than needed.
"""
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
yield from self.data.values()
def values(self):
+ if self._pending_removals:
+ self._commit_removals()
with _IterationGuard(self):
for wr in self.data.values():
obj = wr()
try:
o = self.data.pop(key)()
except KeyError:
+ o = None
+ if o is None:
if args:
return args[0]
- raise
- if o is None:
- raise KeyError(key)
+ else:
+ raise KeyError(key)
else:
return o
def setdefault(self, key, default=None):
try:
- wr = self.data[key]
+ o = self.data[key]()
except KeyError:
+ o = None
+ if o is None:
if self._pending_removals:
self._commit_removals()
self.data[key] = KeyedRef(default, self._remove, key)
return default
else:
- return wr()
+ return o
def update(*args, **kwargs):
if not args:
keep the values around longer than needed.
"""
+ if self._pending_removals:
+ self._commit_removals()
return list(self.data.values())
# set the modified flag so central directory gets written
# even if no files are added to the archive
self._didModify = True
+ self._start_disk = 0
try:
- self.start_dir = self._start_disk = self.fp.tell()
+ self.start_dir = self.fp.tell()
except (AttributeError, OSError):
self.fp = _Tellable(self.fp)
- self.start_dir = self._start_disk = 0
+ self.start_dir = 0
self._seekable = False
else:
# Some file-like objects can provide tell() but not seek()
Python 2.6.
In addition to what is supplied with OS X 10.5+ and Xcode 3+, the script
-requires an installed version of hg and a third-party version of
+requires an installed version of git and a third-party version of
Tcl/Tk 8.4 (for OS X 10.4 and 10.5 deployment targets) or Tcl/TK 8.5
(for 10.6 or later) installed in /Library/Frameworks. When installed,
the Python built by this script will attempt to dynamically link first to
32-bit-only installer builds are still possible on OS X 10.4 with Xcode 2.5
and the installation of additional components, such as a newer Python
-(2.5 is needed for Python parser updates), hg, and for the documentation
+(2.5 is needed for Python parser updates), git, and for the documentation
build either svn (pre-3.4.1) or sphinx-build (3.4.1 and later).
Usage: see USAGE variable in the script.
result.extend([
dict(
- name="OpenSSL 1.0.2j",
- url="https://www.openssl.org/source/openssl-1.0.2j.tar.gz",
- checksum='96322138f0b69e61b7212bc53d5e912b',
+ name="OpenSSL 1.0.2k",
+ url="https://www.openssl.org/source/openssl-1.0.2k.tar.gz",
+ checksum='f965fc0bf01bf882b31314b61391ae65',
patches=[
"openssl_sdk_makedepend.patch",
],
base_path = base_path + ':' + OLD_DEVELOPER_TOOLS
os.environ['PATH'] = base_path
print("Setting default PATH: %s"%(os.environ['PATH']))
- # Ensure ws have access to hg and to sphinx-build.
+ # Ensure ws have access to git and to sphinx-build.
# You may have to create links in /usr/bin for them.
- runCommand('hg --version')
+ runCommand('git --version')
runCommand('sphinx-build --version')
def parseOptions(args=None):
shellQuote(WORKDIR)[1:-1],
shellQuote(WORKDIR)[1:-1]))
- print("Running make touch")
- runCommand("make touch")
+ # bpo-29550: avoid using make touch until it is fixed for git
+ # print("Running make touch")
+ # runCommand("make touch")
print("Running make")
runCommand("make")
# HG changeset patch
#
-# using openssl 1.0.2j
+# using openssl 1.0.2k
#
# - support building with an OS X SDK
<key>CFBundleExecutable</key>
<string>IDLE</string>
<key>CFBundleGetInfoString</key>
- <string>%version%, © 2001-2016 Python Software Foundation</string>
+ <string>%version%, © 2001-2017 Python Software Foundation</string>
<key>CFBundleIconFile</key>
<string>IDLE.icns</string>
<key>CFBundleIdentifier</key>
<key>CFBundleExecutable</key>
<string>Python Launcher</string>
<key>CFBundleGetInfoString</key>
- <string>%VERSION%, © 2001-2016 Python Software Foundation</string>
+ <string>%VERSION%, © 2001-2017 Python Software Foundation</string>
<key>CFBundleIconFile</key>
<string>PythonLauncher.icns</string>
<key>CFBundleIdentifier</key>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleLongVersionString</key>
- <string>%version%, (c) 2001-2016 Python Software Foundation.</string>
+ <string>%version%, (c) 2001-2017 Python Software Foundation.</string>
<key>CFBundleName</key>
<string>Python</string>
<key>CFBundlePackageType</key>
<key>CFBundlePackageType</key>
<string>FMWK</string>
<key>CFBundleShortVersionString</key>
- <string>%VERSION%, (c) 2001-2016 Python Software Foundation.</string>
+ <string>%VERSION%, (c) 2001-2017 Python Software Foundation.</string>
<key>CFBundleLongVersionString</key>
- <string>%VERSION%, (c) 2001-2016 Python Software Foundation.</string>
+ <string>%VERSION%, (c) 2001-2017 Python Software Foundation.</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleVersion</key>
READELF= @READELF@
SOABI= @SOABI@
LDVERSION= @LDVERSION@
-HGVERSION= @HGVERSION@
-HGTAG= @HGTAG@
-HGBRANCH= @HGBRANCH@
+GITVERSION= @GITVERSION@
+GITTAG= @GITTAG@
+GITBRANCH= @GITBRANCH@
PGO_PROF_GEN_FLAG=@PGO_PROF_GEN_FLAG@
PGO_PROF_USE_FLAG=@PGO_PROF_USE_FLAG@
LLVM_PROF_MERGER=@LLVM_PROF_MERGER@
$(MODOBJS) \
$(srcdir)/Modules/getbuildinfo.c
$(CC) -c $(PY_CORE_CFLAGS) \
- -DHGVERSION="\"`LC_ALL=C $(HGVERSION)`\"" \
- -DHGTAG="\"`LC_ALL=C $(HGTAG)`\"" \
- -DHGBRANCH="\"`LC_ALL=C $(HGBRANCH)`\"" \
+ -DGITVERSION="\"`LC_ALL=C $(GITVERSION)`\"" \
+ -DGITTAG="\"`LC_ALL=C $(GITTAG)`\"" \
+ -DGITBRANCH="\"`LC_ALL=C $(GITBRANCH)`\"" \
-o $@ $(srcdir)/Modules/getbuildinfo.c
Modules/getpath.o: $(srcdir)/Modules/getpath.c Makefile
$(srcdir)/Objects/stringlib/unicode_format.h \
$(srcdir)/Objects/stringlib/unicodedefs.h
+Objects/bytes_methods.o: $(srcdir)/Objects/bytes_methods.c $(BYTESTR_DEPS)
Objects/bytesobject.o: $(srcdir)/Objects/bytesobject.c $(BYTESTR_DEPS)
-
Objects/bytearrayobject.o: $(srcdir)/Objects/bytearrayobject.c $(BYTESTR_DEPS)
Objects/unicodeobject.o: $(srcdir)/Objects/unicodeobject.c $(UNICODE_DEPS)
turtledemo \
multiprocessing multiprocessing/dummy \
unittest unittest/test unittest/test/testmock \
- venv venv/scripts venv/scripts/posix \
+ venv venv/scripts venv/scripts/common venv/scripts/posix \
curses pydoc_data
libinstall: build_all $(srcdir)/Modules/xxmodule.c
@for i in $(SCRIPTDIR) $(LIBDEST); \
Mark Anacker
Shashwat Anand
Anders Andersen
+Tycho Andersen
John Anderson
Pehr Anderson
Erik Andersén
Paul Boddie
Matthew Boedicker
Robin Boerdijk
+Andra Bogildea
Nikolay Bogoychev
David Bolen
Wouter Bolsterlee
Anthony Briggs
Keith Briggs
Tobias Brink
+Dillon Brock
Richard Brodie
Michael Broghton
Ammar Brohi
Tarn Weisner Burton
Lee Busby
Katherine Busch
+Matthias Bussonnier
Ralph Butler
Laurent De Buyst
Zach Byrne
Adal Chiriliuc
Matt Chisholm
Lita Cho
+Sayan Chowdhury
Anders Chrigström
Tom Christiansen
Renee Chu
Merlijn van Deen
John DeGood
Ned Deily
+Jim DeLaHunt
Vincent Delft
Arnaud Delobelle
Konrad Delong
Josip Djolonga
Walter Dörwald
Jaromir Dolecek
+Brendan Donegan
Ismail Donmez
Robert Donohue
Marcos Donolo
Bob Ippolito
Roger Irwin
Atsuo Ishimoto
+Alexey Izbyshev
Kasia Jachim
Adam Jackson
Ben Jackson
Chris Lawrence
Mark Lawrence
Chris Laws
+Michael Layzell
Michael Lazar
Brian Leair
Mathieu Leduc-Hamel
Randy Pausch
Samuele Pedroni
Justin Peel
+Loic Pefferkorn
Marcel van der Peijl
Berker Peksag
Andreas Pelme
Yuxiao Zeng
Uwe Zessin
Cheng Zhang
-Xiang Zhang
Kai Zhu
Tarek Ziadé
Jelle Zijlstra
Doug Zongker
Peter Åstrand
evilzero
+Dhushyanth Ramasamy
======================================================================
+What's New in Python 3.4.6?
+===========================
+
+Release date: 2017-01-17
+
+There were no changes between 3.4.6rc1 and 3.4.6 final.
+
+
+What's New in Python 3.4.6rc1?
+==============================
+
+Release date: 2017-01-02
+
+Core and Builtins
+-----------------
+
+- Issue #28648: Fixed crash in Py_DecodeLocale() in debug build on Mac OS X
+ when decode astral characters. Patch by Xiang Zhang.
+
+- Issue #28426: Fixed potential crash in PyUnicode_AsDecodedObject() in debug
+ build.
+
+Library
+-------
+
+- Issue #28563: Fixed possible DoS and arbitrary code execution when handle
+ plural form selections in the gettext module. The expression parser now
+ supports exact syntax supported by GNU gettext.
+
+- In the curses module, raise an error if window.getstr() or window.instr() is
+ passed a negative value.
+
+- Issue #27783: Fix possible usage of uninitialized memory in operator.methodcaller.
+
+- Issue #27774: Fix possible Py_DECREF on unowned object in _sre.
+
+- Issue #27760: Fix possible integer overflow in binascii.b2a_qp.
+
+- Issue #27758: Fix possible integer overflow in the _csv module for large record
+ lengths.
+
+- Issue #27568: Prevent HTTPoxy attack (CVE-2016-1000110). Ignore the
+ HTTP_PROXY variable when REQUEST_METHOD environment is set, which indicates
+ that the script is in CGI mode.
+
+- Issue #27759: Fix selectors incorrectly retain invalid file descriptors.
+ Patch by Mark Williams.
+
+Build
+-----
+
+- Issue #28248: Update Windows build to use OpenSSL 1.0.2j.
+
+Tests
+-----
+
+- Issue #27369: In test_pyexpat, avoid testing an error message detail that
+ changed in Expat 2.2.0.
+
+
+What's New in Python 3.4.5?
+===========================
+
+Release date: 2016-06-26
+
+Tests
+-----
+
+- Issue #26867: Ubuntu's openssl OP_NO_SSLv3 is forced on by default; fix test.
+
+
+What's New in Python 3.4.5rc1?
+==============================
+
+Release date: 2016-06-11
+
+Core and Builtins
+-----------------
+
+- Issue #26478: Fix semantic bugs when using binary operators with dictionary
+ views and tuples.
+
+- Issue #26171: Fix possible integer overflow and heap corruption in
+ zipimporter.get_data().
+
+Library
+-------
+
+- Issue #26556: Update expat to 2.1.1, fixes CVE-2015-1283.
+
+- Fix TLS stripping vulnerability in smptlib, CVE-2016-0772. Reported by Team
+ Oststrom
+
+- Issue #25939: On Windows open the cert store readonly in ssl.enum_certificates.
+
+- Issue #26012: Don't traverse into symlinks for ** pattern in
+ pathlib.Path.[r]glob().
+
+- Issue #24120: Ignore PermissionError when traversing a tree with
+ pathlib.Path.[r]glob(). Patch by Ulrich Petri.
+
+- Skip getaddrinfo if host is already resolved.
+ Patch by A. Jesse Jiryu Davis.
+
+- Add asyncio.timeout() context manager.
+
+- Issue #26050: Add asyncio.StreamReader.readuntil() method.
+ Patch by Марк Коренберг.
+
+Tests
+-----
+
+- Issue #25940: Changed test_ssl to use self-signed.pythontest.net. This
+ avoids relying on svn.python.org, which recently changed root certificate.
+
+
+What's New in Python 3.4.4?
+===========================
+
+Release date: 2015/12/20
+
+Windows
+-------
+
+- Issue #25844: Corrected =/== typo potentially leading to crash in launcher.
+
+
+What's New in Python 3.4.4rc1?
+==============================
+
+Release date: 2015/12/06
+
+Core and Builtins
+-----------------
+
+- Issue #25709: Fixed problem with in-place string concatenation and utf-8
+ cache.
+
+- Issue #24097: Fixed crash in object.__reduce__() if slot name is freed inside
+ __getattr__.
+
+- Issue #24731: Fixed crash on converting objects with special methods
+ __bytes__, __trunc__, and __float__ returning instances of subclasses of
+ bytes, int, and float to subclasses of bytes, int, and float correspondingly.
+
+- Issue #25388: Fixed tokenizer crash when processing undecodable source code
+ with a null byte.
+
+- Issue #22995: Default implementation of __reduce__ and __reduce_ex__ now
+ rejects builtin types with not defined __new__.
+
+- Issue #24802: Avoid buffer overreads when int(), float(), compile(), exec()
+ and eval() are passed bytes-like objects. These objects are not
+ necessarily terminated by a null byte, but the functions assumed they were.
+
+- Issue #24402: Fix input() to prompt to the redirected stdout when
+ sys.stdout.fileno() fails.
+
+- Issue #24806: Prevent builtin types that are not allowed to be subclassed from
+ being subclassed through multiple inheritance.
+
+- Issue #24848: Fixed a number of bugs in UTF-7 decoding of misformed data.
+
+- Issue #25280: Import trace messages emitted in verbose (-v) mode are no
+ longer formatted twice.
+
+- Issue #25003: os.urandom() doesn't use getentropy() on Solaris because
+ getentropy() is blocking, whereas os.urandom() should not block. getentropy()
+ is supported since Solaris 11.3.
+
+- Issue #25182: The stdprinter (used as sys.stderr before the io module is
+ imported at startup) now uses the backslashreplace error handler.
+
+- Issue #24891: Fix a race condition at Python startup if the file descriptor
+ of stdin (0), stdout (1) or stderr (2) is closed while Python is creating
+ sys.stdin, sys.stdout and sys.stderr objects. These attributes are now set
+ to None if the creation of the object failed, instead of raising an OSError
+ exception. Initial patch written by Marco Paolini.
+
+- Issue #21167: NAN operations are now handled correctly when python is
+ compiled with ICC even if -fp-model strict is not specified.
+
+- Issue #4395: Better testing and documentation of binary operators.
+ Patch by Martin Panter.
+
+- Issue #24467: Fixed possible buffer over-read in bytearray. The bytearray
+ object now always allocates place for trailing null byte and it's buffer now
+ is always null-terminated.
+
+- Issue #24115: Update uses of PyObject_IsTrue(), PyObject_Not(),
+ PyObject_IsInstance(), PyObject_RichCompareBool() and _PyDict_Contains()
+ to check for and handle errors correctly.
+
+- Issue #24257: Fixed system error in the comparison of faked
+ types.SimpleNamespace.
+
+- Issue #22939: Fixed integer overflow in iterator object. Patch by
+ Clement Rouault.
+
+- Issue #23985: Fix a possible buffer overrun when deleting a slice from
+ the front of a bytearray and then appending some other bytes data.
+
+- Issue #24102: Fixed exception type checking in standard error handlers.
+
+- Issue #23757: PySequence_Tuple() incorrectly called the concrete list API
+ when the data was a list subclass.
+
+- Issue #24407: Fix crash when dict is mutated while being updated.
+
+- Issue #24096: Make warnings.warn_explicit more robust against mutation of the
+ warnings.filters list.
+
+- Issue #23996: Avoid a crash when a delegated generator raises an
+ unnormalized StopIteration exception. Patch by Stefan Behnel.
+
+- Issue #24022: Fix tokenizer crash when processing undecodable source code.
+
+- Issue #23309: Avoid a deadlock at shutdown if a daemon thread is aborted
+ while it is holding a lock to a buffered I/O object, and the main thread
+ tries to use the same I/O object (typically stdout or stderr). A fatal
+ error is emitted instead.
+
+- Issue #22977: Fixed formatting Windows error messages on Wine.
+ Patch by Martin Panter.
+
+- Issue #23803: Fixed str.partition() and str.rpartition() when a separator
+ is wider then partitioned string.
+
+- Issue #23192: Fixed generator lambdas. Patch by Bruno Cauet.
+
+- Issue #23629: Fix the default __sizeof__ implementation for variable-sized
+ objects.
+
+- Issue #24044: Fix possible null pointer dereference in list.sort in out of
+ memory conditions.
+
+- Issue #21354: PyCFunction_New function is exposed by python DLL again.
+
+Library
+-------
+
+- Issue #24903: Fix regression in number of arguments compileall accepts when
+ '-d' is specified. The check on the number of arguments has been dropped
+ completely as it never worked correctly anyway.
+
+- Issue #25764: In the subprocess module, preserve any exception caused by
+ fork() failure when preexec_fn is used.
+
+- Issue #6478: _strptime's regexp cache now is reset after changing timezone
+ with time.tzset().
+
+- Issue #25177: Fixed problem with the mean of very small and very large
+ numbers. As a side effect, statistics.mean and statistics.variance should
+ be significantly faster.
+
+- Issue #25718: Fixed copying object with state with boolean value is false.
+
+- Issue #10131: Fixed deep copying of minidom documents. Based on patch
+ by Marian Ganisin.
+
+- Issue #25725: Fixed a reference leak in pickle.loads() when unpickling
+ invalid data including tuple instructions.
+
+- Issue #25663: In the Readline completer, avoid listing duplicate global
+ names, and search the global namespace before searching builtins.
+
+- Issue #25688: Fixed file leak in ElementTree.iterparse() raising an error.
+
+- Issue #23914: Fixed SystemError raised by unpickler on broken pickle data.
+
+- Issue #25691: Fixed crash on deleting ElementTree.Element attributes.
+
+- Issue #25624: ZipFile now always writes a ZIP_STORED header for directory
+ entries. Patch by Dingyuan Wang.
+
+- Issue #25583: Avoid incorrect errors raised by os.makedirs(exist_ok=True)
+ when the OS gives priority to errors such as EACCES over EEXIST.
+
+- Issue #25593: Change semantics of EventLoop.stop() in asyncio.
+
+- Issue #6973: When we know a subprocess.Popen process has died, do
+ not allow the send_signal(), terminate(), or kill() methods to do
+ anything as they could potentially signal a different process.
+
+- Issue #25578: Fix (another) memory leak in SSLSocket.getpeercer().
+
+- Issue #25590: In the Readline completer, only call getattr() once per
+ attribute.
+
+- Issue #25498: Fix a crash when garbage-collecting ctypes objects created
+ by wrapping a memoryview. This was a regression made in 3.4.3. Based
+ on patch by Eryksun.
+
+- Issue #18010: Fix the pydoc web server's module search function to handle
+ exceptions from importing packages.
+
+- Issue #25510: fileinput.FileInput.readline() now returns b'' instead of ''
+ at the end if the FileInput was opened with binary mode.
+ Patch by Ryosuke Ito.
+
+- Issue #25530: Disable the vulnerable SSLv3 protocol by default when creating
+ ssl.SSLContext.
+
+- Issue #25569: Fix memory leak in SSLSocket.getpeercert().
+
+- Issue #21827: Fixed textwrap.dedent() for the case when largest common
+ whitespace is a substring of smallest leading whitespace.
+ Based on patch by Robert Li.
+
+- Issue #25471: Sockets returned from accept() shouldn't appear to be
+ nonblocking.
+
+- Issue #25441: asyncio: Raise error from drain() when socket is closed.
+
+- Issue #25411: Improved Unicode support in SMTPHandler through better use of
+ the email package. Thanks to user simon04 for the patch.
+
+- Issue #25380: Fixed protocol for the STACK_GLOBAL opcode in
+ pickletools.opcodes.
+
+- Issue #23972: Updates asyncio datagram create method allowing reuseport
+ and reuseaddr socket options to be set prior to binding the socket.
+ Mirroring the existing asyncio create_server method the reuseaddr option
+ for datagram sockets defaults to True if the O/S is 'posix' (except if the
+ platform is Cygwin). Patch by Chris Laws.
+
+- Issue #25304: Add asyncio.run_coroutine_threadsafe(). This lets you
+ submit a coroutine to a loop from another thread, returning a
+ concurrent.futures.Future. By Vincent Michel.
+
+- Issue #25319: When threading.Event is reinitialized, the underlying condition
+ should use a regular lock rather than a recursive lock.
+
+- Issue #25232: Fix CGIRequestHandler to split the query from the URL at the
+ first question mark (?) rather than the last. Patch from Xiang Zhang.
+
+- Issue #24657: Prevent CGIRequestHandler from collapsing slashes in the
+ query part of the URL as if it were a path. Patch from Xiang Zhang.
+
+- Issue #22958: Constructor and update method of weakref.WeakValueDictionary
+ now accept the self and the dict keyword arguments.
+
+- Issue #22609: Constructor of collections.UserDict now accepts the self keyword
+ argument.
+
+- Issue #25262. Added support for BINBYTES8 opcode in Python implementation of
+ unpickler. Highest 32 bits of 64-bit size for BINUNICODE8 and BINBYTES8
+ opcodes no longer silently ignored on 32-bit platforms in C implementation.
+
+- Issue #25034: Fix string.Formatter problem with auto-numbering and
+ nested format_specs. Patch by Anthon van der Neut.
+
+- Issue #25233: Rewrite the guts of asyncio.Queue and
+ asyncio.Semaphore to be more understandable and correct.
+
+- Issue #23600: Default implementation of tzinfo.fromutc() was returning
+ wrong results in some cases.
+
+- Issue #25203: Failed readline.set_completer_delims() no longer left the
+ module in inconsistent state.
+
+- Prevent overflow in _Unpickler_Read.
+
+- Issue #25047: The XML encoding declaration written by Element Tree now
+ respects the letter case given by the user. This restores the ability to
+ write encoding names in uppercase like "UTF-8", which worked in Python 2.
+
+- Issue #19143: platform module now reads Windows version from kernel32.dll to
+ avoid compatibility shims.
+
+- Issue #23517: Fix rounding in fromtimestamp() and utcfromtimestamp() methods
+ of datetime.datetime: microseconds are now rounded to nearest with ties
+ going to nearest even integer (ROUND_HALF_EVEN), instead of being rounding
+ towards zero (ROUND_DOWN). It's important that these methods use the same
+ rounding mode than datetime.timedelta to keep the property:
+ (datetime(1970,1,1) + timedelta(seconds=t)) == datetime.utcfromtimestamp(t).
+ It also the rounding mode used by round(float) for example.
+
+- Issue #24684: socket.socket.getaddrinfo() now calls
+ PyUnicode_AsEncodedString() instead of calling the encode() method of the
+ host, to handle correctly custom string with an encode() method which doesn't
+ return a byte string. The encoder of the IDNA codec is now called directly
+ instead of calling the encode() method of the string.
+
+- Issue #24982: shutil.make_archive() with the "zip" format now adds entries
+ for directories (including empty directories) in ZIP file.
+
+- Issue #24857: Comparing call_args to a long sequence now correctly returns a
+ boolean result instead of raising an exception. Patch by A Kaptur.
+
+- Issue #25019: Fixed a crash caused by setting non-string key of expat parser.
+ Based on patch by John Leitch.
+
+- Issue #24917: time_strftime() buffer over-read.
+
+- Issue #23144: Make sure that HTMLParser.feed() returns all the data, even
+ when convert_charrefs is True.
+
+- Issue #16180: Exit pdb if file has syntax error, instead of trapping user
+ in an infinite loop. Patch by Xavier de Gaye.
+
+- Issue #21112: Fix regression in unittest.expectedFailure on subclasses.
+ Patch from Berker Peksag.
+
+- Issue #24931: Instances of subclasses of namedtuples have their own __dict__
+ which breaks the inherited __dict__ property and breaks the _asdict() method.
+ Removed the __dict__ property to prevent the conflict and fixed _asdict().
+
+- Issue #24764: cgi.FieldStorage.read_multi() now ignores the Content-Length
+ header in part headers. Patch written by Peter Landry and reviewed by Pierre
+ Quentel.
+
+- Issue #24774: Fix docstring in http.server.test. Patch from Chiu-Hsiang Hsu.
+
+- Issue #21159: Improve message in configparser.InterpolationMissingOptionError.
+ Patch from Łukasz Langa.
+
+- Issue #23888: Handle fractional time in cookie expiry. Patch by ssh.
+
+- Issue #23004: mock_open() now reads binary data correctly when the type of
+ read_data is bytes. Initial patch by Aaron Hill.
+
+- Issue #23652: Make it possible to compile the select module against the
+ libc headers from the Linux Standard Base, which do not include some
+ EPOLL macros. Patch by Matt Frank.
+
+- Issue #22932: Fix timezones in email.utils.formatdate.
+ Patch from Dmitry Shachnev.
+
+- Issue #23779: imaplib raises TypeError if authenticator tries to abort.
+ Patch from Craig Holmquist.
+
+- Issue #23319: Fix ctypes.BigEndianStructure, swap correctly bytes. Patch
+ written by Matthieu Gautier.
+
+- Issue #23254: Document how to close the TCPServer listening socket.
+ Patch from Martin Panter.
+
+- Issue #19450: Update Windows and OS X installer builds to use SQLite 3.8.11.
+
+- Issue #23441: rcompleter now prints a tab character instead of displaying
+ possible completions for an empty word. Initial patch by Martin Sekera.
+
+- Issue #24735: Fix invalid memory access in
+ itertools.combinations_with_replacement().
+
+- Issue #17527: Add PATCH to wsgiref.validator. Patch from Luca Sbardella.
+
+- Issue #24683: Fixed crashes in _json functions called with arguments of
+ inappropriate type.
+
+- Issue #21697: shutil.copytree() now correctly handles symbolic links that
+ point to directories. Patch by Eduardo Seabra and Thomas Kluyver.
+
+- Issue #24620: Random.setstate() now validates the value of state last element.
+
+- Issue #22153: Improve unittest docs. Patch from Martin Panter and evilzero.
+
+- Issue #24206: Fixed __eq__ and __ne__ methods of inspect classes.
+
+- Issue #21750: mock_open.read_data can now be read from each instance, as it
+ could in Python 3.3.
+
+- Issue #23247: Fix a crash in the StreamWriter.reset() of CJK codecs.
+
+- Issue #18622: unittest.mock.mock_open().reset_mock would recurse infinitely.
+ Patch from Nicola Palumbo and Laurent De Buyst.
+
+- Issue #24608: chunk.Chunk.read() now always returns bytes, not str.
+
+- Issue #18684: Fixed reading out of the buffer in the re module.
+
+- Issue #24259: tarfile now raises a ReadError if an archive is truncated
+ inside a data segment.
+
+- Issue #24552: Fix use after free in an error case of the _pickle module.
+
+- Issue #24514: tarfile now tolerates number fields consisting of only
+ whitespace.
+
+- Issue #19176: Fixed doctype() related bugs in C implementation of ElementTree.
+ A deprecation warning no longer issued by XMLParser subclass with default
+ doctype() method. Direct call of doctype() now issues a warning. Parser's
+ doctype() now is not called if target's doctype() is called. Based on patch
+ by Martin Panter.
+
+- Issue #20387: Restore semantic round-trip correctness in tokenize/untokenize
+ for tab-indented blocks.
+
+- Issue #24456: Fixed possible buffer over-read in adpcm2lin() and lin2adpcm()
+ functions of the audioop module.
+
+- Issue #24336: The contextmanager decorator now works with functions with
+ keyword arguments called "func" and "self". Patch by Martin Panter.
+
+- Issue #24489: ensure a previously set C errno doesn't disturb cmath.polar().
+
+- Issue #5633: Fixed timeit when the statement is a string and the setup is not.
+
+- Issue #24326: Fixed audioop.ratecv() with non-default weightB argument.
+ Original patch by David Moore.
+
+- Issue #23840: tokenize.open() now closes the temporary binary file on error
+ to fix a resource warning.
+
+- Issue #24257: Fixed segmentation fault in sqlite3.Row constructor with faked
+ cursor type.
+
+- Issue #22107: tempfile.gettempdir() and tempfile.mkdtemp() now try again
+ when a directory with the chosen name already exists on Windows as well as
+ on Unix. tempfile.mkstemp() now fails early if parent directory is not
+ valid (not exists or is a file) on Windows.
+
+- Issue #6598: Increased time precision and random number range in
+ email.utils.make_msgid() to strengthen the uniqueness of the message ID.
+
+- Issue #24091: Fixed various crashes in corner cases in C implementation of
+ ElementTree.
+
+- Issue #21931: msilib.FCICreate() now raises TypeError in the case of a bad
+ argument instead of a ValueError with a bogus FCI error number.
+ Patch by Jeffrey Armstrong.
+
+- Issue #23796: peek and read1 methods of BufferedReader now raise ValueError
+ if they called on a closed object. Patch by John Hergenroeder.
+
+- Issue #24521: Fix possible integer overflows in the pickle module.
+
+- Issue #22931: Allow '[' and ']' in cookie values.
+
+- Issue #20274: Remove ignored and erroneous "kwargs" parameters from three
+ METH_VARARGS methods on _sqlite.Connection.
+
+- Issue #24094: Fix possible crash in json.encode with poorly behaved dict
+ subclasses.
+
+- Asyncio issue 222 / PR 231 (Victor Stinner) -- fix @coroutine
+ functions without __name__.
+
+- Issue #9246: On POSIX, os.getcwd() now supports paths longer than 1025 bytes.
+ Patch written by William Orr.
+
+- The keywords attribute of functools.partial is now always a dictionary.
+
+- Issues #24099, #24100, and #24101: Fix free-after-use bug in heapq's siftup
+ and siftdown functions.
+
+- Backport collections.deque fixes from Python 3.5. Prevents reentrant badness
+ during deletion by deferring the decref until the container has been restored
+ to a consistent state.
+
+- Issue #23008: Fixed resolving attributes with boolean value is False in pydoc.
+
+- Fix asyncio issue 235: LifoQueue and PriorityQueue's put didn't
+ increment unfinished tasks (this bug was introduced in 3.4.3 when
+ JoinableQueue was merged with Queue).
+
+- Issue #23908: os functions now reject paths with embedded null character
+ on Windows instead of silently truncate them.
+
+- Issue #23728: binascii.crc_hqx() could return an integer outside of the range
+ 0-0xffff for empty data.
+
+- Issue #23811: Add missing newline to the PyCompileError error message.
+ Patch by Alex Shkop.
+
+- Issue #17898: Fix exception in gettext.py when parsing certain plural forms.
+
+- Issue #22982: Improve BOM handling when seeking to multiple positions of
+ a writable text file.
+
+- Issue #23865: close() methods in multiple modules now are idempotent and more
+ robust at shutdown. If they need to release multiple resources, all are
+ released even if errors occur.
+
+- Issue #23881: urllib.request.ftpwrapper constructor now closes the socket if
+ the FTP connection failed to fix a ResourceWarning.
+
+- Issue #23400: Raise same exception on both Python 2 and 3 if sem_open is not
+ available. Patch by Davin Potts.
+
+- Issue #15133: _tkinter.tkapp.getboolean() now supports Tcl_Obj and always
+ returns bool. tkinter.BooleanVar now validates input values (accepted bool,
+ int, str, and Tcl_Obj). tkinter.BooleanVar.get() now always returns bool.
+
+- Issue #23338: Fixed formatting ctypes error messages on Cygwin.
+ Patch by Makoto Kato.
+
+- Issue #16840: Tkinter now supports 64-bit integers added in Tcl 8.4 and
+ arbitrary precision integers added in Tcl 8.5.
+
+- Issue #23834: Fix socket.sendto(), use the C Py_ssize_t type to store the
+ result of sendto() instead of the C int type.
+
+- Issue #21526: Tkinter now supports new boolean type in Tcl 8.5.
+
+- Issue #23838: linecache now clears the cache and returns an empty result on
+ MemoryError.
+
+- Issue #18473: Fixed 2to3 and 3to2 compatible pickle mappings. Fixed
+ ambigious reverse mappings. Added many new mappings. Import mapping is no
+ longer applied to modules already mapped with full name mapping.
+
+- Issue #23745: The new email header parser now handles duplicate MIME
+ parameter names without error, similar to how get_param behaves.
+
+- Issue #23792: Ignore KeyboardInterrupt when the pydoc pager is active.
+ This mimics the behavior of the standard unix pagers, and prevents
+ pipepager from shutting down while the pager itself is still running.
+
+- Issue #23742: ntpath.expandvars() no longer loses unbalanced single quotes.
+
+- Issue #21802: The reader in BufferedRWPair now is closed even when closing
+ writer failed in BufferedRWPair.close().
+
+- Issue #23671: string.Template now allows to specify the "self" parameter as
+ keyword argument. string.Formatter now allows to specify the "self" and
+ the "format_string" parameters as keyword arguments.
+
+- Issue #21560: An attempt to write a data of wrong type no longer cause
+ GzipFile corruption. Original patch by Wolfgang Maier.
+
+- Issue #23647: Increase impalib's MAXLINE to accommodate modern mailbox sizes.
+
+- Issue #23539: If body is None, http.client.HTTPConnection.request now sets
+ Content-Length to 0 for PUT, POST, and PATCH headers to avoid 411 errors from
+ some web servers.
+
+- Issue #22351: The nntplib.NNTP constructor no longer leaves the connection
+ and socket open until the garbage collector cleans them up. Patch by
+ Martin Panter.
+
+- Issue #23136: _strptime now uniformly handles all days in week 0, including
+ Dec 30 of previous year. Based on patch by Jim Carroll.
+
+- Issue #23700: Iterator of NamedTemporaryFile now keeps a reference to
+ NamedTemporaryFile instance. Patch by Bohuslav Kabrda.
+
+- Issue #22903: The fake test case created by unittest.loader when it fails
+ importing a test module is now picklable.
+
+- Issue #23568: Add rdivmod support to MagicMock() objects.
+ Patch by Håkan Lövdahl.
+
+- Issue #23138: Fixed parsing cookies with absent keys or values in cookiejar.
+ Patch by Demian Brecht.
+
+- Issue #23051: multiprocessing.Pool methods imap() and imap_unordered() now
+ handle exceptions raised by an iterator. Patch by Alon Diamant and Davin
+ Potts.
+
+- Issue #22928: Disabled HTTP header injections in http.client.
+ Original patch by Demian Brecht.
+
+- Issue #23615: Modules bz2, tarfile and tokenize now can be reloaded with
+ imp.reload(). Patch by Thomas Kluyver.
+
+- Issue #23476: In the ssl module, enable OpenSSL's X509_V_FLAG_TRUSTED_FIRST
+ flag on certificate stores when it is available.
+
+- Issue #23576: Avoid stalling in SSL reads when EOF has been reached in the
+ SSL layer but the underlying connection hasn't been closed.
+
+- Issue #23504: Added an __all__ to the types module.
+
+- Issue #20204: Added the __module__ attribute to _tkinter classes.
+
+- Issue #23521: Corrected pure python implementation of timedelta division.
+
+ * Eliminated OverflowError from timedelta * float for some floats;
+ * Corrected rounding in timedlta true division.
+
+- Issue #21619: Popen objects no longer leave a zombie after exit in the with
+ statement if the pipe was broken. Patch by Martin Panter.
+
+- Issue #6639: Module-level turtle functions no longer raise TclError after
+ closing the window.
+
+- Issues #814253, #9179: Warnings now are raised when group references and
+ conditional group references are used in lookbehind assertions in regular
+ expressions.
+
+- Issue #23215: Multibyte codecs with custom error handlers that ignores errors
+ consumed too much memory and raised SystemError or MemoryError.
+ Original patch by Aleksi Torhamo.
+
+- Issue #5700: io.FileIO() called flush() after closing the file.
+ flush() was not called in close() if closefd=False.
+
+- Issue #23374: Fixed pydoc failure with non-ASCII files when stdout encoding
+ differs from file system encoding (e.g. on Mac OS).
+
+- Issue #23481: Remove RC4 from the SSL module's default cipher list.
+
+- Issue #21548: Fix pydoc.synopsis() and pydoc.apropos() on modules with empty
+ docstrings.
+
+- Issue #22885: Fixed arbitrary code execution vulnerability in the dbm.dumb
+ module. Original patch by Claudiu Popa.
+
+- Issue #23146: Fix mishandling of absolute Windows paths with forward
+ slashes in pathlib.
+
+- Issue #23421: Fixed compression in tarfile CLI. Patch by wdv4758h.
+
+- Issue #23367: Fix possible overflows in the unicodedata module.
+
+- Issue #23361: Fix possible overflow in Windows subprocess creation code.
+
+- Issue #23801: Fix issue where cgi.FieldStorage did not always ignore the
+ entire preamble to a multipart body.
+
+- Issue #23310: Fix MagicMock's initializer to work with __methods__, just
+ like configure_mock(). Patch by Kasia Jachim.
+
+- asyncio: New event loop APIs: set_task_factory() and get_task_factory().
+
+- asyncio: async() function is deprecated in favour of ensure_future().
+
+- Issue #23898: Fix inspect.classify_class_attrs() to support attributes
+ with overloaded __eq__ and __bool__. Patch by Mike Bayer.
+
+- Issue #24298: Fix inspect.signature() to correctly unwrap wrappers
+ around bound methods.
+
+- Issue #23572: Fixed functools.singledispatch on classes with falsy
+ metaclasses. Patch by Ethan Furman.
+
+IDLE
+----
+
+- Issue 15348: Stop the debugger engine (normally in a user process)
+ before closing the debugger window (running in the IDLE process).
+ This prevents the RuntimeErrors that were being caught and ignored.
+
+- Issue #24455: Prevent IDLE from hanging when a) closing the shell while the
+ debugger is active (15347); b) closing the debugger with the [X] button
+ (15348); and c) activating the debugger when already active (24455).
+ The patch by Mark Roseman does this by making two changes.
+ 1. Suspend and resume the gui.interaction method with the tcl vwait
+ mechanism intended for this purpose (instead of root.mainloop & .quit).
+ 2. In gui.run, allow any existing interaction to terminate first.
+
+- Change 'The program' to 'Your program' in an IDLE 'kill program?' message
+ to make it clearer that the program referred to is the currently running
+ user program, not IDLE itself.
+
+- Issue #24750: Improve the appearance of the IDLE editor window status bar.
+ Patch by Mark Roseman.
+
+- Issue #25313: Change the handling of new built-in text color themes to better
+ address the compatibility problem introduced by the addition of IDLE Dark.
+ Consistently use the revised idleConf.CurrentTheme everywhere in idlelib.
+
+- Issue #24782: Extension configuration is now a tab in the IDLE Preferences
+ dialog rather than a separate dialog. The former tabs are now a sorted
+ list. Patch by Mark Roseman.
+
+- Issue #22726: Re-activate the config dialog help button with some content
+ about the other buttons and the new IDLE Dark theme.
+
+- Issue #24820: IDLE now has an 'IDLE Dark' built-in text color theme.
+ It is more or less IDLE Classic inverted, with a cobalt blue background.
+ Strings, comments, keywords, ... are still green, red, orange, ... .
+ To use it with IDLEs released before November 2015, hit the
+ 'Save as New Custom Theme' button and enter a new name,
+ such as 'Custom Dark'. The custom theme will work with any IDLE
+ release, and can be modified.
+
+- Issue #25224: README.txt is now an idlelib index for IDLE developers and
+ curious users. The previous user content is now in the IDLE doc chapter.
+ 'IDLE' now means 'Integrated Development and Learning Environment'.
+
+- Issue #24820: Users can now set breakpoint colors in
+ Settings -> Custom Highlighting. Original patch by Mark Roseman.
+
+- Issue #24972: Inactive selection background now matches active selection
+ background, as configured by users, on all systems. Found items are now
+ always highlighted on Windows. Initial patch by Mark Roseman.
+
+- Issue #24570: Idle: make calltip and completion boxes appear on Macs
+ affected by a tk regression. Initial patch by Mark Roseman.
+
+- Issue #24988: Idle ScrolledList context menus (used in debugger)
+ now work on Mac Aqua. Patch by Mark Roseman.
+
+- Issue #24801: Make right-click for context menu work on Mac Aqua.
+ Patch by Mark Roseman.
+
+- Issue #25173: Associate tkinter messageboxes with a specific widget.
+ For Mac OSX, make them a 'sheet'. Patch by Mark Roseman.
+
+- Issue #25198: Enhance the initial html viewer now used for Idle Help.
+ * Properly indent fixed-pitch text (patch by Mark Roseman).
+ * Give code snippet a very Sphinx-like light blueish-gray background.
+ * Re-use initial width and height set by users for shell and editor.
+ * When the Table of Contents (TOC) menu is used, put the section header
+ at the top of the screen.
+
+- Issue #25225: Condense and rewrite Idle doc section on text colors.
+
+- Issue #21995: Explain some differences between IDLE and console Python.
+
+- Issue #22820: Explain need for *print* when running file from Idle editor.
+
+- Issue #25224: Doc: augment Idle feature list and no-subprocess section.
+
+- Issue #25219: Update doc for Idle command line options.
+ Some were missing and notes were not correct.
+
+- Issue #24861: Most of idlelib is private and subject to change.
+ Use idleib.idle.* to start Idle. See idlelib.__init__.__doc__.
+
+- Issue #25199: Idle: add synchronization comments for future maintainers.
+
+- Issue #16893: Replace help.txt with help.html for Idle doc display.
+ The new idlelib/help.html is rstripped Doc/build/html/library/idle.html.
+ It looks better than help.txt and will better document Idle as released.
+ The tkinter html viewer that works for this file was written by Mark Roseman.
+ The now unused EditorWindow.HelpDialog class and helt.txt file are deprecated.
+
+- Issue #24199: Deprecate unused idlelib.idlever with possible removal in 3.6.
+
+- Issue #24790: Remove extraneous code (which also create 2 & 3 conflicts).
+
+- Issue #23672: Allow Idle to edit and run files with astral chars in name.
+ Patch by Mohd Sanad Zaki Rizvi.
+
+- Issue 24745: Idle editor default font. Switch from Courier to
+ platform-sensitive TkFixedFont. This should not affect current customized
+ font selections. If there is a problem, edit $HOME/.idlerc/config-main.cfg
+ and remove 'fontxxx' entries from [Editor Window]. Patch by Mark Roseman.
+
+- Issue #21192: Idle editor. When a file is run, put its name in the restart bar.
+ Do not print false prompts. Original patch by Adnan Umer.
+
+- Issue #13884: Idle menus. Remove tearoff lines. Patch by Roger Serwy.
+
+- Issue #23184: remove unused names and imports in idlelib.
+ Initial patch by Al Sweigart.
+
+Tests
+-----
+
+- Issue #25616: Tests for OrderedDict are extracted from test_collections
+ into separate file test_ordered_dict.
+
+- Issue #25099: Make test_compileall not fail when an entry on sys.path cannot
+ be written to (commonly seen in administrative installs on Windows).
+
+- Issue #24751: When running regrtest with the ``-w`` command line option,
+ a test run is no longer marked as a failure if all tests succeed when
+ re-run.
+
+- Issue #21520: test_zipfile no longer fails if the word 'bad' appears
+ anywhere in the name of the current directory.
+
+- Issue #23799: Added test.support.start_threads() for running and
+ cleaning up multiple threads.
+
+- Issue #22390: test.regrtest now emits a warning if temporary files or
+ directories are left after running a test.
+
+- Issue #23583: Added tests for standard IO streams in IDLE.
+
+Build
+-----
+
+- Issue #23445: pydebug builds now use "gcc -Og" where possible, to make
+ the resulting executable faster.
+
+- Issue #24603: Update Windows builds to use OpenSSL1.0.2d
+ and OS X 10.5 installer to use OpenSSL 1.0.2e.
+
+C API
+-----
+
+- Issue #23998: PyImport_ReInitLock() now checks for lock allocation error
+
+Documentation
+-------------
+
+- Issue #12067: Rewrite Comparisons section in the Expressions chapter of the
+ language reference. Some of the details of comparing mixed types were
+ incorrect or ambiguous. NotImplemented is only relevant at a lower level
+ than the Expressions chapter. Added details of comparing range() objects,
+ and default behaviour and consistency suggestions for user-defined classes.
+ Patch from Andy Maier.
+
+- Issue #24952: Clarify the default size argument of stack_size() in
+ the "threading" and "_thread" modules. Patch from Mattip.
+
+- Issue #24808: Update the types of some PyTypeObject fields. Patch by
+ Joseph Weston.
+
+- Issue #22812: Fix unittest discovery examples.
+ Patch from Pam McA'Nulty.
+
+- Issue #24129: Clarify the reference documentation for name resolution.
+ This includes removing the assumption that readers will be familiar with the
+ name resolution scheme Python used prior to the introduction of lexical
+ scoping for function namespaces. Patch by Ivan Levkivskyi.
+
+- Issue #20769: Improve reload() docs. Patch by Dorian Pula.
+
+- Issue #23589: Remove duplicate sentence from the FAQ. Patch by Yongzhi Pan.
+
+- Issue #24729: Correct IO tutorial to match implementation regarding
+ encoding parameter to open function.
+
+- Issue #24351: Clarify what is meant by "identifier" in the context of
+ string.Template instances.
+
+- Issue #22155: Add File Handlers subsection with createfilehandler to tkinter
+ doc. Remove obsolete example from FAQ. Patch by Martin Panter.
+
+- Issue #24029: Document the name binding behavior for submodule imports.
+
+- Issue #24077: Fix typo in man page for -I command option: -s, not -S.
+
+Tools/Demos
+-----------
+
+- Issue #25440: Fix output of python-config --extension-suffix.
+
+- Issue #23330: h2py now supports arbitrary filenames in #include.
+
+- Issue #24031: make patchcheck now supports git checkouts, too.
+
+Windows
+-------
+
+- Issue #24306: Sets component ID for launcher to match 3.5 and later
+ to avoid downgrading.
+
+- Issue #25022: Removed very outdated PC/example_nt/ directory.
+
+
+What's New in Python 3.4.3?
+===========================
+
+Release date: 2015-02-23
+
+Core and Builtins
+-----------------
+
+- Issue #22735: Fix many edge cases (including crashes) involving custom mro()
+ implementations.
+
+- Issue #22896: Avoid using PyObject_AsCharBuffer(), PyObject_AsReadBuffer()
+ and PyObject_AsWriteBuffer().
+
+- Issue #21295: Revert some changes (issue #16795) to AST line numbers and
+ column offsets that constituted a regression.
+
+- Issue #21408: The default __ne__() now returns NotImplemented if __eq__()
+ returned NotImplemented. Original patch by Martin Panter.
+
+- Issue #23321: Fixed a crash in str.decode() when error handler returned
+ replacment string longer than mailformed input data.
+
+- Issue #23048: Fix jumping out of an infinite while loop in the pdb.
+
+- Issue #20335: bytes constructor now raises TypeError when encoding or errors
+ is specified with non-string argument. Based on patch by Renaud Blanch.
+
+- Issue #22335: Fix crash when trying to enlarge a bytearray to 0x7fffffff
+ bytes on a 32-bit platform.
+
+- Issue #22653: Fix an assertion failure in debug mode when doing a reentrant
+ dict insertion in debug mode.
+
+- Issue #22643: Fix integer overflow in Unicode case operations (upper, lower,
+ title, swapcase, casefold).
+
+- Issue #22604: Fix assertion error in debug mode when dividing a complex
+ number by (nan+0j).
+
+- Issue #22470: Fixed integer overflow issues in "backslashreplace",
+ "xmlcharrefreplace", and "surrogatepass" error handlers.
+
+- Issue #22520: Fix overflow checking when generating the repr of a unicode
+ object.
+
+- Issue #22519: Fix overflow checking in PyBytes_Repr.
+
+- Issue #22518: Fix integer overflow issues in latin-1 encoding.
+
+- Issue #23165: Perform overflow checks before allocating memory in the
+ _Py_char2wchar function.
+
+Library
+-------
+
+- Issue #23399: pyvenv creates relative symlinks where possible.
+
+- Issue #23099: Closing io.BytesIO with exported buffer is rejected now to
+ prevent corrupting exported buffer.
+
+- Issue #23363: Fix possible overflow in itertools.permutations.
+
+- Issue #23364: Fix possible overflow in itertools.product.
+
+- Issue #23366: Fixed possible integer overflow in itertools.combinations.
+
+- Issue #23369: Fixed possible integer overflow in
+ _json.encode_basestring_ascii.
+
+- Issue #23353: Fix the exception handling of generators in
+ PyEval_EvalFrameEx(). At entry, save or swap the exception state even if
+ PyEval_EvalFrameEx() is called with throwflag=0. At exit, the exception state
+ is now always restored or swapped, not only if why is WHY_YIELD or
+ WHY_RETURN. Patch co-written with Antoine Pitrou.
+
+- Issue #18518: timeit now rejects statements which can't be compiled outside
+ a function or a loop (e.g. "return" or "break").
+
+- Issue #23094: Fixed readline with frames in Python implementation of pickle.
+
+- Issue #23268: Fixed bugs in the comparison of ipaddress classes.
+
+- Issue #21408: Removed incorrect implementations of __ne__() which didn't
+ returned NotImplemented if __eq__() returned NotImplemented. The default
+ __ne__() now works correctly.
+
+- Issue #19996: :class:`email.feedparser.FeedParser` now handles (malformed)
+ headers with no key rather than assuming the body has started.
+
+- Issue #23248: Update ssl error codes from latest OpenSSL git master.
+
+- Issue #23098: 64-bit dev_t is now supported in the os module.
+
+- Issue #23250: In the http.cookies module, capitalize "HttpOnly" and "Secure"
+ as they are written in the standard.
+
+- Issue #23063: In the disutils' check command, fix parsing of reST with code or
+ code-block directives.
+
+- Issue #23209, #23225: selectors.BaseSelector.close() now clears its internal
+ reference to the selector mapping to break a reference cycle. Initial patch
+ written by Martin Richard.
+
+- Issue #21356: Make ssl.RAND_egd() optional to support LibreSSL. The
+ availability of the function is checked during the compilation. Patch written
+ by Bernard Spil.
+
+- Issue #20896, #22935: The :func:`ssl.get_server_certificate` function now
+ uses the :data:`~ssl.PROTOCOL_SSLv23` protocol by default, not
+ :data:`~ssl.PROTOCOL_SSLv3`, for maximum compatibility and support platforms
+ where :data:`~ssl.PROTOCOL_SSLv3` support is disabled.
+
+- Issue #23111: In the ftplib, make ssl.PROTOCOL_SSLv23 the default protocol
+ version.
+
+- Issue #23132: Mitigate regression in speed and clarity in functools.total_ordering.
+
+- Issue #22585: On OpenBSD 5.6 and newer, os.urandom() now calls getentropy(),
+ instead of reading /dev/urandom, to get pseudo-random bytes.
+
+- Issue #23112: Fix SimpleHTTPServer to correctly carry the query string and
+ fragment when it redirects to add a trailing slash.
+
+- Issue #23093: In the io, module allow more operations to work on detached
+ streams.
+
+- Issue #19104: pprint now produces evaluable output for wrapped strings.
+
+- Issue #23071: Added missing names to codecs.__all__. Patch by Martin Panter.
+
+- Issue #15513: Added a __sizeof__ implementation for pickle classes.
+
+- Issue #19858: pickletools.optimize() now aware of the MEMOIZE opcode, can
+ produce more compact result and no longer produces invalid output if input
+ data contains MEMOIZE opcodes together with PUT or BINPUT opcodes.
+
+- Issue #22095: Fixed HTTPConnection.set_tunnel with default port. The port
+ value in the host header was set to "None". Patch by Demian Brecht.
+
+- Issue #23016: A warning no longer produces an AttributeError when the program
+ is run with pythonw.exe.
+
+- Issue #21775: shutil.copytree(): fix crash when copying to VFAT. An exception
+ handler assumed that that OSError objects always have a 'winerror' attribute.
+ That is not the case, so the exception handler itself raised AttributeError
+ when run on Linux (and, presumably, any other non-Windows OS).
+ Patch by Greg Ward.
+
+- Issue #1218234: Fix inspect.getsource() to load updated source of
+ reloaded module. Initial patch by Berker Peksag.
+
+- Issue #22959: In the constructor of http.client.HTTPSConnection, prefer the
+ context's check_hostname attribute over the *check_hostname* parameter.
+
+- Issue #16043: Add a default limit for the amount of data xmlrpclib.gzip_decode
+ will return. This resolves CVE-2013-1753.
+
+- Issue #22966: Fix __pycache__ pyc file name clobber when pyc_compile is
+ asked to compile a source file containing multiple dots in the source file
+ name.
+
+- Issue #21971: Update turtledemo doc and add module to the index.
+
+- Issue #21032. Fixed socket leak if HTTPConnection.getresponse() fails.
+ Original patch by Martin Panter.
+
+- Issue #22960: Add a context argument to xmlrpclib.ServerProxy constructor.
+
+- Issue #22915: SAX parser now supports files opened with file descriptor or
+ bytes path.
+
+- Issue #22609: Constructors and update methods of mapping classes in the
+ collections module now accept the self keyword argument.
+
+- Issue #22788: Add *context* parameter to logging.handlers.HTTPHandler.
+
+- Issue #22921: Allow SSLContext to take the *hostname* parameter even if
+ OpenSSL doesn't support SNI.
+
+- Issue #22894: TestCase.subTest() would cause the test suite to be stopped
+ when in failfast mode, even in the absence of failures.
+
+- Issue #22638: SSLv3 is now disabled throughout the standard library.
+ It can still be enabled by instantiating a SSLContext manually.
+
+- Issue #22370: Windows detection in pathlib is now more robust.
+
+- Issue #22841: Reject coroutines in asyncio add_signal_handler().
+ Patch by Ludovic.Gasc.
+
+- Issue #22849: Fix possible double free in the io.TextIOWrapper constructor.
+
+- Issue #12728: Different Unicode characters having the same uppercase but
+ different lowercase are now matched in case-insensitive regular expressions.
+
+- Issue #22821: Fixed fcntl() with integer argument on 64-bit big-endian
+ platforms.
+
+- Issue #22406: Fixed the uu_codec codec incorrectly ported to 3.x.
+ Based on patch by Martin Panter.
+
+- Issue #17293: uuid.getnode() now determines MAC address on AIX using netstat.
+ Based on patch by Aivars Kalvāns.
+
+- Issue #22769: Fixed ttk.Treeview.tag_has() when called without arguments.
+
+- Issue #22417: Verify certificates by default in httplib (PEP 476).
+
+- Issue #22775: Fixed unpickling of http.cookies.SimpleCookie with protocol 2
+ and above. Patch by Tim Graham.
+
+- Issue #22366: urllib.request.urlopen will accept a context object
+ (SSLContext) as an argument which will then used be for HTTPS connection.
+ Patch by Alex Gaynor.
+
+- Issue #22776: Brought excluded code into the scope of a try block in
+ SysLogHandler.emit().
+
+- Issue #22665: Add missing get_terminal_size and SameFileError to
+ shutil.__all__.
+
+- Issue #17381: Fixed handling of case-insensitive ranges in regular
+ expressions.
+
+- Issue #22410: Module level functions in the re module now cache compiled
+ locale-dependent regular expressions taking into account the locale.
+
+- Issue #22759: Query methods on pathlib.Path() (exists(), is_dir(), etc.)
+ now return False when the underlying stat call raises NotADirectoryError.
+
+- Issue #8876: distutils now falls back to copying files when hard linking
+ doesn't work. This allows use with special filesystems such as VirtualBox
+ shared folders.
+
+- Issue #18853: Fixed ResourceWarning in shlex.__nain__.
+
+- Issue #9351: Defaults set with set_defaults on an argparse subparser
+ are no longer ignored when also set on the parent parser.
+
+- Issue #21991: Make email.headerregistry's header 'params' attributes
+ be read-only (MappingProxyType). Previously the dictionary was modifiable
+ but a new one was created on each access of the attribute.
+
+- Issue #22641: In asyncio, the default SSL context for client connections
+ is now created using ssl.create_default_context(), for stronger security.
+
+- Issue #22435: Fix a file descriptor leak when SocketServer bind fails.
+
+- Issue #13096: Fixed segfault in CTypes POINTER handling of large
+ values.
+
+- Issue #11694: Raise ConversionError in xdrlib as documented. Patch
+ by Filip Gruszczyński and Claudiu Popa.
+
+- Issue #22462: Fix pyexpat's creation of a dummy frame to make it
+ appear in exception tracebacks.
+
+- Issue #21173: Fix len() on a WeakKeyDictionary when .clear() was called
+ with an iterator alive.
+
+- Issue #11866: Eliminated race condition in the computation of names
+ for new threads.
+
+- Issue #21905: Avoid RuntimeError in pickle.whichmodule() when sys.modules
+ is mutated while iterating. Patch by Olivier Grisel.
+
+- Issue #22219: The zipfile module CLI now adds entries for directories
+ (including empty directories) in ZIP file.
+
+- Issue #22449: In the ssl.SSLContext.load_default_certs, consult the
+ environmental variables SSL_CERT_DIR and SSL_CERT_FILE on Windows.
+
+- Issue #20076: Added non derived UTF-8 aliases to locale aliases table.
+
+- Issue #20079: Added locales supported in glibc 2.18 to locale alias table.
+
+- Issue #22396: On 32-bit AIX platform, don't expose os.posix_fadvise() nor
+ os.posix_fallocate() because their prototypes in system headers are wrong.
+
+- Issue #22517: When a io.BufferedRWPair object is deallocated, clear its
+ weakrefs.
+
+- Issue #22448: Improve canceled timer handles cleanup to prevent
+ unbound memory usage. Patch by Joshua Moore-Oliva.
+
+- Issue #23009: Make sure selectors.EpollSelecrtor.select() works when no
+ FD is registered.
+
+IDLE
+----
+
+- Issue #20577: Configuration of the max line length for the FormatParagraph
+ extension has been moved from the General tab of the Idle preferences dialog
+ to the FormatParagraph tab of the Config Extensions dialog.
+ Patch by Tal Einat.
+
+- Issue #16893: Update Idle doc chapter to match current Idle and add new
+ information.
+
+- Issue #3068: Add Idle extension configuration dialog to Options menu.
+ Changes are written to HOME/.idlerc/config-extensions.cfg.
+ Original patch by Tal Einat.
+
+- Issue #16233: A module browser (File : Class Browser, Alt+C) requires an
+ editor window with a filename. When Class Browser is requested otherwise,
+ from a shell, output window, or 'Untitled' editor, Idle no longer displays
+ an error box. It now pops up an Open Module box (Alt+M). If a valid name
+ is entered and a module is opened, a corresponding browser is also opened.
+
+- Issue #4832: Save As to type Python files automatically adds .py to the
+ name you enter (even if your system does not display it). Some systems
+ automatically add .txt when type is Text files.
+
+- Issue #21986: Code objects are not normally pickled by the pickle module.
+ To match this, they are no longer pickled when running under Idle.
+
+- Issue #23180: Rename IDLE "Windows" menu item to "Window".
+ Patch by Al Sweigart.
+
+Tests
+-----
+
+- Issue #23392: Added tests for marshal C API that works with FILE*.
+
+- Issue #18982: Add tests for CLI of the calendar module.
+
+- Issue #19548: Added some additional checks to test_codecs to ensure that
+ statements in the updated documentation remain accurate. Patch by Martin
+ Panter.
+
+- Issue #22838: All test_re tests now work with unittest test discovery.
+
+- Issue #22173: Update lib2to3 tests to use unittest test discovery.
+
+- Issue #16000: Convert test_curses to use unittest.
+
+- Issue #21456: Skip two tests in test_urllib2net.py if _ssl module not
+ present. Patch by Remi Pointel.
+
+- Issue #22770: Prevent some Tk segfaults on OS X when running gui tests.
+
+- Issue #23211: Workaround test_logging failure on some OS X 10.6 systems.
+
+- Issue #23345: Prevent test_ssl failures with large OpenSSL patch level
+ values (like 0.9.8zc).
+
+- Issue #22289: Prevent test_urllib2net failures due to ftp connection timeout.
+
+Build
+-----
+
+- Issue #15506: Use standard PKG_PROG_PKG_CONFIG autoconf macro in the configure
+ script.
+
+- Issue #22935: Allow the ssl module to be compiled if openssl doesn't support
+ SSL 3.
+
+- Issue #16537: Check whether self.extensions is empty in setup.py. Patch by
+ Jonathan Hosmer.
+
+- Issue #18096: Fix library order returned by python-config.
+
+- Issue #17219: Add library build dir for Python extension cross-builds.
+
+- Issue #17128: Use private version of OpenSSL for 3.4.3 OS X 10.5+ installer.
+
+C API
+-----
+
+- Issue #22079: PyType_Ready() now checks that statically allocated type has
+ no dynamically allocated bases.
+
+Documentation
+-------------
+
+- Issue #19548: Update the codecs module documentation to better cover the
+ distinction between text encodings and other codecs, together with other
+ clarifications. Patch by Martin Panter.
+
+- Issue #22914: Update the Python 2/3 porting HOWTO to describe a more automated
+ approach.
+
+- Issue #21514: The documentation of the json module now refers to new JSON RFC
+ 7159 instead of obsoleted RFC 4627.
+
+Tools/Demos
+-----------
+
+- Issue #22314: pydoc now works when the LINES environment variable is set.
+
+Windows
+-------
+
+- Issue #17896: The Windows build scripts now expect external library sources
+ to be in ``PCbuild\..\externals`` rather than ``PCbuild\..\..``.
+
+- Issue #17717: The Windows build scripts now use a copy of NASM pulled from
+ svn.python.org to build OpenSSL.
+
+- Issue #22644: The bundled version of OpenSSL has been updated to 1.0.1j.
+
+
+What's New in Python 3.4.2?
+===========================
+
+Release date: 2014-10-06
+
+Library
+-------
+
+- Issue #10510: distutils register and upload methods now use HTML standards
+ compliant CRLF line endings.
+
+- Issue #9850: Fixed macpath.join() for empty first component. Patch by
+ Oleg Oshmyan.
+
+- Issue #22427: TemporaryDirectory no longer attempts to clean up twice when
+ used in the with statement in generator.
+
+- Issue #20912: Now directories added to ZIP file have correct Unix and MS-DOS
+ directory attributes.
+
+- Issue #21866: ZipFile.close() no longer writes ZIP64 central directory
+ records if allowZip64 is false.
+
+- Issue #22415: Fixed debugging output of the GROUPREF_EXISTS opcode in the re
+ module. Removed trailing spaces in debugging output.
+
+- Issue #22423: Unhandled exception in thread no longer causes unhandled
+ AttributeError when sys.stderr is None.
+
+- Issue #21332: Ensure that ``bufsize=1`` in subprocess.Popen() selects
+ line buffering, rather than block buffering. Patch by Akira Li.
+
+
+What's New in Python 3.4.2rc1?
+==============================
+
+Release date: 2014-09-22
+
+Core and Builtins
+-----------------
+
+- Issue #22258: Fix the the internal function set_inheritable() on Illumos.
+ This platform exposes the function ``ioctl(FIOCLEX)``, but calling it fails
+ with errno is ENOTTY: "Inappropriate ioctl for device". set_inheritable()
+ now falls back to the slower ``fcntl()`` (``F_GETFD`` and then ``F_SETFD``).
+
+- Issue #21669: With the aid of heuristics in SyntaxError.__init__, the
+ parser now attempts to generate more meaningful (or at least more search
+ engine friendly) error messages when "exec" and "print" are used as
+ statements.
+
+- Issue #21642: In the conditional if-else expression, allow an integer written
+ with no space between itself and the ``else`` keyword (e.g. ``True if 42else
+ False``) to be valid syntax.
+
+- Issue #21523: Fix over-pessimistic computation of the stack effect of
+ some opcodes in the compiler. This also fixes a quadratic compilation
+ time issue noticeable when compiling code with a large number of "and"
+ and "or" operators.
+
+Library
+-------
+
+- Issue #21091: Fix API bug: email.message.EmailMessage.is_attachment is now
+ a method. Since EmailMessage is provisional, we can change the API in a
+ maintenance release, but we use a trick to remain backward compatible with
+ 3.4.0/1.
+
+- Issue #21079: Fix email.message.EmailMessage.is_attachment to return the
+ correct result when the header has parameters as well as a value.
+
+- Issue #22247: Add NNTPError to nntplib.__all__.
+
+- Issue #4180: The warnings registries are now reset when the filters
+ are modified.
+
+- Issue #22419: Limit the length of incoming HTTP request in wsgiref server to
+ 65536 bytes and send a 414 error code for higher lengths. Patch contributed
+ by Devin Cook.
+
+- Lax cookie parsing in http.cookies could be a security issue when combined
+ with non-standard cookie handling in some Web browsers. Reported by
+ Sergey Bobrov.
+
+- Issue #22384: An exception in Tkinter callback no longer crashes the program
+ when it is run with pythonw.exe.
+
+- Issue #22168: Prevent turtle AttributeError with non-default Canvas on OS X.
+
+- Issue #21147: sqlite3 now raises an exception if the request contains a null
+ character instead of truncate it. Based on patch by Victor Stinner.
+
+- Issue #21951: Fixed a crash in Tkinter on AIX when called Tcl command with
+ empty string or tuple argument.
+
+- Issue #21951: Tkinter now most likely raises MemoryError instead of crash
+ if the memory allocation fails.
+
+- Issue #22338: Fix a crash in the json module on memory allocation failure.
+
+- Issue #22226: First letter no longer is stripped from the "status" key in
+ the result of Treeview.heading().
+
+- Issue #19524: Fixed resource leak in the HTTP connection when an invalid
+ response is received. Patch by Martin Panter.
+
+- Issue #22051: turtledemo no longer reloads examples to re-run them.
+ Initialization of variables and gui setup should be done in main(),
+ which is called each time a demo is run, but not on import.
+
+- Issue #21933: Turtledemo users can change the code font size with a menu
+ selection or control(command) '-' or '+' or control-mousewheel.
+ Original patch by Lita Cho.
+
+- Issue #21597: The separator between the turtledemo text pane and the drawing
+ canvas can now be grabbed and dragged with a mouse. The code text pane can
+ be widened to easily view or copy the full width of the text. The canvas
+ can be widened on small screens. Original patches by Jan Kanis and Lita Cho.
+
+- Issue #18132: Turtledemo buttons no longer disappear when the window is
+ shrunk. Original patches by Jan Kanis and Lita Cho.
+
+- Issue #22216: smtplib now resets its state more completely after a quit. The
+ most obvious consequence of the previous behavior was a STARTTLS failure
+ during a connect/starttls/quit/connect/starttls sequence.
+
+- Issue #22185: Fix an occasional RuntimeError in threading.Condition.wait()
+ caused by mutation of the waiters queue without holding the lock. Patch
+ by Doug Zongker.
+
+- Issue #22182: Use e.args to unpack exceptions correctly in
+ distutils.file_util.move_file. Patch by Claudiu Popa.
+
+- The webbrowser module now uses subprocess's start_new_session=True rather
+ than a potentially risky preexec_fn=os.setsid call.
+
+- Issue #22236: Fixed Tkinter images copying operations in NoDefaultRoot mode.
+
+- Issue #22191: Fix warnings.__all__.
+
+- Issue #15696: Add a __sizeof__ implementation for mmap objects on Windows.
+
+- Issue #22068: Avoided reference loops with Variables and Fonts in Tkinter.
+
+- Issue #22165: SimpleHTTPRequestHandler now supports undecodable file names.
+
+- Issue #8797: Raise HTTPError on failed Basic Authentication immediately.
+ Initial patch by Sam Bull.
+
+- Issue #20729: Restored the use of lazy iterkeys()/itervalues()/iteritems()
+ in the mailbox module.
+
+- Issue #21448: Changed FeedParser feed() to avoid O(N**2) behavior when
+ parsing long line. Original patch by Raymond Hettinger.
+
+- Issue #22184: The functools LRU Cache decorator factory now gives an earlier
+ and clearer error message when the user forgets the required parameters.
+
+- Issue #17923: glob() patterns ending with a slash no longer match non-dirs on
+ AIX. Based on patch by Delhallt.
+
+- Issue #21121: Don't force 3rd party C extensions to be built with
+ -Werror=declaration-after-statement.
+
+- Issue #21975: Fixed crash when using uninitialized sqlite3.Row (in particular
+ when unpickling pickled sqlite3.Row). sqlite3.Row is now initialized in the
+ __new__() method.
+
+- Issue #21580: Now Tkinter correctly handles bytes arguments passed to Tk.
+ In particular this allows to initialize images from binary data.
+
+- Issue #17172: Make turtledemo start as active on OS X even when run with
+ subprocess. Patch by Lita Cho.
+
+- Issue #21704: Fix build error for _multiprocessing when semaphores
+ are not available. Patch by Arfrever Frehtes Taifersar Arahesis.
+
+- Fix repr(_socket.socket) on Windows 64-bit: don't fail with OverflowError
+ on closed socket. repr(socket.socket) already works fine.
+
+- Issue #16133: The asynchat.async_chat.handle_read() method now ignores
+ BlockingIOError exceptions.
+
+- Issue #22044: Fixed premature DECREF in call_tzinfo_method.
+ Patch by Tom Flanagan.
+
+- Issue #19884: readline: Disable the meta modifier key if stdout is not
+ a terminal to not write the ANSI sequence "\033[1034h" into stdout. This
+ sequence is used on some terminal (ex: TERM=xterm-256color") to enable
+ support of 8 bit characters.
+
+- Issue #21888: plistlib's load() and loads() now work if the fmt parameter is
+ specified.
+
+- Issue #21044: tarfile.open() now handles fileobj with an integer 'name'
+ attribute. Based on patch by Antoine Pietri.
+
+- Issue #21867: Prevent turtle crash due to invalid undo buffer size.
+
+- Issue #19076: Don't pass the redundant 'file' argument to self.error().
+
+- Issue #21942: Fixed source file viewing in pydoc's server mode on Windows.
+
+- Issue #11259: asynchat.async_chat().set_terminator() now raises a ValueError
+ if the number of received bytes is negative.
+
+- Issue #12523: asynchat.async_chat.push() now raises a TypeError if it doesn't
+ get a bytes string
+
+- Issue #21707: Add missing kwonlyargcount argument to
+ ModuleFinder.replace_paths_in_code().
+
+- Issue #20639: calling Path.with_suffix('') allows removing the suffix
+ again. Patch by July Tikhonov.
+
+- Issue #21714: Disallow the construction of invalid paths using
+ Path.with_name(). Original patch by Antony Lee.
+
+- Issue #21897: Fix a crash with the f_locals attribute with closure
+ variables when frame.clear() has been called.
+
+- Issue #21151: Fixed a segfault in the winreg module when ``None`` is passed
+ as a ``REG_BINARY`` value to SetValueEx. Patch by John Ehresman.
+
+- Issue #21090: io.FileIO.readall() does not ignore I/O errors anymore. Before,
+ it ignored I/O errors if at least the first C call read() succeed.
+
+- Issue #21781: ssl.RAND_add() now supports strings longer than 2 GB.
+
+- Issue #11453: asyncore: emit a ResourceWarning when an unclosed file_wrapper
+ object is destroyed. The destructor now closes the file if needed. The
+ close() method can now be called twice: the second call does nothing.
+
+- Issue #21858: Better handling of Python exceptions in the sqlite3 module.
+
+- Issue #21476: Make sure the email.parser.BytesParser TextIOWrapper is
+ discarded after parsing, so the input file isn't unexpectedly closed.
+
+- Issue #21729: Used the "with" statement in the dbm.dumb module to ensure
+ files closing. Patch by Claudiu Popa.
+
+- Issue #21491: socketserver: Fix a race condition in child processes reaping.
+
+- Issue #21832: Require named tuple inputs to be exact strings.
+
+- Issue #19145: The times argument for itertools.repeat now handles
+ negative values the same way for keyword arguments as it does for
+ positional arguments.
+
+- Issue #21812: turtle.shapetransform did not tranform the turtle on the
+ first call. (Issue identified and fixed by Lita Cho.)
+
+- Issue #21635: The difflib SequenceMatcher.get_matching_blocks() method
+ cache didn't match the actual result. The former was a list of tuples
+ and the latter was a list of named tuples.
+
+- Issue #21722: The distutils "upload" command now exits with a non-zero
+ return code when uploading fails. Patch by Martin Dengler.
+
+- Issue #21723: asyncio.Queue: support any type of number (ex: float) for the
+ maximum size. Patch written by Vajrasky Kok.
+
+- Issue #21326: Add a new is_closed() method to asyncio.BaseEventLoop.
+ run_forever() and run_until_complete() methods of asyncio.BaseEventLoop now
+ raise an exception if the event loop was closed.
+
+- Issue #21774: Fixed NameError for an incorrect variable reference in the
+ XML Minidom code for creating processing instructions.
+ (Found and fixed by Claudiu Popa.)
+
+- Issue #21766: Prevent a security hole in CGIHTTPServer by URL unquoting paths
+ before checking for a CGI script at that path.
+
+- Issue #21310: Fixed possible resource leak in failed open().
+
+- Issue #21677: Fixed chaining nonnormalized exceptions in io close() methods.
+
+- Issue #11709: Fix the pydoc.help function to not fail when sys.stdin is not a
+ valid file.
+
+- Issue #13223: Fix pydoc.writedoc so that the HTML documentation for methods
+ that use 'self' in the example code is generated correctly.
+
+- Issue #21463: In urllib.request, fix pruning of the FTP cache.
+
+- Issue #21618: The subprocess module could fail to close open fds that were
+ inherited by the calling process and already higher than POSIX resource
+ limits would otherwise allow. On systems with a functioning /proc/self/fd
+ or /dev/fd interface the max is now ignored and all fds are closed.
+
+- Issue #21552: Fixed possible integer overflow of too long string lengths in
+ the tkinter module on 64-bit platforms.
+
+- Issue #14315: The zipfile module now ignores extra fields in the central
+ directory that are too short to be parsed instead of letting a struct.unpack
+ error bubble up as this "bad data" appears in many real world zip files in
+ the wild and is ignored by other zip tools.
+
+- Issue #21402: tkinter.ttk now works when default root window is not set.
+
+- Issue #10203: sqlite3.Row now truly supports sequence protocol. In particular
+ it supports reverse() and negative indices. Original patch by Claudiu Popa.
+
+- Issue #18807: If copying (no symlinks) specified for a venv, then the python
+ interpreter aliases (python, python3) are now created by copying rather than
+ symlinking.
+
+- Issue #14710: pkgutil.get_loader() no longer raises an exception when None is
+ found in sys.modules.
+
+- Issue #14710: pkgutil.find_loader() no longer raises an exception when a
+ module doesn't exist.
+
+- Issue #21481: Argparse equality and inequality tests now return
+ NotImplemented when comparing to an unknown type.
+
+- Issue #8743: Fix interoperability between set objects and the
+ collections.Set() abstract base class.
+
+- Issue #13355: random.triangular() no longer fails with a ZeroDivisionError
+ when low equals high.
+
+- Issue #21538: The plistlib module now supports loading of binary plist files
+ when reference or offset size is not a power of two.
+
+- Issue #21801: Validate that __signature__ is None or an instance of Signature.
+
+- Issue #21923: Prevent AttributeError in distutils.sysconfig.customize_compiler
+ due to possible uninitialized _config_vars.
+
+- Issue #21323: Fix http.server to again handle scripts in CGI subdirectories,
+ broken by the fix for security issue #19435. Patch by Zach Byrne.
+
+Extension Modules
+-----------------
+
+- Issue #22176: Update the ctypes module's libffi to v3.1. This release
+ adds support for the Linux AArch64 and POWERPC ELF ABIv2 little endian
+ architectures.
+
+Build
+-----
+
+- Issue #15661: python.org OS X installers are now distributed as signed
+ installer packages compatible with the Gatekeeper security feature.
+
+- Issue #21958: Define HAVE_ROUND when building with Visual Studio 2013 and
+ above. Patch by Zachary Turner.
+
+- Issue #15759: "make suspicious", "make linkcheck" and "make doctest" in Doc/
+ now display special message when and only when there are failures.
+
+- Issue #17095: Fix Modules/Setup *shared* support.
+
+- Issue #21811: Anticipated fixes to support OS X versions > 10.9.
+
+- Issue #21166: Prevent possible segfaults and other random failures of
+ python --generate-posix-vars in pybuilddir.txt build target.
+
+IDLE
+----
+
+- Issue #17390: Adjust Editor window title; remove 'Python',
+ move version to end.
+
+- Issue #14105: Idle debugger breakpoints no longer disappear
+ when inseting or deleting lines.
+
+- Issue #17172: Turtledemo can now be run from Idle.
+ Currently, the entry is on the Help menu, but it may move to Run.
+ Patch by Ramchandra Apt and Lita Cho.
+
+- Issue #21765: Add support for non-ascii identifiers to HyperParser.
+
+- Issue #21940: Add unittest for WidgetRedirector. Initial patch by Saimadhav
+ Heblikar.
+
+- Issue #18592: Add unittest for SearchDialogBase. Patch by Phil Webster.
+
+- Issue #21694: Add unittest for ParenMatch. Patch by Saimadhav Heblikar.
+
+- Issue #21686: add unittest for HyperParser. Original patch by Saimadhav
+ Heblikar.
+
+- Issue #12387: Add missing upper(lower)case versions of default Windows key
+ bindings for Idle so Caps Lock does not disable them. Patch by Roger Serwy.
+
+- Issue #21695: Closing a Find-in-files output window while the search is
+ still in progress no longer closes Idle.
+
+- Issue #18910: Add unittest for textView. Patch by Phil Webster.
+
+- Issue #18292: Add unittest for AutoExpand. Patch by Saihadhav Heblikar.
+
+- Issue #18409: Add unittest for AutoComplete. Patch by Phil Webster.
+
+Tests
+-----
+
+- Issue #22166: With the assistance of a new internal _codecs._forget_codec
+ helping function, test_codecs now clears the encoding caches to avoid the
+ appearance of a reference leak
+
+- Issue #22236: Tkinter tests now don't reuse default root window. New root
+ window is created for every test class.
+
+- Issue #20746: Fix test_pdb to run in refleak mode (-R). Patch by Xavier
+ de Gaye.
+
+- Issue #22060: test_ctypes has been somewhat cleaned up and simplified; it
+ now uses unittest test discovery to find its tests.
+
+- Issue #22104: regrtest.py no longer holds a reference to the suite of tests
+ loaded from test modules that don't define test_main().
+
+- Issue #22002: Added ``load_package_tests`` function to test.support and used
+ it to implement/augment test discovery in test_asyncio, test_email,
+ test_importlib, test_json, and test_tools.
+
+- Issue #21976: Fix test_ssl to accept LibreSSL version strings. Thanks
+ to William Orr.
+
+- Issue #21918: Converted test_tools from a module to a package containing
+ separate test files for each tested script.
+
+- Issue #20155: Changed HTTP method names in failing tests in test_httpservers
+ so that packet filtering software (specifically Windows Base Filtering Engine)
+ does not interfere with the transaction semantics expected by the tests.
+
+- Issue #19493: Refactored the ctypes test package to skip tests explicitly
+ rather than silently.
+
+- Issue #18492: All resources are now allowed when tests are not run by
+ regrtest.py.
+
+- Issue #21634: Fix pystone micro-benchmark: use floor division instead of true
+ division to benchmark integers instead of floating point numbers. Set pystone
+ version to 1.2. Patch written by Lennart Regebro.
+
+- Issue #21605: Added tests for Tkinter images.
+
+- Issue #21493: Added test for ntpath.expanduser(). Original patch by
+ Claudiu Popa.
+
+- Issue #19925: Added tests for the spwd module. Original patch by Vajrasky Kok.
+
+- Issue #21522: Added Tkinter tests for Listbox.itemconfigure(),
+ PanedWindow.paneconfigure(), and Menu.entryconfigure().
+
+Documentation
+-------------
+
+- Issue #21777: The binary sequence methods on bytes and bytearray are now
+ documented explicitly, rather than assuming users will be able to derive
+ the expected behaviour from the behaviour of the corresponding str methods.
+
+Windows
+-------
+
+- Issue #21671, #22160, CVE-2014-0224: The bundled version of OpenSSL has been
+ updated to 1.0.1i.
+
+- Issue #10747: Use versioned labels in the Windows start menu.
+ Patch by Olive Kilburn.
+
+Tools/Demos
+-----------
+
+- Issue #22201: Command-line interface of the zipfile module now correctly
+ extracts ZIP files with directory entries. Patch by Ryan Wilson.
+
+- Issue #21906: Make Tools/scripts/md5sum.py work in Python 3.
+ Patch by Zachary Ware.
+
+- Issue #21629: Fix Argument Clinic's "--converters" feature.
+
+
+What's New in Python 3.4.1?
+===========================
+
+Release date: 2014-05-18
+
+Core and Builtins
+-----------------
+
+- Issue #21418: Fix a crash in the builtin function super() when called without
+ argument and without current frame (ex: embedded Python).
+
+- Issue #21425: Fix flushing of standard streams in the interactive
+ interpreter.
+
+- Issue #21435: In rare cases, when running finalizers on objects in cyclic
+ trash a bad pointer dereference could occur due to a subtle flaw in
+ internal iteration logic.
+
+Library
+-------
+
+- Issue #10744: Fix PEP 3118 format strings on ctypes objects with a nontrivial
+ shape.
+
+- Issue #20998: Fixed re.fullmatch() of repeated single character pattern
+ with ignore case. Original patch by Matthew Barnett.
+
+- Issue #21075: fileinput.FileInput now reads bytes from standard stream if
+ binary mode is specified. Patch by Sam Kimbrel.
+
+- Issue #21396: Fix TextIOWrapper(..., write_through=True) to not force a
+ flush() on the underlying binary stream. Patch by akira.
+
+- Issue #21470: Do a better job seeding the random number generator by
+ using enough bytes to span the full state space of the Mersenne Twister.
+
+- Issue #21398: Fix an unicode error in the pydoc pager when the documentation
+ contains characters not encodable to the stdout encoding.
+
+Tests
+-----
+
+- Issue #17756: Fix test_code test when run from the installed location.
+
+- Issue #17752: Fix distutils tests when run from the installed location.
+
+IDLE
+----
+
+- Issue #18104: Add idlelib/idle_test/htest.py with a few sample tests to begin
+ consolidating and improving human-validated tests of Idle. Change other files
+ as needed to work with htest. Running the module as __main__ runs all tests.
+
+
+What's New in Python 3.4.1rc1?
+==============================
+
+Release date: 2014-05-05
+
+Core and Builtins
+-----------------
+
+- Issue #21274: Define PATH_MAX for GNU/Hurd in Python/pythonrun.c.
+
+- Issue #21209: Fix sending tuples to custom generator objects with the yield
+ from syntax.
+
+- Issue #21134: Fix segfault when str is called on an uninitialized
+ UnicodeEncodeError, UnicodeDecodeError, or UnicodeTranslateError object.
+
+- Issue #19537: Fix PyUnicode_DATA() alignment under m68k. Patch by
+ Andreas Schwab.
+
+- Issue #20929: Add a type cast to avoid shifting a negative number.
+
+- Issue #20731: Properly position in source code files even if they
+ are opened in text mode. Patch by Serhiy Storchaka.
+
+- Issue #20637: Key-sharing now also works for instance dictionaries of
+ subclasses. Patch by Peter Ingebretson.
+
+- Issue #12546: Allow ``\x00`` to be used as a fill character when using str, int,
+ float, and complex __format__ methods.
+
+- Issue #13598: Modify string.Formatter to support auto-numbering of
+ replacement fields. It now matches the behavior of str.format() in
+ this regard. Patches by Phil Elson and Ramchandra Apte.
+
+Library
+-------
+
+- Issue #21088: Bugfix for curses.window.addch() regression in 3.4.0.
+ In porting to Argument Clinic, the first two arguments were reversed.
+
+- Issue #21469: Reduced the risk of false positives in robotparser by
+ checking to make sure that robots.txt has been read or does not exist
+ prior to returning True in can_fetch().
+
+- Issue #21321: itertools.islice() now releases the reference to the source
+ iterator when the slice is exhausted. Patch by Anton Afanasyev.
+
+- Issue #9815: assertRaises now tries to clear references to local variables
+ in the exception's traceback.
+
+- Issue #13204: Calling sys.flags.__new__ would crash the interpreter,
+ now it raises a TypeError.
+
+- Issue #19385: Make operations on a closed dbm.dumb database always raise the
+ same exception.
+
+- Issue #21207: Detect when the os.urandom cached fd has been closed or
+ replaced, and open it anew.
+
+- Issue #21291: subprocess's Popen.wait() is now thread safe so that
+ multiple threads may be calling wait() or poll() on a Popen instance
+ at the same time without losing the Popen.returncode value.
+
+- Issue #21127: Path objects can now be instantiated from str subclass
+ instances (such as ``numpy.str_``).
+
+- Issue #15002: urllib.response object to use _TemporaryFileWrapper (and
+ _TemporaryFileCloser) facility. Provides a better way to handle file
+ descriptor close. Patch contributed by Christian Theune.
+
+- Issue #12220: mindom now raises a custom ValueError indicating it doesn't
+ support spaces in URIs instead of letting a 'split' ValueError bubble up.
+
+- Issue #21239: patch.stopall() didn't work deterministically when the same
+ name was patched more than once.
+
+- Issue #21222: Passing name keyword argument to mock.create_autospec now
+ works.
+
+- Issue #21197: Add lib64 -> lib symlink in venvs on 64-bit non-OS X POSIX.
+
+- Issue #17498: Some SMTP servers disconnect after certain errors, violating
+ strict RFC conformance. Instead of losing the error code when we issue the
+ subsequent RSET, smtplib now returns the error code and defers raising the
+ SMTPServerDisconnected error until the next command is issued.
+
+- Issue #17826: setting an iterable side_effect on a mock function created by
+ create_autospec now works. Patch by Kushal Das.
+
+- Issue #7776: Fix ``Host:`` header and reconnection when using
+ http.client.HTTPConnection.set_tunnel(). Patch by Nikolaus Rath.
+
+- Issue #20968: unittest.mock.MagicMock now supports division.
+ Patch by Johannes Baiter.
+
+- Issue #21529 (CVE-2014-4616): Fix arbitrary memory access in
+ JSONDecoder.raw_decode with a negative second parameter. Bug reported by Guido
+ Vranken.
+
+- Issue #21169: getpass now handles non-ascii characters that the
+ input stream encoding cannot encode by re-encoding using the
+ replace error handler.
+
+- Issue #21171: Fixed undocumented filter API of the rot13 codec.
+ Patch by Berker Peksag.
+
+- Issue #21172: isinstance check relaxed from dict to collections.Mapping.
+
+- Issue #21155: asyncio.EventLoop.create_unix_server() now raises a ValueError
+ if path and sock are specified at the same time.
+
+- Issue #21149: Improved thread-safety in logging cleanup during interpreter
+ shutdown. Thanks to Devin Jeanpierre for the patch.
+
+- Issue #20145: `assertRaisesRegex` and `assertWarnsRegex` now raise a
+ TypeError if the second argument is not a string or compiled regex.
+
+- Issue #21058: Fix a leak of file descriptor in
+ :func:`tempfile.NamedTemporaryFile`, close the file descriptor if
+ :func:`io.open` fails
+
+- Issue #21200: Return None from pkgutil.get_loader() when __spec__ is missing.
+
+- Issue #21013: Enhance ssl.create_default_context() when used for server side
+ sockets to provide better security by default.
+
+- Issue #20633: Replace relative import by absolute import.
+
+- Issue #20980: Stop wrapping exception when using ThreadPool.
+
+- Issue #21082: In os.makedirs, do not set the process-wide umask. Note this
+ changes behavior of makedirs when exist_ok=True.
+
+- Issue #20990: Fix issues found by pyflakes for multiprocessing.
+
+- Issue #21015: SSL contexts will now automatically select an elliptic
+ curve for ECDH key exchange on OpenSSL 1.0.2 and later, and otherwise
+ default to "prime256v1".
+
+- Issue #20995: Enhance default ciphers used by the ssl module to enable
+ better security an prioritize perfect forward secrecy.
+
+- Issue #20884: Don't assume that __file__ is defined on importlib.__init__.
+
+- Issue #21499: Ignore __builtins__ in several test_importlib.test_api tests.
+
+- Issue #20879: Delay the initialization of encoding and decoding tables for
+ base32, ascii85 and base85 codecs in the base64 module, and delay the
+ initialization of the unquote_to_bytes() table of the urllib.parse module, to
+ not waste memory if these modules are not used.
+
+- Issue #19157: Include the broadcast address in the usuable hosts for IPv6
+ in ipaddress.
+
+- Issue #11599: When an external command (e.g. compiler) fails, distutils now
+ prints out the whole command line (instead of just the command name) if the
+ environment variable DISTUTILS_DEBUG is set.
+
+- Issue #4931: distutils should not produce unhelpful "error: None" messages
+ anymore. distutils.util.grok_environment_error is kept but doc-deprecated.
+
+- Issue #20875: Prevent possible gzip "'read' is not defined" NameError.
+ Patch by Claudiu Popa.
+
+- Issue #11558: ``email.message.Message.attach`` now returns a more
+ useful error message if ``attach`` is called on a message for which
+ ``is_multipart`` is False.
+
+- Issue #20283: RE pattern methods now accept the string keyword parameters
+ as documented. The pattern and source keyword parameters are left as
+ deprecated aliases.
+
+- Issue #20778: Fix modulefinder to work with bytecode-only modules.
+
+- Issue #20791: copy.copy() now doesn't make a copy when the input is
+ a bytes object. Initial patch by Peter Otten.
+
+- Issue #19748: On AIX, time.mktime() now raises an OverflowError for year
+ outsize range [1902; 2037].
+
+- Issue #20816: Fix inspect.getcallargs() to raise correct TypeError for
+ missing keyword-only arguments. Patch by Jeremiah Lowin.
+
+- Issue #20817: Fix inspect.getcallargs() to fail correctly if more
+ than 3 arguments are missing. Patch by Jeremiah Lowin.
+
+- Issue #6676: Ensure a meaningful exception is raised when attempting
+ to parse more than one XML document per pyexpat xmlparser instance.
+ (Original patches by Hirokazu Yamamoto and Amaury Forgeot d'Arc, with
+ suggested wording by David Gutteridge)
+
+- Issue #21117: Fix inspect.signature to better support functools.partial.
+ Due to the specifics of functools.partial implementation,
+ positional-or-keyword arguments passed as keyword arguments become
+ keyword-only.
+
+- Issue #21209: Fix asyncio.tasks.CoroWrapper to workaround a bug
+ in yield-from implementation in CPythons prior to 3.4.1.
+
+- asyncio: Add gi_{frame,running,code} properties to CoroWrapper
+ (upstream issue #163).
+
+- Issue #21311: Avoid exception in _osx_support with non-standard compiler
+ configurations. Patch by John Szakmeister.
+
+- Issue #11571: Ensure that the turtle window becomes the topmost window
+ when launched on OS X.
+
+Extension Modules
+-----------------
+
+- Issue #21276: posixmodule: Don't define USE_XATTRS on KFreeBSD and the Hurd.
+
+- Issue #21226: Set up modules properly in PyImport_ExecCodeModuleObject
+ (and friends).
+
+IDLE
+----
+
+- Issue #21139: Change default paragraph width to 72, the PEP 8 recommendation.
+
+- Issue #21284: Paragraph reformat test passes after user changes reformat width.
+
+- Issue #17654: Ensure IDLE menus are customized properly on OS X for
+ non-framework builds and for all variants of Tk.
+
+Build
+-----
+
+- The Windows build now includes OpenSSL 1.0.1g
+
+- Issue #21285: Refactor and fix curses configure check to always search
+ in a ncursesw directory.
+
+- Issue #15234: For BerkelyDB and Sqlite, only add the found library and
+ include directories if they aren't already being searched. This avoids
+ an explicit runtime library dependency.
+
+- Issue #20644: OS X installer build support for documentation build changes
+ in 3.4.1: assume externally supplied sphinx-build is available in /usr/bin.
+
+C API
+-----
+
+- Issue #20942: PyImport_ImportFrozenModuleObject() no longer sets __file__ to
+ match what importlib does; this affects _frozen_importlib as well as any
+ module loaded using imp.init_frozen().
+
+Documentation
+-------------
+
+- Issue #17386: Expanded functionality of the ``Doc/make.bat`` script to make
+ it much more comparable to ``Doc/Makefile``.
+
+- Issue #21043: Remove the recommendation for specific CA organizations and to
+ mention the ability to load the OS certificates.
+
+- Issue #20765: Add missing documentation for PurePath.with_name() and
+ PurePath.with_suffix().
+
+- Issue #19407: New package installation and distribution guides based on
+ the Python Packaging Authority tools. Existing guides have been retained
+ as legacy links from the distutils docs, as they still contain some
+ required reference material for tool developers that isn't recorded
+ anywhere else.
+
+- Issue #19697: Document cases where __main__.__spec__ is None.
+
+Tests
+-----
+
+- Issue #18604: Consolidated checks for GUI availability. All platforms now
+ at least check whether Tk can be instantiated when the GUI resource is
+ requested.
+
+- Issue #21275: Fix a socket test on KFreeBSD.
+
+- Issue #21223: Pass test_site/test_startup_imports when some of the extensions
+ are built as builtins.
+
+- Issue #20635: Added tests for Tk geometry managers.
+
+- Add test case for freeze.
+
+- Issue #20743: Fix a reference leak in test_tcl.
+
+- Issue #21097: Move test_namespace_pkgs into test_importlib.
+
+- Issue #20939: Avoid various network test failures due to new
+ redirect of http://www.python.org/ to https://www.python.org:
+ use http://www.example.com instead.
+
+- Issue #20668: asyncio tests no longer rely on tests.txt file.
+ (Patch by Vajrasky Kok)
+
+- Issue #21093: Prevent failures of ctypes test_macholib on OS X if a
+ copy of libz exists in $HOME/lib or /usr/local/lib.
+
+Tools/Demos
+-----------
+
+- Add support for ``yield from`` to 2to3.
+
+- Add support for the PEP 465 matrix multiplication operator to 2to3.
+
+- Issue #16047: Fix module exception list and __file__ handling in freeze.
+ Patch by Meador Inge.
+
+- Issue #11824: Consider ABI tags in freeze. Patch by Meador Inge.
+
+- Issue #20535: PYTHONWARNING no longer affects the run_tests.py script.
+ Patch by Arfrever Frehtes Taifersar Arahesis.
+
What's New in Python 3.4.0?
===========================
- Issue #20588: Make Python-ast.c C89 compliant.
-- Issue #20437: Fixed 22 potential bugs when deleting object references.
+- Issue #20437: Fixed 22 potential bugs when deleting objects references.
- Issue #20500: Displaying an exception at interpreter shutdown no longer
risks triggering an assertion failure in PyObject_Str.
when the creation of the replacement exception won't lose any information.
- Issue #19466: Clear the frames of daemon threads earlier during the
- Python shutdown to call object destructors. So "unclosed file" resource
- warnings are now correctly emitted for daemon threads.
+ Python shutdown to call objects destructors. So "unclosed file" resource
+ warnings are now corretly emitted for daemon threads.
- Issue #19514: Deduplicate some _Py_IDENTIFIER declarations.
Patch by Andrei Dorian Duma.
- Issue #19369: Optimized the usage of __length_hint__().
-- Issue #28026: Raise ImportError when exec_module() exists but
- create_module() is missing.
-
- Issue #18603: Ensure that PyOS_mystricmp and PyOS_mystrnicmp are in the
Python executable and not removed by the linker's optimizer.
- Issue #19448: Add private API to SSL module to lookup ASN.1 objects by OID,
NID, short name and long name.
-- Issue #19282: dbm.open now supports the context management protocol.
- (Initial patch by Claudiu Popa)
+- Issue #19282: dbm.open now supports the context management protocol. (Inital
+ patch by Claudiu Popa)
- Issue #8311: Added support for writing any bytes-like objects in the aifc,
sunau, and wave modules.
- Issue #19227: Remove pthread_atfork() handler. The handler was added to
solve #18747 but has caused issues.
-- Issue #19420: Fix reference leak in module initialization code of
+- Issue #19420: Fix reference leak in module initalization code of
_hashopenssl.c
- Issue #19329: Optimized compiling charsets in regular expressions.
- Issue #16809: Tkinter's splitlist() and split() methods now accept Tcl_Obj
argument.
-- Issue #17211: Yield a namedtuple in pkgutil.
- Patch by Ramchandra Apte.
-
- Issue #18324: set_payload now correctly handles binary input. This also
supersedes the previous fixes for #14360, #1717, and #16564.
- Issue #17119: Fixed integer overflows when processing large strings and tuples
in the tkinter module.
-- Issue #15352: Rebuild frozen modules when marshal.c is changed.
-
- Issue #18747: Re-seed OpenSSL's pseudo-random number generator after fork.
A pthread_atfork() parent handler is used to seed the PRNG with pid, time
and some stack data.
- Issue #18709: Fix CVE-2013-4238. The SSL module now handles NULL bytes
inside subjectAltName correctly. Formerly the module has used OpenSSL's
- GENERAL_NAME_print() function to get the string representation of ASN.1
+ GENERAL_NAME_print() function to get the string represention of ASN.1
strings for ``rfc822Name`` (email), ``dNSName`` (DNS) and
``uniformResourceIdentifier`` (URI).
Documentation
-------------
-- Issue #18743: Fix references to non-existent "StringIO" module.
+- Issue #18743: Fix references to non-existant "StringIO" module.
- Issue #18783: Removed existing mentions of Python long type in docstrings,
error messages and comments.
- Issue #18137: Detect integer overflow on precision in float.__format__()
and complex.__format__().
-- Issue #15767: Introduce ModuleNotFoundError which is raised when a module
- could not be found.
-
- Issue #18183: Fix various unicode operations on strings with large unicode
codepoints.
- Issue #17173: Remove uses of locale-dependent C functions (isalpha() etc.)
in the interpreter.
-- Issue #17137: When a Unicode string is resized, the internal wide character
+- Issue #17137: When an Unicode string is resized, the internal wide character
string (wstr) format is now cleared.
- Issue #17043: The unicode-internal decoder no longer read past the end of
on Windows and adds no value over and above python -m pydoc ...
- Issue #18155: The csv module now correctly handles csv files that use
- a delimiter character that has a special meaning in regexes, instead of
+ a delimter character that has a special meaning in regexes, instead of
throwing an exception.
- Issue #14360: encode_quopri can now be successfully used as an encoder
Thomas Barlow.
- Issue #17358: Modules loaded by imp.load_source() and load_compiled() (and by
- extension load_module()) now have a better chance of working when reloaded.
+ extention load_module()) now have a better chance of working when reloaded.
- Issue #17804: New function ``struct.iter_unpack`` allows for streaming
struct unpacking.
error message has been removed. Patch by Ram Rachum.
- Issue #18080: When building a C extension module on OS X, if the compiler
- is overridden with the CC environment variable, use the new compiler as
- the default for linking if LDSHARED is not also overridden. This restores
+ is overriden with the CC environment variable, use the new compiler as
+ the default for linking if LDSHARED is not also overriden. This restores
Distutils behavior introduced in 3.2.3 and inadvertently dropped in 3.3.0.
- Issue #18113: Fixed a refcount leak in the curses.panel module's
specifically addresses a stack misalignment issue on x86 and issues on
some more recent platforms.
-- Issue #8862: Fixed curses cleanup when getkey is interrupted by a signal.
+- Issue #8862: Fixed curses cleanup when getkey is interrputed by a signal.
- Issue #17443: imaplib.IMAP4_stream was using the default unbuffered IO
in subprocess, but the imap code assumes buffered IO. In Python2 this
symlinks on POSIX platforms.
- Issue #13773: sqlite3.connect() gets a new `uri` parameter to pass the
- filename as a URI, allowing custom options to be passed.
+ filename as a URI, allowing to pass custom options.
- Issue #16564: Fixed regression relative to Python2 in the operation of
email.encoders.encode_noop when used with binary data.
internal XML encoding is not UTF-8 or US-ASCII. It also now accepts bytes
and strings larger than 2 GiB.
-- Issue #6083: Fix multiple segmentation faults occurred when PyArg_ParseTuple
+- Issue #6083: Fix multiple segmentation faults occured when PyArg_ParseTuple
parses nested mutating sequence.
- Issue #5289: Fix ctypes.util.find_library on Solaris.
- Issue #7719: Make distutils ignore ``.nfs*`` files instead of choking later
on. Initial patch by SilentGhost and Jeff Ramnani.
-- Issue #13120: Allow calling pdb.set_trace() from thread.
+- Issue #13120: Allow to call pdb.set_trace() from thread.
Patch by Ilya Sandler.
- Issue #16585: Make CJK encoders support error handlers that return bytes per
- Issue #16284: Prevent keeping unnecessary references to worker functions
in concurrent.futures ThreadPoolExecutor.
-- Issue #16230: Fix a crash in select.select() when one of the lists changes
+- Issue #16230: Fix a crash in select.select() when one the lists changes
size while iterated on. Patch by Serhiy Storchaka.
- Issue #16228: Fix a crash in the json module where a list changes size
- Issue #16245: Fix the value of a few entities in html.entities.html5.
-- Issue #16301: Fix the localhost verification in urllib/request.py for ``file://``
+- Issue #16301: Fix the localhost verification in urllib/request.py for file://
urls.
- Issue #16250: Fix the invocations of URLError which had misplaced filename
- Issue #16176: Properly identify Windows 8 via platform.platform()
- Issue #16088: BaseHTTPRequestHandler's send_error method includes a
- Content-Length header in its response now. Patch by Antoine Pitrou.
+ Content-Length header in it's response now. Patch by Antoine Pitrou.
- Issue #16114: The subprocess module no longer provides a misleading error
message stating that args[0] did not exist when either the cwd or executable
PyImport_ExecCodeModuleWithPathnames() (and thus by extension
PyImport_ExecCodeModule() and PyImport_ExecCodeModuleEx()).
-- Issue #15767: Added PyErr_SetImportErrorSubclass().
-
-- PyErr_SetImportError() now sets TypeError when its msg argument is set.
-
- Issue #9369: The types of `char*` arguments of PyObject_CallFunction() and
PyObject_CallMethod() now changed to `const char*`. Based on patches by
Jörg Müller and Lars Buitinck.
Documentation
-------------
-- Issue #23006: Improve the documentation and indexing of dict.__missing__.
- Add an entry in the language datamodel special methods section.
- Revise and index its discussion in the stdtypes mapping/dict section.
-
- Issue #17701: Improving strftime documentation.
- Issue #18440: Clarify that `hash()` can truncate the value returned from an
NULL).
- Issue #10829: Refactor PyUnicode_FromFormat(), use the same function to parse
- the format string in the 3 steps, fix crashs on invalid format strings.
+ the format string in the 3 steps, fix crashes on invalid format strings.
- Issue #13007: whichdb should recognize gdbm 1.9 magic numbers.
Python News
+++++++++++
+What's New in Python 3.6.1?
+===========================
+
+*Release date: 2017-03-21*
+
+Core and Builtins
+-----------------
+
+- bpo-29723: The ``sys.path[0]`` initialization change for bpo-29139 caused a
+ regression by revealing an inconsistency in how sys.path is initialized when
+ executing ``__main__`` from a zipfile, directory, or other import location.
+ The interpreter now consistently avoids ever adding the import location's
+ parent directory to ``sys.path``, and ensures no other ``sys.path`` entries
+ are inadvertently modified when inserting the import location named on the
+ command line.
+
+Build
+-----
+
+- bpo-27593: fix format of git information used in sys.version
+
+- Fix incompatible comment in python.h
+
+
+What's New in Python 3.6.1 release candidate 1
+==============================================
+
+*Release date: 2017-03-04*
+
+Core and Builtins
+-----------------
+
+- bpo-28893: Set correct __cause__ for errors about invalid awaitables
+ returned from __aiter__ and __anext__.
+
+- bpo-29683: Fixes to memory allocation in _PyCode_SetExtra. Patch by
+ Brian Coleman.
+
+- bpo-29684: Fix minor regression of PyEval_CallObjectWithKeywords.
+ It should raise TypeError when kwargs is not a dict. But it might
+ cause segv when args=NULL and kwargs is not a dict.
+
+- Issue #28598: Support __rmod__ for subclasses of str being called before
+ str.__mod__. Patch by Martijn Pieters.
+
+- bpo-29572: Update Windows build and OS X installers to use OpenSSL 1.0.2k.
+
+- bpo-29607: Fix stack_effect computation for CALL_FUNCTION_EX.
+ Patch by Matthieu Dartiailh.
+
+- bpo-29602: Fix incorrect handling of signed zeros in complex constructor for
+ complex subclasses and for inputs having a __complex__ method. Patch
+ by Serhiy Storchaka.
+
+- bpo-29347: Fixed possibly dereferencing undefined pointers
+ when creating weakref objects.
+
+- bpo-29438: Fixed use-after-free problem in key sharing dict.
+
+- Issue #29319: Prevent RunMainFromImporter overwriting sys.path[0].
+
+- Issue #29337: Fixed possible BytesWarning when compare the code objects.
+ Warnings could be emitted at compile time.
+
+- Issue #29327: Fixed a crash when pass the iterable keyword argument to
+ sorted().
+
+- Issue #29034: Fix memory leak and use-after-free in os module (path_converter).
+
+- Issue #29159: Fix regression in bytes(x) when x.__index__() raises Exception.
+
+- Issue #28932: Do not include <sys/random.h> if it does not exist.
+
+- Issue #25677: Correct the positioning of the syntax error caret for
+ indented blocks. Based on patch by Michael Layzell.
+
+- Issue #29000: Fixed bytes formatting of octals with zero padding in alternate
+ form.
+
+- Issue #26919: On Android, operating system data is now always encoded/decoded
+ to/from UTF-8, instead of the locale encoding to avoid inconsistencies with
+ os.fsencode() and os.fsdecode() which are already using UTF-8.
+
+- Issue #28991: functools.lru_cache() was susceptible to an obscure reentrancy
+ bug triggerable by a monkey-patched len() function.
+
+- Issue #28739: f-string expressions are no longer accepted as docstrings and
+ by ast.literal_eval() even if they do not include expressions.
+
+- Issue #28512: Fixed setting the offset attribute of SyntaxError by
+ PyErr_SyntaxLocationEx() and PyErr_SyntaxLocationObject().
+
+- Issue #28918: Fix the cross compilation of xxlimited when Python has been
+ built with Py_DEBUG defined.
+
+- Issue #28731: Optimize _PyDict_NewPresized() to create correct size dict.
+ Improve speed of dict literal with constant keys up to 30%.
+
+Extension Modules
+-----------------
+
+- Issue #29169: Update zlib to 1.2.11.
+
+Library
+-------
+
+- bpo-29623: Allow use of path-like object as a single argument in
+ ConfigParser.read(). Patch by David Ellis.
+
+- bpo-28963: Fix out of bound iteration in asyncio.Future.remove_done_callback
+ implemented in C.
+
+- bpo-29704: asyncio.subprocess.SubprocessStreamProtocol no longer closes
+ before all pipes are closed.
+
+- bpo-29271: Fix Task.current_task and Task.all_tasks implemented in C
+ to accept None argument as their pure Python implementation.
+
+- bpo-29703: Fix asyncio to support instantiation of new event loops
+ in child processes.
+
+- bpo-29376: Fix assertion error in threading._DummyThread.is_alive().
+
+- bpo-28624: Add a test that checks that cwd parameter of Popen() accepts
+ PathLike objects. Patch by Sayan Chowdhury.
+
+- bpo-28518: Start a transaction implicitly before a DML statement.
+ Patch by Aviv Palivoda.
+
+- bpo-29532: Altering a kwarg dictionary passed to functools.partial()
+ no longer affects a partial object after creation.
+
+- bpo-29110: Fix file object leak in aifc.open() when file is given as a
+ filesystem path and is not in valid AIFF format. Patch by Anthony Zhang.
+
+- Issue #28556: Various updates to typing module: typing.Counter, typing.ChainMap,
+ improved ABC caching, etc. Original PRs by Jelle Zijlstra, Ivan Levkivskyi,
+ Manuel Krebber, and Łukasz Langa.
+
+- Issue #29100: Fix datetime.fromtimestamp() regression introduced in Python
+ 3.6.0: check minimum and maximum years.
+
+- Issue #29519: Fix weakref spewing exceptions during interpreter shutdown
+ when used with a rare combination of multiprocessing and custom codecs.
+
+- Issue #29416: Prevent infinite loop in pathlib.Path.mkdir
+
+- Issue #29444: Fixed out-of-bounds buffer access in the group() method of
+ the match object. Based on patch by WGH.
+
+- Issue #29335: Fix subprocess.Popen.wait() when the child process has
+ exited to a stopped instead of terminated state (ex: when under ptrace).
+
+- Issue #29290: Fix a regression in argparse that help messages would wrap at
+ non-breaking spaces.
+
+- Issue #28735: Fixed the comparison of mock.MagickMock with mock.ANY.
+
+- Issue #29316: Restore the provisional status of typing module, add
+ corresponding note to documentation. Patch by Ivan L.
+
+- Issue #29219: Fixed infinite recursion in the repr of uninitialized
+ ctypes.CDLL instances.
+
+- Issue #29011: Fix an important omission by adding Deque to the typing module.
+
+- Issue #28969: Fixed race condition in C implementation of functools.lru_cache.
+ KeyError could be raised when cached function with full cache was
+ simultaneously called from differen threads with the same uncached arguments.
+
+- Issue #29142: In urllib.request, suffixes in no_proxy environment variable with
+ leading dots could match related hostnames again (e.g. .b.c matches a.b.c).
+ Patch by Milan Oberkirch.
+
+- Issue #28961: Fix unittest.mock._Call helper: don't ignore the name parameter
+ anymore. Patch written by Jiajun Huang.
+
+- Issue #29203: functools.lru_cache() now respects PEP 468 and preserves
+ the order of keyword arguments. f(a=1, b=2) is now cached separately
+ from f(b=2, a=1) since both calls could potentially give different results.
+
+- Issue #15812: inspect.getframeinfo() now correctly shows the first line of
+ a context. Patch by Sam Breese.
+
+- Issue #29094: Offsets in a ZIP file created with extern file object and modes
+ "w" and "x" now are relative to the start of the file.
+
+- Issue #29085: Allow random.Random.seed() to use high quality OS randomness
+ rather than the pid and time.
+
+- Issue #29061: Fixed bug in secrets.randbelow() which would hang when given
+ a negative input. Patch by Brendan Donegan.
+
+- Issue #29079: Prevent infinite loop in pathlib.resolve() on Windows
+
+- Issue #13051: Fixed recursion errors in large or resized
+ curses.textpad.Textbox. Based on patch by Tycho Andersen.
+
+- Issue #29119: Fix weakrefs in the pure python version of
+ collections.OrderedDict move_to_end() method.
+ Contributed by Andra Bogildea.
+
+- Issue #9770: curses.ascii predicates now work correctly with negative
+ integers.
+
+- Issue #28427: old keys should not remove new values from
+ WeakValueDictionary when collecting from another thread.
+
+- Issue 28923: Remove editor artifacts from Tix.py.
+
+- Issue #29055: Neaten-up empty population error on random.choice()
+ by suppressing the upstream exception.
+
+- Issue #28871: Fixed a crash when deallocate deep ElementTree.
+
+- Issue #19542: Fix bugs in WeakValueDictionary.setdefault() and
+ WeakValueDictionary.pop() when a GC collection happens in another
+ thread.
+
+- Issue #20191: Fixed a crash in resource.prlimit() when passing a sequence that
+ doesn't own its elements as limits.
+
+- Issue #28779: multiprocessing.set_forkserver_preload() would crash the
+ forkserver process if a preloaded module instantiated some
+ multiprocessing objects such as locks.
+
+- Issue #28847: dbm.dumb now supports reading read-only files and no longer
+ writes the index file when it is not changed.
+
+- Issue #26937: The chown() method of the tarfile.TarFile class does not fail
+ now when the grp module cannot be imported, as for example on Android
+ platforms.
+
+Windows
+-------
+
+- bpo-29579: Removes readme.txt from the installer
+
+- Issue #29326: Ignores blank lines in ._pth files (Patch by Alexey Izbyshev)
+
+- Issue #28164: Correctly handle special console filenames (patch by Eryk Sun)
+
+- Issue #29409: Implement PEP 529 for io.FileIO (Patch by Eryk Sun)
+
+- Issue #29392: Prevent crash when passing invalid arguments into msvcrt module.
+
+- Issue #25778: winreg does not truncate string correctly (Patch by Eryk Sun)
+
+- Issue #28896: Deprecate WindowsRegistryFinder and disable it by default.
+
+C API
+-----
+
+- Issue #27867: Function PySlice_GetIndicesEx() is replaced with a macro if
+ Py_LIMITED_API is not set or set to the value between 0x03050400
+ and 0x03060000 (not including) or 0x03060100 or higher.
+
+- Issue #29083: Fixed the declaration of some public API functions.
+ PyArg_VaParse() and PyArg_VaParseTupleAndKeywords() were not available in
+ limited API. PyArg_ValidateKeywordArguments(), PyArg_UnpackTuple() and
+ Py_BuildValue() were not available in limited API of version < 3.3 when
+ PY_SSIZE_T_CLEAN is defined.
+
+- Issue #29058: All stable API extensions added after Python 3.2 are now
+ available only when Py_LIMITED_API is set to the PY_VERSION_HEX value of
+ the minimum Python version supporting this API.
+
+Documentation
+-------------
+
+- bpo-28929: Link the documentation to its source file on GitHub.
+
+- bpo-25008: Document smtpd.py as effectively deprecated and add a pointer to
+ aiosmtpd, a third-party asyncio-based replacement.
+
+- Issue #26355: Add canonical header link on each page to corresponding major
+ version of the documentation. Patch by Matthias Bussonnier.
+
+- Issue #29349: Fix Python 2 syntax in code for building the documentation.
+
+Tests
+-----
+
+- bpo-28087: Skip test_asyncore and test_eintr poll failures on macOS.
+ Skip some tests of select.poll when running on macOS due to unresolved
+ issues with the underlying system poll function on some macOS versions.
+
+- Issue #29571: to match the behaviour of the ``re.LOCALE`` flag,
+ test_re.test_locale_flag now uses ``locale.getpreferredencoding(False)`` to
+ determine the candidate encoding for the test regex (allowing it to correctly
+ skip the test when the default locale encoding is a multi-byte encoding)
+
+- Issue #28950: Disallow -j0 to be combined with -T/-l in regrtest
+ command line arguments.
+
+- Issue #28683: Fix the tests that bind() a unix socket and raise
+ PermissionError on Android for a non-root user.
+
+- Issue #26939: Add the support.setswitchinterval() function to fix
+ test_functools hanging on the Android armv7 qemu emulator.
+
+Build
+-----
+
+- bpo-27593: sys.version and the platform module python_build(),
+ python_branch(), and python_revision() functions now use
+ git information rather than hg when building from a repo.
+
+- bpo-29572: Update Windows build and OS X installers to use OpenSSL 1.0.2k.
+
+- Issue #26851: Set Android compilation and link flags.
+
+- Issue #28768: Fix implicit declaration of function _setmode. Patch by
+ Masayuki Yamamoto
+
+- Issue #29080: Removes hard dependency on hg.exe from PCBuild/build.bat
+
+- Issue #23903: Added missed names to PC/python3.def.
+
+- Issue #28762: lockf() is available on Android API level 24, but the F_LOCK
+ macro is not defined in android-ndk-r13.
+
+- Issue #28538: Fix the compilation error that occurs because if_nameindex() is
+ available on Android API level 24, but the if_nameindex structure is not
+ defined.
+
+- Issue #20211: Do not add the directory for installing C header files and the
+ directory for installing object code libraries to the cross compilation
+ search paths. Original patch by Thomas Petazzoni.
+
+- Issue #28849: Do not define sys.implementation._multiarch on Android.
+
+
What's New in Python 3.6.0?
===========================
must not convert combined table into split table. Patch written by INADA
Naoki.
-- Issue #28990: Fix asynchio SSL hanging if connection is closed before
+- Issue #28990: Fix asyncio SSL hanging if connection is closed before
handshake is completed. (Patch by HoHo-Ho)
Tools/Demos
may be revisited again after the Python 2.7 branch is no longer officially
supported.
+- Issue #26273: Add new :data:`socket.TCP_CONGESTION` (Linux 2.6.13) and
+ :data:`socket.TCP_USER_TIMEOUT` (Linux 2.6.37) constants. Patch written by
+ Omar Sandoval.
+
- Issue #24142: Reading a corrupt config file left configparser in an
invalid state. Original patch by Florian Höch.
Library
-------
-- Issue #26273: Add new :data:`socket.TCP_CONGESTION` (Linux 2.6.13) and
- :data:`socket.TCP_USER_TIMEOUT` (Linux 2.6.37) constants. Patch written by
- Omar Sandoval.
-
- Issue #28752: Restored the __reduce__() methods of datetime objects.
- Issue #28727: Regular expression patterns, _sre.SRE_Pattern objects created
- Issue #28227: gzip now supports pathlib. Patch by Ethan Furman.
- Issue #27358: Optimized merging var-keyword arguments and improved error
- message when pass a non-mapping as a var-keyword argument.
+ message when passing a non-mapping as a var-keyword argument.
-- Issue #28257: Improved error message when pass a non-iterable as
+- Issue #28257: Improved error message when passing a non-iterable as
a var-positional argument. Added opcode BUILD_TUPLE_UNPACK_WITH_CALL.
- Issue #28322: Fixed possible crashes when unpickle itertools objects from
- Issue #26307: The profile-opt build now applies PGO to the built-in modules.
-- Issue #26539: Add the --with-optimizations flag to turn on LTO and PGO build
+- Issue #26359: Add the --with-optimizations flag to turn on LTO and PGO build
support when available.
- Issue #27917: Set platform triplets for Android builds.
instead of TypeError on programmical error in parsing format string.
-What's New in Python 3.5.1 final?
-=================================
-
-Release date: 2015-12-06
-
-Core and Builtins
------------------
-
-- Issue #25709: Fixed problem with in-place string concatenation and
- utf-8 cache.
+What's New in Python 3.5.3?
+===========================
-Windows
--------
+Release date: 2017-01-17
-- Issue #25715: Python 3.5.1 installer shows wrong upgrade path and incorrect
- logic for launcher detection.
+There were no code changes between 3.5.3rc1 and 3.5.3 final.
-What's New in Python 3.5.1 release candidate 1?
+What's New in Python 3.5.3 release candidate 1?
===============================================
-Release date: 2015-11-22
+Release date: 2017-01-02
Core and Builtins
-----------------
-- Issue #25630: Fix a possible segfault during argument parsing in functions
- that accept filesystem paths.
+- Issue #29073: bytearray formatting no longer truncates on first null byte.
-- Issue #23564: Fixed a partially broken sanity check in the _posixsubprocess
- internals regarding how fds_to_pass were passed to the child. The bug had
- no actual impact as subprocess.py already avoided it.
+- Issue #28932: Do not include <sys/random.h> if it does not exist.
-- Issue #25388: Fixed tokenizer crash when processing undecodable source code
- with a null byte.
+- Issue #28147: Fix a memory leak in split-table dictionaries: setattr()
+ must not convert combined table into split table.
-- Issue #25462: The hash of the key now is calculated only once in most
- operations in C implementation of OrderedDict.
+- Issue #25677: Correct the positioning of the syntax error caret for
+ indented blocks. Based on patch by Michael Layzell.
-- Issue #22995: Default implementation of __reduce__ and __reduce_ex__ now
- rejects builtin types with not defined __new__.
+- Issue #29000: Fixed bytes formatting of octals with zero padding in alternate
+ form.
-- Issue #25555: Fix parser and AST: fill lineno and col_offset of "arg" node
- when compiling AST from Python objects.
+- Issue #28512: Fixed setting the offset attribute of SyntaxError by
+ PyErr_SyntaxLocationEx() and PyErr_SyntaxLocationObject().
-- Issue #24802: Avoid buffer overreads when int(), float(), compile(), exec()
- and eval() are passed bytes-like objects. These objects are not
- necessarily terminated by a null byte, but the functions assumed they were.
+- Issue #28991: functools.lru_cache() was susceptible to an obscure reentrancy
+ bug caused by a monkey-patched len() function.
-- Issue #24726: Fixed a crash and leaking NULL in repr() of OrderedDict that
- was mutated by direct calls of dict methods.
+- Issue #28648: Fixed crash in Py_DecodeLocale() in debug build on Mac OS X
+ when decode astral characters. Patch by Xiang Zhang.
-- Issue #25449: Iterating OrderedDict with keys with unstable hash now raises
- KeyError in C implementations as well as in Python implementation.
+- Issue #19398: Extra slash no longer added to sys.path components in case of
+ empty compile-time PYTHONPATH components.
-- Issue #25395: Fixed crash when highly nested OrderedDict structures were
- garbage collected.
+- Issue #28426: Fixed potential crash in PyUnicode_AsDecodedObject() in debug
+ build.
-- Issue #25274: sys.setrecursionlimit() now raises a RecursionError if the new
- recursion limit is too low depending at the current recursion depth. Modify
- also the "lower-water mark" formula to make it monotonic. This mark is used
- to decide when the overflowed flag of the thread state is reset.
+- Issue #23782: Fixed possible memory leak in _PyTraceback_Add() and exception
+ loss in PyTraceBack_Here().
-- Issue #24402: Fix input() to prompt to the redirected stdout when
- sys.stdout.fileno() fails.
+- Issue #28379: Added sanity checks and tests for PyUnicode_CopyCharacters().
+ Patch by Xiang Zhang.
-- Issue #24806: Prevent builtin types that are not allowed to be subclassed from
- being subclassed through multiple inheritance.
+- Issue #28376: The type of long range iterator is now registered as Iterator.
+ Patch by Oren Milman.
-- Issue #24848: Fixed a number of bugs in UTF-7 decoding of misformed data.
+- Issue #28376: The constructor of range_iterator now checks that step is not 0.
+ Patch by Oren Milman.
-- Issue #25280: Import trace messages emitted in verbose (-v) mode are no
- longer formatted twice.
+- Issue #26906: Resolving special methods of uninitialized type now causes
+ implicit initialization of the type instead of a fail.
-- Issue #25003: On Solaris 11.3 or newer, os.urandom() now uses the
- getrandom() function instead of the getentropy() function. The getentropy()
- function is blocking to generate very good quality entropy, os.urandom()
- doesn't need such high-quality entropy.
+- Issue #18287: PyType_Ready() now checks that tp_name is not NULL.
+ Original patch by Niklas Koep.
-- Issue #25182: The stdprinter (used as sys.stderr before the io module is
- imported at startup) now uses the backslashreplace error handler.
+- Issue #24098: Fixed possible crash when AST is changed in process of
+ compiling it.
-- Issue #25131: Make the line number and column offset of set/dict literals and
- comprehensions correspond to the opening brace.
+- Issue #28350: String constants with null character no longer interned.
-- Issue #25150: Hide the private _Py_atomic_xxx symbols from the public
- Python.h header to fix a compilation error with OpenMP. PyThreadState_GET()
- becomes an alias to PyThreadState_Get() to avoid ABI incompatibilies.
+- Issue #26617: Fix crash when GC runs during weakref callbacks.
-Library
--------
+- Issue #27942: String constants now interned recursively in tuples and frozensets.
-- Issue #25626: Change three zlib functions to accept sizes that fit in
- Py_ssize_t, but internally cap those sizes to UINT_MAX. This resolves a
- regression in 3.5 where GzipFile.read() failed to read chunks larger than 2
- or 4 GiB. The change affects the zlib.Decompress.decompress() max_length
- parameter, the zlib.decompress() bufsize parameter, and the
- zlib.Decompress.flush() length parameter.
+- Issue #21578: Fixed misleading error message when ImportError called with
+ invalid keyword args.
-- Issue #25583: Avoid incorrect errors raised by os.makedirs(exist_ok=True)
- when the OS gives priority to errors such as EACCES over EEXIST.
+- Issue #28203: Fix incorrect type in error message from
+ ``complex(1.0, {2:3})``. Patch by Soumya Sharma.
-- Issue #25593: Change semantics of EventLoop.stop() in asyncio.
+- Issue #27955: Fallback on reading /dev/urandom device when the getrandom()
+ syscall fails with EPERM, for example when blocked by SECCOMP.
-- Issue #6973: When we know a subprocess.Popen process has died, do
- not allow the send_signal(), terminate(), or kill() methods to do
- anything as they could potentially signal a different process.
+- Issue #28131: Fix a regression in zipimport's compile_source(). zipimport
+ should use the same optimization level as the interpreter.
-- Issue #25590: In the Readline completer, only call getattr() once per
- attribute.
+- Issue #25221: Fix corrupted result from PyLong_FromLong(0) when
+ Python is compiled with NSMALLPOSINTS = 0.
-- Issue #25498: Fix a crash when garbage-collecting ctypes objects created
- by wrapping a memoryview. This was a regression made in 3.5a1. Based
- on patch by Eryksun.
+- Issue #25758: Prevents zipimport from unnecessarily encoding a filename
+ (patch by Eryk Sun)
-- Issue #25584: Added "escape" to the __all__ list in the glob module.
+- Issue #28189: dictitems_contains no longer swallows compare errors.
+ (Patch by Xiang Zhang)
+
+- Issue #27812: Properly clear out a generator's frame's backreference to the
+ generator to prevent crashes in frame.clear().
+
+- Issue #27811: Fix a crash when a coroutine that has not been awaited is
+ finalized with warnings-as-errors enabled.
+
+- Issue #27587: Fix another issue found by PVS-Studio: Null pointer check
+ after use of 'def' in _PyState_AddModule().
+ Initial patch by Christian Heimes.
+
+- Issue #26020: set literal evaluation order did not match documented behaviour.
+
+- Issue #27782: Multi-phase extension module import now correctly allows the
+ ``m_methods`` field to be used to add module level functions to instances
+ of non-module types returned from ``Py_create_mod``. Patch by Xiang Zhang.
+
+- Issue #27936: The round() function accepted a second None argument
+ for some types but not for others. Fixed the inconsistency by
+ accepting None for all numeric types.
+
+- Issue #27487: Warn if a submodule argument to "python -m" or
+ runpy.run_module() is found in sys.modules after parent packages are
+ imported, but before the submodule is executed.
+
+- Issue #27558: Fix a SystemError in the implementation of "raise" statement.
+ In a brand new thread, raise a RuntimeError since there is no active
+ exception to reraise. Patch written by Xiang Zhang.
+
+- Issue #27419: Standard __import__() no longer look up "__import__" in globals
+ or builtins for importing submodules or "from import". Fixed handling an
+ error of non-string package name.
+
+- Issue #27083: Respect the PYTHONCASEOK environment variable under Windows.
+
+- Issue #27514: Make having too many statically nested blocks a SyntaxError
+ instead of SystemError.
+
+- Issue #27473: Fixed possible integer overflow in bytes and bytearray
+ concatenations. Patch by Xiang Zhang.
+
+- Issue #27507: Add integer overflow check in bytearray.extend(). Patch by
+ Xiang Zhang.
+
+- Issue #27581: Don't rely on wrapping for overflow check in
+ PySequence_Tuple(). Patch by Xiang Zhang.
+
+- Issue #27443: __length_hint__() of bytearray iterators no longer return a
+ negative integer for a resized bytearray.
+
+- Issue #27942: Fix memory leak in codeobject.c
+
+Library
+-------
+
+- Issue #15812: inspect.getframeinfo() now correctly shows the first line of
+ a context. Patch by Sam Breese.
+
+- Issue #29094: Offsets in a ZIP file created with extern file object and modes
+ "w" and "x" now are relative to the start of the file.
+
+- Issue #13051: Fixed recursion errors in large or resized
+ curses.textpad.Textbox. Based on patch by Tycho Andersen.
+
+- Issue #29119: Fix weakrefs in the pure python version of
+ collections.OrderedDict move_to_end() method.
+ Contributed by Andra Bogildea.
+
+- Issue #9770: curses.ascii predicates now work correctly with negative
+ integers.
+
+- Issue #28427: old keys should not remove new values from
+ WeakValueDictionary when collecting from another thread.
+
+- Issue 28923: Remove editor artifacts from Tix.py.
+
+- Issue #28871: Fixed a crash when deallocate deep ElementTree.
+
+- Issue #19542: Fix bugs in WeakValueDictionary.setdefault() and
+ WeakValueDictionary.pop() when a GC collection happens in another
+ thread.
+
+- Issue #20191: Fixed a crash in resource.prlimit() when pass a sequence that
+ doesn't own its elements as limits.
+
+- Issue #28779: multiprocessing.set_forkserver_preload() would crash the
+ forkserver process if a preloaded module instantiated some
+ multiprocessing objects such as locks.
+
+- Issue #28847: dbm.dumb now supports reading read-only files and no longer
+ writes the index file when it is not changed.
+
+- Issue #25659: In ctypes, prevent a crash calling the from_buffer() and
+ from_buffer_copy() methods on abstract classes like Array.
+
+- Issue #28732: Fix crash in os.spawnv() with no elements in args
+
+- Issue #28485: Always raise ValueError for negative
+ compileall.compile_dir(workers=...) parameter, even when multithreading is
+ unavailable.
+
+- Issue #28387: Fixed possible crash in _io.TextIOWrapper deallocator when
+ the garbage collector is invoked in other thread. Based on patch by
+ Sebastian Cufre.
+
+- Issue #27517: LZMA compressor and decompressor no longer raise exceptions if
+ given empty data twice. Patch by Benjamin Fogle.
+
+- Issue #28549: Fixed segfault in curses's addch() with ncurses6.
+
+- Issue #28449: tarfile.open() with mode "r" or "r:" now tries to open a tar
+ file with compression before trying to open it without compression. Otherwise
+ it had 50% chance failed with ignore_zeros=True.
+
+- Issue #23262: The webbrowser module now supports Firefox 36+ and derived
+ browsers. Based on patch by Oleg Broytman.
+
+- Issue #27939: Fixed bugs in tkinter.ttk.LabeledScale and tkinter.Scale caused
+ by representing the scale as float value internally in Tk. tkinter.IntVar
+ now works if float value is set to underlying Tk variable.
+
+- Issue #28255: calendar.TextCalendar().prmonth() no longer prints a space
+ at the start of new line after printing a month's calendar. Patch by
+ Xiang Zhang.
+
+- Issue #20491: The textwrap.TextWrapper class now honors non-breaking spaces.
+ Based on patch by Kaarle Ritvanen.
+
+- Issue #28353: os.fwalk() no longer fails on broken links.
+
+- Issue #25464: Fixed HList.header_exists() in tkinter.tix module by addin
+ a workaround to Tix library bug.
+
+- Issue #28488: shutil.make_archive() no longer add entry "./" to ZIP archive.
+
+- Issue #24452: Make webbrowser support Chrome on Mac OS X.
+
+- Issue #20766: Fix references leaked by pdb in the handling of SIGINT
+ handlers.
+
+- Issue #26293: Fixed writing ZIP files that starts not from the start of the
+ file. Offsets in ZIP file now are relative to the start of the archive in
+ conforming to the specification.
+
+- Issue #28321: Fixed writing non-BMP characters with binary format in plistlib.
+
+- Issue #28322: Fixed possible crashes when unpickle itertools objects from
+ incorrect pickle data. Based on patch by John Leitch.
+
+- Fix possible integer overflows and crashes in the mmap module with unusual
+ usage patterns.
+
+- Issue #1703178: Fix the ability to pass the --link-objects option to the
+ distutils build_ext command.
+
+- Issue #28253: Fixed calendar functions for extreme months: 0001-01
+ and 9999-12.
+
+ Methods itermonthdays() and itermonthdays2() are reimplemented so
+ that they don't call itermonthdates() which can cause datetime.date
+ under/overflow.
+
+- Issue #28275: Fixed possible use after free in the decompress()
+ methods of the LZMADecompressor and BZ2Decompressor classes.
+ Original patch by John Leitch.
+
+- Issue #27897: Fixed possible crash in sqlite3.Connection.create_collation()
+ if pass invalid string-like object as a name. Patch by Xiang Zhang.
+
+- Issue #18893: Fix invalid exception handling in Lib/ctypes/macholib/dyld.py.
+ Patch by Madison May.
+
+- Issue #27611: Fixed support of default root window in the tkinter.tix module.
+
+- Issue #27348: In the traceback module, restore the formatting of exception
+ messages like "Exception: None". This fixes a regression introduced in
+ 3.5a2.
+
+- Issue #25651: Allow falsy values to be used for msg parameter of subTest().
+
+- Issue #27932: Prevent memory leak in win32_ver().
+
+- Fix UnboundLocalError in socket._sendfile_use_sendfile.
+
+- Issue #28075: Check for ERROR_ACCESS_DENIED in Windows implementation of
+ os.stat(). Patch by Eryk Sun.
+
+- Issue #25270: Prevent codecs.escape_encode() from raising SystemError when
+ an empty bytestring is passed.
+
+- Issue #28181: Get antigravity over HTTPS. Patch by Kaartic Sivaraam.
+
+- Issue #25895: Enable WebSocket URL schemes in urllib.parse.urljoin.
+ Patch by Gergely Imreh and Markus Holtermann.
+
+- Issue #27599: Fixed buffer overrun in binascii.b2a_qp() and binascii.a2b_qp().
+
+- Issue #19003:m email.generator now replaces only \r and/or \n line
+ endings, per the RFC, instead of all unicode line endings.
+
+- Issue #28019: itertools.count() no longer rounds non-integer step in range
+ between 1.0 and 2.0 to 1.
+
+- Issue #25969: Update the lib2to3 grammar to handle the unpacking
+ generalizations added in 3.5.
+
+- Issue #14977: mailcap now respects the order of the lines in the mailcap
+ files ("first match"), as required by RFC 1542. Patch by Michael Lazar.
+
+- Issue #24594: Validates persist parameter when opening MSI database
+
+- Issue #17582: xml.etree.ElementTree nows preserves whitespaces in attributes
+ (Patch by Duane Griffin. Reviewed and approved by Stefan Behnel.)
+
+- Issue #28047: Fixed calculation of line length used for the base64 CTE
+ in the new email policies.
+
+- Issue #27445: Don't pass str(_charset) to MIMEText.set_payload().
+ Patch by Claude Paroz.
+
+- Issue #22450: urllib now includes an "Accept: */*" header among the
+ default headers. This makes the results of REST API requests more
+ consistent and predictable especially when proxy servers are involved.
+
+- lib2to3.pgen3.driver.load_grammar() now creates a stable cache file
+ between runs given the same Grammar.txt input regardless of the hash
+ randomization setting.
+
+- Issue #27570: Avoid zero-length memcpy() etc calls with null source
+ pointers in the "ctypes" and "array" modules.
+
+- Issue #22233: Break email header lines *only* on the RFC specified CR and LF
+ characters, not on arbitrary unicode line breaks. This also fixes a bug in
+ HTTP header parsing.
+
+- Issue 27988: Fix email iter_attachments incorrect mutation of payload list.
+
+- Issue #27691: Fix ssl module's parsing of GEN_RID subject alternative name
+ fields in X.509 certs.
+
+- Issue #27850: Remove 3DES from ssl module's default cipher list to counter
+ measure sweet32 attack (CVE-2016-2183).
+
+- Issue #27766: Add ChaCha20 Poly1305 to ssl module's default ciper list.
+ (Required OpenSSL 1.1.0 or LibreSSL).
+
+- Issue #26470: Port ssl and hashlib module to OpenSSL 1.1.0.
+
+- Remove support for passing a file descriptor to os.access. It never worked but
+ previously didn't raise.
+
+- Issue #12885: Fix error when distutils encounters symlink.
+
+- Issue #27881: Fixed possible bugs when setting sqlite3.Connection.isolation_level.
+ Based on patch by Xiang Zhang.
+
+- Issue #27861: Fixed a crash in sqlite3.Connection.cursor() when a factory
+ creates not a cursor. Patch by Xiang Zhang.
+
+- Issue #19884: Avoid spurious output on OS X with Gnu Readline.
+
+- Issue #27706: Restore deterministic behavior of random.Random().seed()
+ for string seeds using seeding version 1. Allows sequences of calls
+ to random() to exactly match those obtained in Python 2.
+ Patch by Nofar Schnider.
+
+- Issue #10513: Fix a regression in Connection.commit(). Statements should
+ not be reset after a commit.
+
+- A new version of typing.py from https://github.com/python/typing:
+ - Collection (only for 3.6) (Issue #27598)
+ - Add FrozenSet to __all__ (upstream #261)
+ - fix crash in _get_type_vars() (upstream #259)
+ - Remove the dict constraint in ForwardRef._eval_type (upstream #252)
+
+- Issue #27539: Fix unnormalised ``Fraction.__pow__`` result in the case
+ of negative exponent and negative base.
+
+- Issue #21718: cursor.description is now available for queries using CTEs.
+
+- Issue #2466: posixpath.ismount now correctly recognizes mount points which
+ the user does not have permission to access.
+
+- Issue #27773: Correct some memory management errors server_hostname in
+ _ssl.wrap_socket().
+
+- Issue #26750: unittest.mock.create_autospec() now works properly for
+ subclasses of property() and other data descriptors.
+
+- In the curses module, raise an error if window.getstr() or window.instr() is
+ passed a negative value.
+
+- Issue #27783: Fix possible usage of uninitialized memory in
+ operator.methodcaller.
+
+- Issue #27774: Fix possible Py_DECREF on unowned object in _sre.
+
+- Issue #27760: Fix possible integer overflow in binascii.b2a_qp.
+
+- Issue #27758: Fix possible integer overflow in the _csv module for large
+ record lengths.
+
+- Issue #27568: Prevent HTTPoxy attack (CVE-2016-1000110). Ignore the
+ HTTP_PROXY variable when REQUEST_METHOD environment is set, which indicates
+ that the script is in CGI mode.
+
+- Issue #27656: Do not assume sched.h defines any SCHED_* constants.
+
+- Issue #27130: In the "zlib" module, fix handling of large buffers
+ (typically 4 GiB) when compressing and decompressing. Previously, inputs
+ were limited to 4 GiB, and compression and decompression operations did not
+ properly handle results of 4 GiB.
+
+- Issue #27533: Release GIL in nt._isdir
+
+- Issue #17711: Fixed unpickling by the persistent ID with protocol 0.
+ Original patch by Alexandre Vassalotti.
+
+- Issue #27522: Avoid an unintentional reference cycle in email.feedparser.
+
+- Issue #26844: Fix error message for imp.find_module() to refer to 'path'
+ instead of 'name'. Patch by Lev Maximov.
+
+- Issue #23804: Fix SSL zero-length recv() calls to not block and not raise
+ an error about unclean EOF.
+
+- Issue #27466: Change time format returned by http.cookie.time2netscape,
+ confirming the netscape cookie format and making it consistent with
+ documentation.
+
+- Issue #26664: Fix activate.fish by removing mis-use of ``$``.
+
+- Issue #22115: Fixed tracing Tkinter variables: trace_vdelete() with wrong
+ mode no longer break tracing, trace_vinfo() now always returns a list of
+ pairs of strings, tracing in the "u" mode now works.
+
+- Fix a scoping issue in importlib.util.LazyLoader which triggered an
+ UnboundLocalError when lazy-loading a module that was already put into
+ sys.modules.
+
+- Issue #27079: Fixed curses.ascii functions isblank(), iscntrl() and ispunct().
+
+- Issue #26754: Some functions (compile() etc) accepted a filename argument
+ encoded as an iterable of integers. Now only strings and byte-like objects
+ are accepted.
+
+- Issue #27048: Prevents distutils failing on Windows when environment
+ variables contain non-ASCII characters
+
+- Issue #27330: Fixed possible leaks in the ctypes module.
+
+- Issue #27238: Got rid of bare excepts in the turtle module. Original patch
+ by Jelle Zijlstra.
+
+- Issue #27122: When an exception is raised within the context being managed
+ by a contextlib.ExitStack() and one of the exit stack generators
+ catches and raises it in a chain, do not re-raise the original exception
+ when exiting, let the new chained one through. This avoids the PEP 479
+ bug described in issue25782.
+
+- [Security] Issue #27278: Fix os.urandom() implementation using getrandom() on
+ Linux. Truncate size to INT_MAX and loop until we collected enough random
+ bytes, instead of casting a directly Py_ssize_t to int.
+
+- Issue #26386: Fixed ttk.TreeView selection operations with item id's
+ containing spaces.
+
+- [Security] Issue #22636: Avoid shell injection problems with
+ ctypes.util.find_library().
+
+- Issue #16182: Fix various functions in the "readline" module to use the
+ locale encoding, and fix get_begidx() and get_endidx() to return code point
+ indexes.
+
+- Issue #27392: Add loop.connect_accepted_socket().
+ Patch by Jim Fulton.
+
+- Issue #27930: Improved behaviour of logging.handlers.QueueListener.
+ Thanks to Paulo Andrade and Petr Viktorin for the analysis and patch.
+
+- Issue #21201: Improves readability of multiprocessing error message. Thanks
+ to Wojciech Walczak for patch.
+
+- Issue #27456: asyncio: Set TCP_NODELAY by default.
+
+- Issue #27906: Fix socket accept exhaustion during high TCP traffic.
+ Patch by Kevin Conway.
+
+- Issue #28174: Handle when SO_REUSEPORT isn't properly supported.
+ Patch by Seth Michael Larson.
+
+- Issue #26654: Inspect functools.partial in asyncio.Handle.__repr__.
+ Patch by iceboy.
+
+- Issue #26909: Fix slow pipes IO in asyncio.
+ Patch by INADA Naoki.
+
+- Issue #28176: Fix callbacks race in asyncio.SelectorLoop.sock_connect.
+
+- Issue #27759: Fix selectors incorrectly retain invalid file descriptors.
+ Patch by Mark Williams.
+
+- Issue #28368: Refuse monitoring processes if the child watcher has
+ no loop attached.
+ Patch by Vincent Michel.
+
+- Issue #28369: Raise RuntimeError when transport's FD is used with
+ add_reader, add_writer, etc.
+
+- Issue #28370: Speedup asyncio.StreamReader.readexactly.
+ Patch by Коренберг Марк.
+
+- Issue #28371: Deprecate passing asyncio.Handles to run_in_executor.
+
+- Issue #28372: Fix asyncio to support formatting of non-python coroutines.
+
+- Issue #28399: Remove UNIX socket from FS before binding.
+ Patch by Коренберг Марк.
+
+- Issue #27972: Prohibit Tasks to await on themselves.
+
+- Issue #26923: Fix asyncio.Gather to refuse being cancelled once all
+ children are done.
+ Patch by Johannes Ebke.
+
+- Issue #26796: Don't configure the number of workers for default
+ threadpool executor.
+ Initial patch by Hans Lawrenz.
+
+- Issue #28600: Optimize loop.call_soon().
+
+- Issue #28613: Fix get_event_loop() return the current loop if
+ called from coroutines/callbacks.
+
+- Issue #28639: Fix inspect.isawaitable to always return bool
+ Patch by Justin Mayfield.
+
+- Issue #28652: Make loop methods reject socket kinds they do not support.
+
+- Issue #28653: Fix a refleak in functools.lru_cache.
+
+- Issue #28703: Fix asyncio.iscoroutinefunction to handle Mock objects.
+
+- Issue #24142: Reading a corrupt config file left the parser in an
+ invalid state. Original patch by Florian Höch.
+
+- Issue #28990: Fix SSL hanging if connection is closed before handshake
+ completed.
+ (Patch by HoHo-Ho)
+
+IDLE
+----
+
+- Issue #15308: Add 'interrupt execution' (^C) to Shell menu.
+ Patch by Roger Serwy, updated by Bayard Randel.
+
+- Issue #27922: Stop IDLE tests from 'flashing' gui widgets on the screen.
+
+- Add version to title of IDLE help window.
+
+- Issue #25564: In section on IDLE -- console differences, mention that
+ using exec means that __builtins__ is defined for each statement.
+
+- Issue #27714: text_textview and test_autocomplete now pass when re-run
+ in the same process. This occurs when test_idle fails when run with the
+ -w option but without -jn. Fix warning from test_config.
+
+- Issue #25507: IDLE no longer runs buggy code because of its tkinter imports.
+ Users must include the same imports required to run directly in Python.
+
+- Issue #27452: add line counter and crc to IDLE configHandler test dump.
+
+- Issue #27365: Allow non-ascii chars in IDLE NEWS.txt, for contributor names.
+
+- Issue #27245: IDLE: Cleanly delete custom themes and key bindings.
+ Previously, when IDLE was started from a console or by import, a cascade
+ of warnings was emitted. Patch by Serhiy Storchaka.
+
+C API
+-----
+
+- Issue #28808: PyUnicode_CompareWithASCIIString() now never raises exceptions.
+
+- Issue #26754: PyUnicode_FSDecoder() accepted a filename argument encoded as
+ an iterable of integers. Now only strings and bytes-like objects are accepted.
+
+Documentation
+-------------
+
+- Issue #28513: Documented command-line interface of zipfile.
+
+Tests
+-----
+
+- Issue #28950: Disallow -j0 to be combined with -T/-l/-M in regrtest
+ command line arguments.
+
+- Issue #28666: Now test.support.rmtree is able to remove unwritable or
+ unreadable directories.
+
+- Issue #23839: Various caches now are cleared before running every test file.
+
+- Issue #28409: regrtest: fix the parser of command line arguments.
+
+- Issue #27787: Call gc.collect() before checking each test for "dangling
+ threads", since the dangling threads are weak references.
+
+- Issue #27369: In test_pyexpat, avoid testing an error message detail that
+ changed in Expat 2.2.0.
+
+Tools/Demos
+-----------
+
+- Issue #27952: Get Tools/scripts/fixcid.py working with Python 3 and the
+ current "re" module, avoid invalid Python backslash escapes, and fix a bug
+ parsing escaped C quote signs.
+
+- Issue #27332: Fixed the type of the first argument of module-level functions
+ generated by Argument Clinic. Patch by Petr Viktorin.
+
+- Issue #27418: Fixed Tools/importbench/importbench.py.
+
+Windows
+-------
+
+- Issue #28251: Improvements to help manuals on Windows.
+
+- Issue #28110: launcher.msi has different product codes between 32-bit and
+ 64-bit
+
+- Issue #25144: Ensures TargetDir is set before continuing with custom
+ install.
+
+- Issue #27469: Adds a shell extension to the launcher so that drag and drop
+ works correctly.
+
+- Issue #27309: Enabled proper Windows styles in python[w].exe manifest.
+
+Build
+-----
+
+- Issue #29080: Removes hard dependency on hg.exe from PCBuild/build.bat
+
+- Issue #23903: Added missed names to PC/python3.def.
+
+- Issue #10656: Fix out-of-tree building on AIX. Patch by Tristan Carel and
+ Michael Haubenwallner.
+
+- Issue #26359: Rename --with-optimiations to --enable-optimizations.
+
+- Issue #28444: Fix missing extensions modules when cross compiling.
+
+- Issue #28248: Update Windows build and OS X installers to use OpenSSL 1.0.2j.
+
+- Issue #28258: Fixed build with Estonian locale (python-config and distclean
+ targets in Makefile). Patch by Arfrever Frehtes Taifersar Arahesis.
+
+- Issue #26661: setup.py now detects system libffi with multiarch wrapper.
+
+- Issue #28066: Fix the logic that searches build directories for generated
+ include files when building outside the source tree.
+
+- Issue #15819: Remove redundant include search directory option for building
+ outside the source tree.
+
+- Issue #27566: Fix clean target in freeze makefile (patch by Lisa Roach)
+
+- Issue #27705: Update message in validate_ucrtbase.py
+
+- Issue #27983: Cause lack of llvm-profdata tool when using clang as
+ required for PGO linking to be a configure time error rather than
+ make time when --with-optimizations is enabled. Also improve our
+ ability to find the llvm-profdata tool on MacOS and some Linuxes.
+
+- Issue #26307: The profile-opt build now applies PGO to the built-in modules.
+
+- Issue #26359: Add the --with-optimizations configure flag.
+
+- Issue #27713: Suppress spurious build warnings when updating importlib's
+ bootstrap files. Patch by Xiang Zhang
+
+- Issue #25825: Correct the references to Modules/python.exp and ld_so_aix,
+ which are required on AIX. This updates references to an installation path
+ that was changed in 3.2a4, and undoes changed references to the build tree
+ that were made in 3.5.0a1.
+
+- Issue #27453: CPP invocation in configure must use CPPFLAGS. Patch by
+ Chi Hsuan Yen.
+
+- Issue #27641: The configure script now inserts comments into the makefile
+ to prevent the pgen and _freeze_importlib executables from being cross-
+ compiled.
+
+- Issue #26662: Set PYTHON_FOR_GEN in configure as the Python program to be
+ used for file generation during the build.
+
+- Issue #10910: Avoid C++ compilation errors on FreeBSD and OS X.
+ Also update FreedBSD version checks for the original ctype UTF-8 workaround.
+
+- Issue #28676: Prevent missing 'getentropy' declaration warning on macOS.
+ Patch by Gareth Rees.
+
+
+What's New in Python 3.5.2?
+===========================
+
+Release date: 2016-06-26
+
+Core and Builtins
+-----------------
+
+- Issue #26930: Update Windows builds to use OpenSSL 1.0.2h.
+
+Tests
+-----
+
+- Issue #26867: Ubuntu's openssl OP_NO_SSLv3 is forced on by default; fix test.
+
+IDLE
+----
+
+- Issue #27365: Allow non-ascii in idlelib/NEWS.txt - minimal part for 3.5.2.
+
+
+What's New in Python 3.5.2 release candidate 1?
+===============================================
+
+Release date: 2016-06-12
+
+Core and Builtins
+-----------------
+
+- Issue #27066: Fixed SystemError if a custom opener (for open()) returns a
+ negative number without setting an exception.
+
+- Issue #20041: Fixed TypeError when frame.f_trace is set to None.
+ Patch by Xavier de Gaye.
+
+- Issue #26168: Fixed possible refleaks in failing Py_BuildValue() with the "N"
+ format unit.
+
+- Issue #26991: Fix possible refleak when creating a function with annotations.
+
+- Issue #27039: Fixed bytearray.remove() for values greater than 127. Patch by
+ Joe Jevnik.
+
+- Issue #23640: int.from_bytes() no longer bypasses constructors for subclasses.
+
+- Issue #26811: gc.get_objects() no longer contains a broken tuple with NULL
+ pointer.
+
+- Issue #20120: Use RawConfigParser for .pypirc parsing,
+ removing support for interpolation unintentionally added
+ with move to Python 3. Behavior no longer does any
+ interpolation in .pypirc files, matching behavior in Python
+ 2.7 and Setuptools 19.0.
+
+- Issue #26659: Make the builtin slice type support cycle collection.
+
+- Issue #26718: super.__init__ no longer leaks memory if called multiple times.
+ NOTE: A direct call of super.__init__ is not endorsed!
+
+- Issue #25339: PYTHONIOENCODING now has priority over locale in setting the
+ error handler for stdin and stdout.
+
+- Issue #26494: Fixed crash on iterating exhausting iterators.
+ Affected classes are generic sequence iterators, iterators of str, bytes,
+ bytearray, list, tuple, set, frozenset, dict, OrderedDict, corresponding
+ views and os.scandir() iterator.
+
+- Issue #26581: If coding cookie is specified multiple times on a line in
+ Python source code file, only the first one is taken to account.
+
+- Issue #26464: Fix str.translate() when string is ASCII and first replacements
+ removes character, but next replacement uses a non-ASCII character or a
+ string longer than 1 character. Regression introduced in Python 3.5.0.
+
+- Issue #22836: Ensure exception reports from PyErr_Display() and
+ PyErr_WriteUnraisable() are sensible even when formatting them produces
+ secondary errors. This affects the reports produced by
+ sys.__excepthook__() and when __del__() raises an exception.
+
+- Issue #26302: Correct behavior to reject comma as a legal character for
+ cookie names.
+
+- Issue #4806: Avoid masking the original TypeError exception when using star
+ (*) unpacking in function calls. Based on patch by Hagen Fürstenau and
+ Daniel Urban.
+
+- Issue #27138: Fix the doc comment for FileFinder.find_spec().
+
+- Issue #26154: Add a new private _PyThreadState_UncheckedGet() function to get
+ the current Python thread state, but don't issue a fatal error if it is NULL.
+ This new function must be used instead of accessing directly the
+ _PyThreadState_Current variable. The variable is no more exposed since
+ Python 3.5.1 to hide the exact implementation of atomic C types, to avoid
+ compiler issues.
+
+- Issue #26194: Deque.insert() gave odd results for bounded deques that had
+ reached their maximum size. Now an IndexError will be raised when attempting
+ to insert into a full deque.
+
+- Issue #25843: When compiling code, don't merge constants if they are equal
+ but have a different types. For example, ``f1, f2 = lambda: 1, lambda: 1.0``
+ is now correctly compiled to two different functions: ``f1()`` returns ``1``
+ (``int``) and ``f2()`` returns ``1.0`` (``int``), even if ``1`` and ``1.0``
+ are equal.
+
+- Issue #22995: [UPDATE] Comment out the one of the pickleability tests in
+ _PyObject_GetState() due to regressions observed in Cython-based projects.
+
+- Issue #25961: Disallowed null characters in the type name.
+
+- Issue #25973: Fix segfault when an invalid nonlocal statement binds a name
+ starting with two underscores.
+
+- Issue #22995: Instances of extension types with a state that aren't
+ subclasses of list or dict and haven't implemented any pickle-related
+ methods (__reduce__, __reduce_ex__, __getnewargs__, __getnewargs_ex__,
+ or __getstate__), can no longer be pickled. Including memoryview.
+
+- Issue #20440: Massive replacing unsafe attribute setting code with special
+ macro Py_SETREF.
+
+- Issue #25766: Special method __bytes__() now works in str subclasses.
+
+- Issue #25421: __sizeof__ methods of builtin types now use dynamic basic size.
+ This allows sys.getsize() to work correctly with their subclasses with
+ __slots__ defined.
+
+- Issue #25709: Fixed problem with in-place string concatenation and utf-8
+ cache.
+
+- Issue #27147: Mention PEP 420 in the importlib docs.
+
+- Issue #24097: Fixed crash in object.__reduce__() if slot name is freed inside
+ __getattr__.
+
+- Issue #24731: Fixed crash on converting objects with special methods
+ __bytes__, __trunc__, and __float__ returning instances of subclasses of
+ bytes, int, and float to subclasses of bytes, int, and float correspondingly.
+
+- Issue #26478: Fix semantic bugs when using binary operators with dictionary
+ views and tuples.
+
+- Issue #26171: Fix possible integer overflow and heap corruption in
+ zipimporter.get_data().
+
+- Issue #25660: Fix TAB key behaviour in REPL with readline.
+
+- Issue #25887: Raise a RuntimeError when a coroutine object is awaited
+ more than once.
+
+- Issue #27243: Update the __aiter__ protocol: instead of returning
+ an awaitable that resolves to an asynchronous iterator, the asynchronous
+ iterator should be returned directly. Doing the former will trigger a
+ PendingDeprecationWarning.
+
+
+Library
+-------
+
+- [Security] Issue #26556: Update expat to 2.1.1, fixes CVE-2015-1283.
+
+- [Security] Fix TLS stripping vulnerability in smtplib, CVE-2016-0772.
+ Reported by Team Oststrom
+
+- Issue #21386: Implement missing IPv4Address.is_global property. It was
+ documented since 07a5610bae9d. Initial patch by Roger Luethi.
+
+- Issue #20900: distutils register command now decodes HTTP responses
+ correctly. Initial patch by ingrid.
+
+- A new version of typing.py provides several new classes and
+ features: @overload outside stubs, Reversible, DefaultDict, Text,
+ ContextManager, Type[], NewType(), TYPE_CHECKING, and numerous bug
+ fixes (note that some of the new features are not yet implemented in
+ mypy or other static analyzers). Also classes for PEP 492
+ (Awaitable, AsyncIterable, AsyncIterator) have been added (in fact
+ they made it into 3.5.1 but were never mentioned).
+
+- Issue #25738: Stop http.server.BaseHTTPRequestHandler.send_error() from
+ sending a message body for 205 Reset Content. Also, don't send Content
+ header fields in responses that don't have a body. Patch by Susumu
+ Koshiba.
+
+- Issue #21313: Fix the "platform" module to tolerate when sys.version
+ contains truncated build information.
+
+- [Security] Issue #26839: On Linux, :func:`os.urandom` now calls
+ ``getrandom()`` with ``GRND_NONBLOCK`` to fall back on reading
+ ``/dev/urandom`` if the urandom entropy pool is not initialized yet. Patch
+ written by Colm Buckley.
+
+- Issue #27164: In the zlib module, allow decompressing raw Deflate streams
+ with a predefined zdict. Based on patch by Xiang Zhang.
+
+- Issue #24291: Fix wsgiref.simple_server.WSGIRequestHandler to completely
+ write data to the client. Previously it could do partial writes and
+ truncate data. Also, wsgiref.handler.ServerHandler can now handle stdout
+ doing partial writes, but this is deprecated.
+
+- Issue #26809: Add ``__all__`` to :mod:`string`. Patch by Emanuel Barry.
+
+- Issue #26373: subprocess.Popen.communicate now correctly ignores
+ BrokenPipeError when the child process dies before .communicate()
+ is called in more/all circumstances.
+
+- Issue #21776: distutils.upload now correctly handles HTTPError.
+ Initial patch by Claudiu Popa.
+
+- Issue #27114: Fix SSLContext._load_windows_store_certs fails with
+ PermissionError
+
+- Issue #18383: Avoid creating duplicate filters when using filterwarnings
+ and simplefilter. Based on patch by Alex Shkop.
+
+- Issue #27057: Fix os.set_inheritable() on Android, ioctl() is blocked by
+ SELinux and fails with EACCESS. The function now falls back to fcntl().
+ Patch written by Michał Bednarski.
+
+- Issue #27014: Fix infinite recursion using typing.py. Thanks to Kalle Tuure!
+
+- Issue #14132: Fix urllib.request redirect handling when the target only has
+ a query string. Original fix by Ján Janech.
+
+- Issue #17214: The "urllib.request" module now percent-encodes non-ASCII
+ bytes found in redirect target URLs. Some servers send Location header
+ fields with non-ASCII bytes, but "http.client" requires the request target
+ to be ASCII-encodable, otherwise a UnicodeEncodeError is raised. Based on
+ patch by Christian Heimes.
+
+- Issue #26892: Honor debuglevel flag in urllib.request.HTTPHandler. Patch
+ contributed by Chi Hsuan Yen.
+
+- Issue #22274: In the subprocess module, allow stderr to be redirected to
+ stdout even when stdout is not redirected. Patch by Akira Li.
+
+- Issue #26807: mock_open 'files' no longer error on readline at end of file.
+ Patch from Yolanda Robla.
+
+- Issue #25745: Fixed leaking a userptr in curses panel destructor.
+
+- Issue #26977: Removed unnecessary, and ignored, call to sum of squares helper
+ in statistics.pvariance.
+
+- Issue #26881: The modulefinder module now supports extended opcode arguments.
+
+- Issue #23815: Fixed crashes related to directly created instances of types in
+ _tkinter and curses.panel modules.
+
+- Issue #17765: weakref.ref() no longer silently ignores keyword arguments.
+ Patch by Georg Brandl.
+
+- Issue #26873: xmlrpc now raises ResponseError on unsupported type tags
+ instead of silently return incorrect result.
+
+- Issue #26711: Fixed the comparison of plistlib.Data with other types.
+
+- Issue #24114: Fix an uninitialized variable in `ctypes.util`.
+
+ The bug only occurs on SunOS when the ctypes implementation searches
+ for the `crle` program. Patch by Xiang Zhang. Tested on SunOS by
+ Kees Bos.
+
+- Issue #26864: In urllib.request, change the proxy bypass host checking
+ against no_proxy to be case-insensitive, and to not match unrelated host
+ names that happen to have a bypassed hostname as a suffix. Patch by Xiang
+ Zhang.
+
+- Issue #26634: recursive_repr() now sets __qualname__ of wrapper. Patch by
+ Xiang Zhang.
+
+- Issue #26804: urllib.request will prefer lower_case proxy environment
+ variables over UPPER_CASE or Mixed_Case ones. Patch contributed by Hans-Peter
+ Jansen.
+
+- Issue #26837: assertSequenceEqual() now correctly outputs non-stringified
+ differing items (like bytes in the -b mode). This affects assertListEqual()
+ and assertTupleEqual().
+
+- Issue #26041: Remove "will be removed in Python 3.7" from deprecation
+ messages of platform.dist() and platform.linux_distribution().
+ Patch by Kumaripaba Miyurusara Athukorala.
+
+- Issue #26822: itemgetter, attrgetter and methodcaller objects no longer
+ silently ignore keyword arguments.
+
+- Issue #26733: Disassembling a class now disassembles class and static methods.
+ Patch by Xiang Zhang.
+
+- Issue #26801: Fix error handling in :func:`shutil.get_terminal_size`, catch
+ :exc:`AttributeError` instead of :exc:`NameError`. Patch written by Emanuel
+ Barry.
+
+- Issue #24838: tarfile's ustar and gnu formats now correctly calculate name
+ and link field limits for multibyte character encodings like utf-8.
+
+- [Security] Issue #26657: Fix directory traversal vulnerability with
+ http.server on Windows. This fixes a regression that was introduced in
+ 3.3.4rc1 and 3.4.0rc1. Based on patch by Philipp Hagemeister.
+
+- Issue #26717: Stop encoding Latin-1-ized WSGI paths with UTF-8. Patch by
+ Anthony Sottile.
+
+- Issue #26735: Fix :func:`os.urandom` on Solaris 11.3 and newer when reading
+ more than 1,024 bytes: call ``getrandom()`` multiple times with a limit of
+ 1024 bytes per call.
+
+- Issue #16329: Add .webm to mimetypes.types_map. Patch by Giampaolo Rodola'.
+
+- Issue #13952: Add .csv to mimetypes.types_map. Patch by Geoff Wilson.
+
+- Issue #26709: Fixed Y2038 problem in loading binary PLists.
+
+- Issue #23735: Handle terminal resizing with Readline 6.3+ by installing our
+ own SIGWINCH handler. Patch by Eric Price.
+
+- Issue #26586: In http.server, respond with "413 Request header fields too
+ large" if there are too many header fields to parse, rather than killing
+ the connection and raising an unhandled exception. Patch by Xiang Zhang.
+
+- Issue #22854: Change BufferedReader.writable() and
+ BufferedWriter.readable() to always return False.
+
+- Issue #25195: Fix a regression in mock.MagicMock. _Call is a subclass of
+ tuple (changeset 3603bae63c13 only works for classes) so we need to
+ implement __ne__ ourselves. Patch by Andrew Plummer.
+
+- Issue #26644: Raise ValueError rather than SystemError when a negative
+ length is passed to SSLSocket.recv() or read().
+
+- Issue #23804: Fix SSL recv(0) and read(0) methods to return zero bytes
+ instead of up to 1024.
+
+- Issue #26616: Fixed a bug in datetime.astimezone() method.
+
+- Issue #21925: :func:`warnings.formatwarning` now catches exceptions on
+ ``linecache.getline(...)`` to be able to log :exc:`ResourceWarning` emitted
+ late during the Python shutdown process.
+
+- Issue #24266: Ctrl+C during Readline history search now cancels the search
+ mode when compiled with Readline 7.
+
+- Issue #26560: Avoid potential ValueError in BaseHandler.start_response.
+ Initial patch by Peter Inglesby.
+
+- [Security] Issue #26313: ssl.py _load_windows_store_certs fails if windows
+ cert store is empty. Patch by Baji.
+
+- Issue #26569: Fix :func:`pyclbr.readmodule` and :func:`pyclbr.readmodule_ex`
+ to support importing packages.
+
+- Issue #26499: Account for remaining Content-Length in
+ HTTPResponse.readline() and read1(). Based on patch by Silent Ghost.
+ Also document that HTTPResponse now supports these methods.
+
+- Issue #25320: Handle sockets in directories unittest discovery is scanning.
+ Patch from Victor van den Elzen.
+
+- Issue #16181: cookiejar.http2time() now returns None if year is higher than
+ datetime.MAXYEAR.
+
+- Issue #26513: Fixes platform module detection of Windows Server
+
+- Issue #23718: Fixed parsing time in week 0 before Jan 1. Original patch by
+ Tamás Bence Gedai.
+
+- Issue #20589: Invoking Path.owner() and Path.group() on Windows now raise
+ NotImplementedError instead of ImportError.
+
+- Issue #26177: Fixed the keys() method for Canvas and Scrollbar widgets.
+
+- Issue #15068: Got rid of excessive buffering in the fileinput module.
+ The bufsize parameter is no longer used.
+
+- Issue #2202: Fix UnboundLocalError in
+ AbstractDigestAuthHandler.get_algorithm_impls. Initial patch by Mathieu
+ Dupuy.
+
+- Issue #25718: Fixed pickling and copying the accumulate() iterator with
+ total is None.
+
+- Issue #26475: Fixed debugging output for regular expressions with the (?x)
+ flag.
+
+- Issue #26457: Fixed the subnets() methods in IP network classes for the case
+ when resulting prefix length is equal to maximal prefix length.
+ Based on patch by Xiang Zhang.
+
+- Issue #26385: Remove the file if the internal open() call in
+ NamedTemporaryFile() fails. Patch by Silent Ghost.
+
+- Issue #26402: Fix XML-RPC client to retry when the server shuts down a
+ persistent connection. This was a regression related to the new
+ http.client.RemoteDisconnected exception in 3.5.0a4.
+
+- Issue #25913: Leading ``<~`` is optional now in base64.a85decode() with
+ adobe=True. Patch by Swati Jaiswal.
+
+- Issue #26186: Remove an invalid type check in importlib.util.LazyLoader.
+
+- Issue #26367: importlib.__import__() raises SystemError like
+ builtins.__import__() when ``level`` is specified but without an accompanying
+ package specified.
+
+- Issue #26309: In the "socketserver" module, shut down the request (closing
+ the connected socket) when verify_request() returns false. Patch by Aviv
+ Palivoda.
+
+- [Security] Issue #25939: On Windows open the cert store readonly in
+ ssl.enum_certificates.
+
+- Issue #25995: os.walk() no longer uses FDs proportional to the tree depth.
+
+- Issue #26117: The os.scandir() iterator now closes file descriptor not only
+ when the iteration is finished, but when it was failed with error.
+
+- Issue #25911: Restored support of bytes paths in os.walk() on Windows.
+
+- Issue #26045: Add UTF-8 suggestion to error message when posting a
+ non-Latin-1 string with http.client.
+
+- Issue #12923: Reset FancyURLopener's redirect counter even if there is an
+ exception. Based on patches by Brian Brazil and Daniel Rocco.
+
+- Issue #25945: Fixed a crash when unpickle the functools.partial object with
+ wrong state. Fixed a leak in failed functools.partial constructor.
+ "args" and "keywords" attributes of functools.partial have now always types
+ tuple and dict correspondingly.
+
+- Issue #26202: copy.deepcopy() now correctly copies range() objects with
+ non-atomic attributes.
+
+- Issue #23076: Path.glob() now raises a ValueError if it's called with an
+ invalid pattern. Patch by Thomas Nyberg.
+
+- Issue #19883: Fixed possible integer overflows in zipimport.
+
+- Issue #26227: On Windows, getnameinfo(), gethostbyaddr() and
+ gethostbyname_ex() functions of the socket module now decode the hostname
+ from the ANSI code page rather than UTF-8.
+
+- Issue #26147: xmlrpc now works with strings not encodable with used
+ non-UTF-8 encoding.
+
+- Issue #25935: Garbage collector now breaks reference loops with OrderedDict.
+
+- Issue #16620: Fixed AttributeError in msilib.Directory.glob().
+
+- Issue #26013: Added compatibility with broken protocol 2 pickles created
+ in old Python 3 versions (3.4.3 and lower).
+
+- Issue #25850: Use cross-compilation by default for 64-bit Windows.
+
+- Issue #17633: Improve zipimport's support for namespace packages.
+
+- Issue #24705: Fix sysconfig._parse_makefile not expanding ${} vars
+ appearing before $() vars.
+
+- Issue #22138: Fix mock.patch behavior when patching descriptors. Restore
+ original values after patching. Patch contributed by Sean McCully.
+
+- Issue #25672: In the ssl module, enable the SSL_MODE_RELEASE_BUFFERS mode
+ option if it is safe to do so.
+
+- Issue #26012: Don't traverse into symlinks for ** pattern in
+ pathlib.Path.[r]glob().
+
+- Issue #24120: Ignore PermissionError when traversing a tree with
+ pathlib.Path.[r]glob(). Patch by Ulrich Petri.
+
+- Issue #25447: fileinput now uses sys.stdin as-is if it does not have a
+ buffer attribute (restores backward compatibility).
+
+- Issue #25447: Copying the lru_cache() wrapper object now always works,
+ independedly from the type of the wrapped object (by returning the original
+ object unchanged).
+
+- Issue #24103: Fixed possible use after free in ElementTree.XMLPullParser.
+
+- Issue #25860: os.fwalk() no longer skips remaining directories when error
+ occurs. Original patch by Samson Lee.
+
+- Issue #25914: Fixed and simplified OrderedDict.__sizeof__.
+
+- Issue #25902: Fixed various refcount issues in ElementTree iteration.
+
+- Issue #25717: Restore the previous behaviour of tolerating most fstat()
+ errors when opening files. This was a regression in 3.5a1, and stopped
+ anonymous temporary files from working in special cases.
+
+- Issue #24903: Fix regression in number of arguments compileall accepts when
+ '-d' is specified. The check on the number of arguments has been dropped
+ completely as it never worked correctly anyway.
+
+- Issue #25764: In the subprocess module, preserve any exception caused by
+ fork() failure when preexec_fn is used.
+
+- Issue #6478: _strptime's regexp cache now is reset after changing timezone
+ with time.tzset().
+
+- Issue #14285: When executing a package with the "python -m package" option,
+ and package initialization fails, a proper traceback is now reported. The
+ "runpy" module now lets exceptions from package initialization pass back to
+ the caller, rather than raising ImportError.
+
+- Issue #19771: Also in runpy and the "-m" option, omit the irrelevant
+ message ". . . is a package and cannot be directly executed" if the package
+ could not even be initialized (e.g. due to a bad ``*.pyc`` file).
+
+- Issue #25177: Fixed problem with the mean of very small and very large
+ numbers. As a side effect, statistics.mean and statistics.variance should
+ be significantly faster.
+
+- Issue #25718: Fixed copying object with state with boolean value is false.
+
+- Issue #10131: Fixed deep copying of minidom documents. Based on patch
+ by Marian Ganisin.
+
+- Issue #25725: Fixed a reference leak in pickle.loads() when unpickling
+ invalid data including tuple instructions.
+
+- Issue #25663: In the Readline completer, avoid listing duplicate global
+ names, and search the global namespace before searching builtins.
+
+- Issue #25688: Fixed file leak in ElementTree.iterparse() raising an error.
+
+- Issue #23914: Fixed SystemError raised by unpickler on broken pickle data.
+
+- Issue #25691: Fixed crash on deleting ElementTree.Element attributes.
+
+- Issue #25624: ZipFile now always writes a ZIP_STORED header for directory
+ entries. Patch by Dingyuan Wang.
+
+- Skip getaddrinfo if host is already resolved.
+ Patch by A. Jesse Jiryu Davis.
+
+- Issue #26050: Add asyncio.StreamReader.readuntil() method.
+ Patch by Марк Коренберг.
+
+- Issue #25924: Avoid unnecessary serialization of getaddrinfo(3) calls on
+ OS X versions 10.5 or higher. Original patch by A. Jesse Jiryu Davis.
+
+- Issue #26406: Avoid unnecessary serialization of getaddrinfo(3) calls on
+ current versions of OpenBSD and NetBSD. Patch by A. Jesse Jiryu Davis.
+
+- Issue #26848: Fix asyncio/subprocess.communicate() to handle empty input.
+ Patch by Jack O'Connor.
+
+- Issue #27040: Add loop.get_exception_handler method
+
+- Issue #27041: asyncio: Add loop.create_future method
+
+- Issue #27223: asyncio: Fix _read_ready and _write_ready to respect
+ _conn_lost.
+ Patch by Łukasz Langa.
+
+- Issue #22970: asyncio: Fix inconsistency cancelling Condition.wait.
+ Patch by David Coles.
+
+IDLE
+----
+
+- Issue #5124: Paste with text selected now replaces the selection on X11.
+ This matches how paste works on Windows, Mac, most modern Linux apps,
+ and ttk widgets. Original patch by Serhiy Storchaka.
+
+- Issue #24759: Make clear in idlelib.idle_test.__init__ that the directory
+ is a private implementation of test.test_idle and tool for maintainers.
+
+- Issue #27196: Stop 'ThemeChanged' warnings when running IDLE tests.
+ These persisted after other warnings were suppressed in #20567.
+ Apply Serhiy Storchaka's update_idletasks solution to four test files.
+ Record this additional advice in idle_test/README.txt
+
+- Issue #20567: Revise idle_test/README.txt with advice about avoiding
+ tk warning messages from tests. Apply advice to several IDLE tests.
+
+- Issue #27117: Make colorizer htest and turtledemo work with dark themes.
+ Move code for configuring text widget colors to a new function.
+
+- Issue #26673: When tk reports font size as 0, change to size 10.
+ Such fonts on Linux prevented the configuration dialog from opening.
+
+- Issue #21939: Add test for IDLE's percolator.
+ Original patch by Saimadhav Heblikar.
+
+- Issue #21676: Add test for IDLE's replace dialog.
+ Original patch by Saimadhav Heblikar.
+
+- Issue #18410: Add test for IDLE's search dialog.
+ Original patch by Westley Martínez.
+
+- Issue #21703: Add test for IDLE's undo delegator.
+ Original patch by Saimadhav Heblikar .
+
+- Issue #27044: Add ConfigDialog.remove_var_callbacks to stop memory leaks.
+
+- Issue #23977: Add more asserts to test_delegator.
+
+- Issue #20640: Add tests for idlelib.configHelpSourceEdit.
+ Patch by Saimadhav Heblikar.
+
+- In the 'IDLE-console differences' section of the IDLE doc, clarify
+ how running with IDLE affects sys.modules and the standard streams.
+
+- Issue #25507: fix incorrect change in IOBinding that prevented printing.
+ Augment IOBinding htest to include all major IOBinding functions.
+
+- Issue #25905: Revert unwanted conversion of ' to ’ RIGHT SINGLE QUOTATION
+ MARK in README.txt and open this and NEWS.txt with 'ascii'.
+ Re-encode CREDITS.txt to utf-8 and open it with 'utf-8'.
+
+Documentation
+-------------
+
+- Issue #19489: Moved the search box from the sidebar to the header and footer
+ of each page. Patch by Ammar Askar.
+
+- Issue #24136: Document the new PEP 448 unpacking syntax of 3.5.
+
+- Issue #26736: Used HTTPS for external links in the documentation if possible.
+
+- Issue #6953: Rework the Readline module documentation to group related
+ functions together, and add more details such as what underlying Readline
+ functions and variables are accessed.
+
+- Issue #23606: Adds note to ctypes documentation regarding cdll.msvcrt.
+
+- Issue #25500: Fix documentation to not claim that __import__ is searched for
+ in the global scope.
+
+- Issue #26014: Update 3.x packaging documentation:
+ * "See also" links to the new docs are now provided in the legacy pages
+ * links to setuptools documentation have been updated
+
+Tests
+-----
+
+- Issue #21916: Added tests for the turtle module. Patch by ingrid,
+ Gregory Loyse and Jelle Zijlstra.
+
+- Issue #26523: The multiprocessing thread pool (multiprocessing.dummy.Pool)
+ was untested.
+
+- Issue #26015: Added new tests for pickling iterators of mutable sequences.
+
+- Issue #26325: Added test.support.check_no_resource_warning() to check that
+ no ResourceWarning is emitted.
+
+- Issue #25940: Changed test_ssl to use self-signed.pythontest.net. This
+ avoids relying on svn.python.org, which recently changed root certificate.
+
+- Issue #25616: Tests for OrderedDict are extracted from test_collections
+ into separate file test_ordered_dict.
+
+- Issue #26583: Skip test_timestamp_overflow in test_import if bytecode
+ files cannot be written.
+
+Build
+-----
+
+- Issue #26884: Fix linking extension modules for cross builds.
+ Patch by Xavier de Gaye.
+
+- Issue #22359: Disable the rules for running _freeze_importlib and pgen when
+ cross-compiling. The output of these programs is normally saved with the
+ source code anyway, and is still regenerated when doing a native build.
+ Patch by Xavier de Gaye.
+
+- Issue #27229: Fix the cross-compiling pgen rule for in-tree builds. Patch
+ by Xavier de Gaye.
+
+- Issue #21668: Link audioop, _datetime, _ctypes_test modules to libm,
+ except on Mac OS X. Patch written by Xavier de Gaye.
+
+- Issue #25702: A --with-lto configure option has been added that will
+ enable link time optimizations at build time during a make profile-opt.
+ Some compilers and toolchains are known to not produce stable code when
+ using LTO, be sure to test things thoroughly before relying on it.
+ It can provide a few % speed up over profile-opt alone.
+
+- Issue #26624: Adds validation of ucrtbase[d].dll version with warning
+ for old versions.
+
+- Issue #17603: Avoid error about nonexistant fileblocks.o file by using a
+ lower-level check for st_blocks in struct stat.
+
+- Issue #26079: Fixing the build output folder for tix-8.4.3.6. Patch by
+ Bjoern Thiel.
+
+- Issue #26465: Update Windows builds to use OpenSSL 1.0.2g.
+
+- Issue #24421: Compile Modules/_math.c once, before building extensions.
+ Previously it could fail to compile properly if the math and cmath builds
+ were concurrent.
+
+- Issue #25348: Added ``--pgo`` and ``--pgo-job`` arguments to
+ ``PCbuild\build.bat`` for building with Profile-Guided Optimization. The
+ old ``PCbuild\build_pgo.bat`` script is now deprecated, and simply calls
+ ``PCbuild\build.bat --pgo %*``.
+
+- Issue #25827: Add support for building with ICC to ``configure``, including
+ a new ``--with-icc`` flag.
+
+- Issue #25696: Fix installation of Python on UNIX with make -j9.
+
+- Issue #26930: Update OS X 10.5+ 32-bit-only installer to build
+ and link with OpenSSL 1.0.2h.
+
+- Issue #26268: Update Windows builds to use OpenSSL 1.0.2f.
+
+- Issue #25136: Support Apple Xcode 7's new textual SDK stub libraries.
+
+- Issue #24324: Do not enable unreachable code warnings when using
+ gcc as the option does not work correctly in older versions of gcc
+ and has been silently removed as of gcc-4.5.
+
+Windows
+-------
+
+- Issue #27053: Updates make_zip.py to correctly generate library ZIP file.
+
+- Issue #26268: Update the prepare_ssl.py script to handle OpenSSL releases
+ that don't include the contents of the include directory (that is, 1.0.2e
+ and later).
+
+- Issue #26071: bdist_wininst created binaries fail to start and find
+ 32bit Python
+
+- Issue #26073: Update the list of magic numbers in launcher
+
+- Issue #26065: Excludes venv from library when generating embeddable
+ distro.
+
+Tools/Demos
+-----------
+
+- Issue #26799: Fix python-gdb.py: don't get C types once when the Python code
+ is loaded, but get C types on demand. The C types can change if
+ python-gdb.py is loaded before the Python executable. Patch written by Thomas
+ Ilsche.
+
+- Issue #26271: Fix the Freeze tool to properly use flags passed through
+ configure. Patch by Daniel Shaulov.
+
+- Issue #26489: Add dictionary unpacking support to Tools/parser/unparse.py.
+ Patch by Guo Ci Teo.
+
+- Issue #26316: Fix variable name typo in Argument Clinic.
+
+Misc
+----
+
+- Issue #17500, and https://github.com/python/pythondotorg/issues/945: Remove
+ unused and outdated icons.
+
+
+What's New in Python 3.5.1 final?
+=================================
+
+Release date: 2015-12-06
+
+Core and Builtins
+-----------------
+
+- Issue #25709: Fixed problem with in-place string concatenation and
+ utf-8 cache.
+
+Windows
+-------
+
+- Issue #25715: Python 3.5.1 installer shows wrong upgrade path and incorrect
+ logic for launcher detection.
+
+
+What's New in Python 3.5.1 release candidate 1?
+===============================================
+
+Release date: 2015-11-22
+
+Core and Builtins
+-----------------
+
+- Issue #25630: Fix a possible segfault during argument parsing in functions
+ that accept filesystem paths.
+
+- Issue #23564: Fixed a partially broken sanity check in the _posixsubprocess
+ internals regarding how fds_to_pass were passed to the child. The bug had
+ no actual impact as subprocess.py already avoided it.
+
+- Issue #25388: Fixed tokenizer crash when processing undecodable source code
+ with a null byte.
+
+- Issue #25462: The hash of the key now is calculated only once in most
+ operations in C implementation of OrderedDict.
+
+- Issue #22995: Default implementation of __reduce__ and __reduce_ex__ now
+ rejects builtin types with not defined __new__.
+
+- Issue #25555: Fix parser and AST: fill lineno and col_offset of "arg" node
+ when compiling AST from Python objects.
+
+- Issue #24802: Avoid buffer overreads when int(), float(), compile(), exec()
+ and eval() are passed bytes-like objects. These objects are not
+ necessarily terminated by a null byte, but the functions assumed they were.
+
+- Issue #24726: Fixed a crash and leaking NULL in repr() of OrderedDict that
+ was mutated by direct calls of dict methods.
+
+- Issue #25449: Iterating OrderedDict with keys with unstable hash now raises
+ KeyError in C implementations as well as in Python implementation.
+
+- Issue #25395: Fixed crash when highly nested OrderedDict structures were
+ garbage collected.
+
+- Issue #25274: sys.setrecursionlimit() now raises a RecursionError if the new
+ recursion limit is too low depending at the current recursion depth. Modify
+ also the "lower-water mark" formula to make it monotonic. This mark is used
+ to decide when the overflowed flag of the thread state is reset.
+
+- Issue #24402: Fix input() to prompt to the redirected stdout when
+ sys.stdout.fileno() fails.
+
+- Issue #24806: Prevent builtin types that are not allowed to be subclassed from
+ being subclassed through multiple inheritance.
+
+- Issue #24848: Fixed a number of bugs in UTF-7 decoding of misformed data.
+
+- Issue #25280: Import trace messages emitted in verbose (-v) mode are no
+ longer formatted twice.
+
+- Issue #25003: On Solaris 11.3 or newer, os.urandom() now uses the
+ getrandom() function instead of the getentropy() function. The getentropy()
+ function is blocking to generate very good quality entropy, os.urandom()
+ doesn't need such high-quality entropy.
+
+- Issue #25182: The stdprinter (used as sys.stderr before the io module is
+ imported at startup) now uses the backslashreplace error handler.
+
+- Issue #25131: Make the line number and column offset of set/dict literals and
+ comprehensions correspond to the opening brace.
+
+- Issue #25150: Hide the private _Py_atomic_xxx symbols from the public
+ Python.h header to fix a compilation error with OpenMP. PyThreadState_GET()
+ becomes an alias to PyThreadState_Get() to avoid ABI incompatibilies.
+
+Library
+-------
+
+- Issue #25626: Change three zlib functions to accept sizes that fit in
+ Py_ssize_t, but internally cap those sizes to UINT_MAX. This resolves a
+ regression in 3.5 where GzipFile.read() failed to read chunks larger than 2
+ or 4 GiB. The change affects the zlib.Decompress.decompress() max_length
+ parameter, the zlib.decompress() bufsize parameter, and the
+ zlib.Decompress.flush() length parameter.
+
+- Issue #25583: Avoid incorrect errors raised by os.makedirs(exist_ok=True)
+ when the OS gives priority to errors such as EACCES over EEXIST.
+
+- Issue #25593: Change semantics of EventLoop.stop() in asyncio.
+
+- Issue #6973: When we know a subprocess.Popen process has died, do
+ not allow the send_signal(), terminate(), or kill() methods to do
+ anything as they could potentially signal a different process.
+
+- Issue #25590: In the Readline completer, only call getattr() once per
+ attribute.
+
+- Issue #25498: Fix a crash when garbage-collecting ctypes objects created
+ by wrapping a memoryview. This was a regression made in 3.5a1. Based
+ on patch by Eryksun.
+
+- Issue #25584: Added "escape" to the __all__ list in the glob module.
- Issue #25584: Fixed recursive glob() with patterns starting with '\*\*'.
Documentation
-------------
+- Issue #22558: Add remaining doc links to source code for Python-coded modules.
+ Patch by Yoni Lavi.
+
- Issue #12067: Rewrite Comparisons section in the Expressions chapter of the
language reference. Some of the details of comparing mixed types were
incorrect or ambiguous. NotImplemented is only relevant at a lower level
- Issue #24631: Fixed regression in the timeit module with multiline setup.
+- Issue #18622: unittest.mock.mock_open().reset_mock would recurse infinitely.
+ Patch from Nicola Palumbo and Laurent De Buyst.
+
+- Issue #23661: unittest.mock side_effects can now be exceptions again. This
+ was a regression vs Python 3.4. Patch from Ignacio Rossi
+
- Issue #24608: chunk.Chunk.read() now always returns bytes, not str.
- Issue #18684: Fixed reading out of the buffer in the re module.
- Issue #15014: SMTP.auth() and SMTP.login() now support RFC 4954's optional
initial-response argument to the SMTP AUTH command.
-- Issue #6549: Remove hyphen from ttk.Style().element options. Only return result
- from ttk.Style().configure if a result was generated or a query submitted.
-
- Issue #24669: Fix inspect.getsource() for 'async def' functions.
Patch by Kai Groner.
- Issue #24603: Update Windows builds and OS X 10.5 installer to use OpenSSL
1.0.2d.
+
What's New in Python 3.5.0 beta 3?
==================================
- Issue #24268: PEP 489: Multi-phase extension module initialization.
Patch by Petr Viktorin.
-- Issue #23359: Optimize set object internals by specializing the
- hash table search into a lookup function and an insert function.
-
- Issue #23955: Add pyvenv.cfg option to suppress registry/environment
lookup for generating sys.path on Windows.
- Issue #1322: platform.dist() and platform.linux_distribution() functions are
now deprecated. Initial patch by Vajrasky Kok.
-- Issue #22486: Added the math.gcd() function. The fractions.gcd() function now is
- deprecated. Based on patch by Mark Dickinson.
+- Issue #22486: Added the math.gcd() function. The fractions.gcd() function
+ now is deprecated. Based on patch by Mark Dickinson.
- Issue #24064: Property() docstrings are now writeable.
(Patch by Berker Peksag.)
writer failed in BufferedRWPair.close().
- Issue #23622: Unknown escapes in regular expressions that consist of ``'\'``
- and an ASCII letter now raise a deprecation warning and will be forbidden
- in Python 3.6.
+ and ASCII letter now raise a deprecation warning and will be forbidden in
+ Python 3.6.
- Issue #23671: string.Template now allows specifying the "self" parameter as
a keyword argument. string.Formatter now allows specifying the "self" and
return NULL;
}
- for (i = 0; i < len; i++) {
+ for (i = 0; i < PyList_GET_SIZE(self->fut_callbacks); i++) {
int ret;
PyObject *item = PyList_GET_ITEM(self->fut_callbacks, i);
return -1;
}
- res = _PyObject_CallMethodId(all_tasks, &PyId_add, "O", self, NULL);
+ res = _PyObject_CallMethodIdObjArgs(all_tasks, &PyId_add, self, NULL);
if (res == NULL) {
return -1;
}
@classmethod
_asyncio.Task.current_task
- loop: 'O' = NULL
+ loop: 'O' = None
Return the currently running task in an event loop or None.
static PyObject *
_asyncio_Task_current_task_impl(PyTypeObject *type, PyObject *loop)
-/*[clinic end generated code: output=99fbe7332c516e03 input=cd784537f02cf833]*/
+/*[clinic end generated code: output=99fbe7332c516e03 input=a0d6cdf2e3b243e1]*/
{
PyObject *res;
- if (loop == NULL) {
- loop = PyObject_CallObject(asyncio_get_event_loop, NULL);
+ if (loop == Py_None) {
+ loop = _PyObject_CallNoArg(asyncio_get_event_loop);
if (loop == NULL) {
return NULL;
}
@classmethod
_asyncio.Task.all_tasks
- loop: 'O' = NULL
+ loop: 'O' = None
Return a set of all tasks for an event loop.
static PyObject *
_asyncio_Task_all_tasks_impl(PyTypeObject *type, PyObject *loop)
-/*[clinic end generated code: output=11f9b20749ccca5d input=cd64aa5f88bd5c49]*/
+/*[clinic end generated code: output=11f9b20749ccca5d input=c6f5b53bd487488f]*/
{
PyObject *res;
- if (loop == NULL) {
- loop = PyObject_CallObject(asyncio_get_event_loop, NULL);
+ if (loop == Py_None) {
+ loop = _PyObject_CallNoArg(asyncio_get_event_loop);
if (loop == NULL) {
return NULL;
}
}
else {
/* `task` is a subclass of Task */
- return _PyObject_CallMethodId(
- (PyObject*)task, &PyId__wakeup, "O", fut, NULL);
+ return _PyObject_CallMethodIdObjArgs((PyObject*)task, &PyId__wakeup,
+ fut, NULL);
}
}
if (arg == NULL) {
arg = Py_None;
}
- return _PyObject_CallMethodId(
- (PyObject*)task, &PyId__step, "O", arg, NULL);
+ return _PyObject_CallMethodIdObjArgs((PyObject*)task, &PyId__step,
+ arg, NULL);
}
}
return -1;
}
- handle = _PyObject_CallMethodId(
- task->task_loop, &PyId_call_soon, "O", cb, NULL);
+ handle = _PyObject_CallMethodIdObjArgs(task->task_loop, &PyId_call_soon,
+ cb, NULL);
Py_DECREF(cb);
if (handle == NULL) {
return -1;
if (wrapper == NULL) {
goto fail;
}
- res = _PyObject_CallMethodId(
- result, &PyId_add_done_callback, "O", wrapper, NULL);
+ res = _PyObject_CallMethodIdObjArgs(result,
+ &PyId_add_done_callback,
+ wrapper, NULL);
Py_DECREF(wrapper);
if (res == NULL) {
goto fail;
PyDoc_STRVAR(_count_elements_doc,
"_count_elements(mapping, iterable) -> None\n\
\n\
-Count elements in the iterable, updating the mappping");
+Count elements in the iterable, updating the mapping");
static PyObject *
_count_elements(PyObject *self, PyObject *args)
func(in);
}
+/*
+ * See issue 29565. Update a structure passed by value;
+ * the caller should not see any change.
+ */
+
+EXPORT(void)
+_testfunc_large_struct_update_value(Test in)
+{
+ in.first = 0x0badf00d;
+ in.second = 0x0badf00d;
+ in.third = 0x0badf00d;
+}
+
EXPORT(void)testfunc_array(int values[4])
{
printf("testfunc_array %d %d %d %d\n",
break;
#else
case FFI_SYSV:
+ /* If a single argument takes more than 8 bytes,
+ then a copy is passed by reference. */
+ for (unsigned i = 0; i < cif->nargs; i++) {
+ size_t z = cif->arg_types[i]->size;
+ if (z > 8) {
+ void *temp = alloca(z);
+ memcpy(temp, avalue[i], z);
+ avalue[i] = temp;
+ }
+ }
/*@-usedef@*/
return ffi_call_AMD64(ffi_prep_args, &ecif, cif->bytes,
cif->flags, ecif.rvalue, fn);
static PyTypeObject PyDateTime_TZInfoType;
static PyTypeObject PyDateTime_TimeZoneType;
+static int check_tzinfo_subclass(PyObject *p);
+
_Py_IDENTIFIER(as_integer_ratio);
_Py_IDENTIFIER(fromutc);
_Py_IDENTIFIER(isoformat);
{
if (year < MINYEAR || year > MAXYEAR) {
- PyErr_SetString(PyExc_ValueError,
- "year is out of range");
+ PyErr_Format(PyExc_ValueError, "year %i is out of range", year);
return -1;
}
if (month < 1 || month > 12) {
{
PyDateTime_Date *self;
+ if (check_date_args(year, month, day) < 0) {
+ return NULL;
+ }
+
self = (PyDateTime_Date *) (type->tp_alloc(type, 0));
if (self != NULL)
set_date_fields(self, year, month, day);
PyDateTime_DateTime *self;
char aware = tzinfo != Py_None;
+ if (check_date_args(year, month, day) < 0) {
+ return NULL;
+ }
+ if (check_time_args(hour, minute, second, usecond, fold) < 0) {
+ return NULL;
+ }
+ if (check_tzinfo_subclass(tzinfo) < 0) {
+ return NULL;
+ }
+
self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware));
if (self != NULL) {
self->hastzinfo = aware;
PyDateTime_Time *self;
char aware = tzinfo != Py_None;
+ if (check_time_args(hour, minute, second, usecond, fold) < 0) {
+ return NULL;
+ }
+ if (check_tzinfo_subclass(tzinfo) < 0) {
+ return NULL;
+ }
+
self = (PyDateTime_Time *) (type->tp_alloc(type, aware));
if (self != NULL) {
self->hastzinfo = aware;
if (PyArg_ParseTupleAndKeywords(args, kw, "iii", date_kws,
&year, &month, &day)) {
- if (check_date_args(year, month, day) < 0)
- return NULL;
self = new_date_ex(year, month, day, type);
}
return self;
if (PyArg_ParseTupleAndKeywords(args, kw, "|iiiiO$i", time_kws,
&hour, &minute, &second, &usecond,
&tzinfo, &fold)) {
- if (check_time_args(hour, minute, second, usecond, fold) < 0)
- return NULL;
- if (check_tzinfo_subclass(tzinfo) < 0)
- return NULL;
self = new_time_ex2(hour, minute, second, usecond, tzinfo, fold,
type);
}
{
if (self->hashcode == -1) {
PyObject *offset, *self0;
- if (DATE_GET_FOLD(self)) {
- self0 = new_time_ex2(DATE_GET_HOUR(self),
- DATE_GET_MINUTE(self),
- DATE_GET_SECOND(self),
- DATE_GET_MICROSECOND(self),
+ if (TIME_GET_FOLD(self)) {
+ self0 = new_time_ex2(TIME_GET_HOUR(self),
+ TIME_GET_MINUTE(self),
+ TIME_GET_SECOND(self),
+ TIME_GET_MICROSECOND(self),
HASTZINFO(self) ? self->tzinfo : Py_None,
0, Py_TYPE(self));
if (self0 == NULL)
if (PyArg_ParseTupleAndKeywords(args, kw, "iii|iiiiO$i", datetime_kws,
&year, &month, &day, &hour, &minute,
&second, &usecond, &tzinfo, &fold)) {
- if (check_date_args(year, month, day) < 0)
- return NULL;
- if (check_time_args(hour, minute, second, usecond, fold) < 0)
- return NULL;
- if (check_tzinfo_subclass(tzinfo) < 0)
- return NULL;
self = new_datetime_ex2(year, month, day,
hour, minute, second, usecond,
tzinfo, fold, type);
utc_to_seconds(int year, int month, int day,
int hour, int minute, int second)
{
- long long ordinal = ymd_to_ord(year, month, day);
+ long long ordinal;
+
+ /* ymd_to_ord() doesn't support year <= 0 */
+ if (year < MINYEAR || year > MAXYEAR) {
+ PyErr_Format(PyExc_ValueError, "year %i is out of range", year);
+ return -1;
+ }
+
+ ordinal = ymd_to_ord(year, month, day);
return ((ordinal * 24 + hour) * 60 + minute) * 60 + second;
}
"timestamp out of range for platform time_t");
return -1;
}
- /* XXX: add bounds checking */
if (_PyTime_localtime(t, &local_time) != 0)
return -1;
return utc_to_seconds(local_time.tm_year + 1900,
*/
second = Py_MIN(59, tm.tm_sec);
+ /* local timezone requires to compute fold */
if (tzinfo == Py_None && f == _PyTime_localtime) {
long long probe_seconds, result_seconds, transition;
assert(factor == 1 || factor == -1);
if (normalize_datetime(&year, &month, &day,
- &hour, &minute, &second, µsecond) < 0)
+ &hour, &minute, &second, µsecond) < 0) {
return NULL;
- else
- return new_datetime(year, month, day,
- hour, minute, second, microsecond,
- HASTZINFO(date) ? date->tzinfo : Py_None, 0);
+ }
+
+ return new_datetime(year, month, day,
+ hour, minute, second, microsecond,
+ HASTZINFO(date) ? date->tzinfo : Py_None, 0);
}
static PyObject *
PyObject *retval;
if (PyUnicode_Check(name)) {
- if (_PyUnicode_EqualToASCIIString(name, "traps")) {
+ if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
retval = ((PyDecContextObject *)self)->traps;
Py_INCREF(retval);
return retval;
}
- if (_PyUnicode_EqualToASCIIString(name, "flags")) {
+ if (PyUnicode_CompareWithASCIIString(name, "flags") == 0) {
retval = ((PyDecContextObject *)self)->flags;
Py_INCREF(retval);
return retval;
}
if (PyUnicode_Check(name)) {
- if (_PyUnicode_EqualToASCIIString(name, "traps")) {
+ if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
return context_settraps_dict(self, value);
}
- if (_PyUnicode_EqualToASCIIString(name, "flags")) {
+ if (PyUnicode_CompareWithASCIIString(name, "flags") == 0) {
return context_setstatus_dict(self, value);
}
}
tmp = PyTuple_GET_ITEM(dectuple, 2);
if (PyUnicode_Check(tmp)) {
/* special */
- if (_PyUnicode_EqualToASCIIString(tmp, "F")) {
+ if (PyUnicode_CompareWithASCIIString(tmp, "F") == 0) {
strcat(sign_special, "Inf");
is_infinite = 1;
}
- else if (_PyUnicode_EqualToASCIIString(tmp, "n")) {
+ else if (PyUnicode_CompareWithASCIIString(tmp, "n") == 0) {
strcat(sign_special, "NaN");
}
- else if (_PyUnicode_EqualToASCIIString(tmp, "N")) {
+ else if (PyUnicode_CompareWithASCIIString(tmp, "N") == 0) {
strcat(sign_special, "sNaN");
}
else {
element_dealloc(ElementObject* self)
{
PyObject_GC_UnTrack(self);
+ Py_TRASHCAN_SAFE_BEGIN(self)
if (self->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
RELEASE(sizeof(ElementObject), "destroy element");
Py_TYPE(self)->tp_free((PyObject *)self);
+ Py_TRASHCAN_SAFE_END(self)
}
/* -------------------------------------------------------------------- */
if (kw == NULL) {
pto->kw = PyDict_New();
}
- else {
+ else if (Py_REFCNT(kw) == 1) {
Py_INCREF(kw);
pto->kw = kw;
}
+ else {
+ pto->kw = PyDict_Copy(kw);
+ }
}
else {
pto->kw = PyDict_Copy(pkw);
static PyObject *
lru_cache_make_key(PyObject *args, PyObject *kwds, int typed)
{
- PyObject *key, *sorted_items;
- Py_ssize_t key_size, pos, key_pos;
+ PyObject *key, *keyword, *value;
+ Py_ssize_t key_size, pos, key_pos, kwds_size;
/* short path, key will match args anyway, which is a tuple */
if (!typed && !kwds) {
return args;
}
- if (kwds && PyDict_Size(kwds) > 0) {
- sorted_items = PyDict_Items(kwds);
- if (!sorted_items)
- return NULL;
- if (PyList_Sort(sorted_items) < 0) {
- Py_DECREF(sorted_items);
- return NULL;
- }
- } else
- sorted_items = NULL;
+ kwds_size = kwds ? PyDict_Size(kwds) : 0;
+ assert(kwds_size >= 0);
key_size = PyTuple_GET_SIZE(args);
- if (sorted_items)
- key_size += PyList_GET_SIZE(sorted_items);
+ if (kwds_size)
+ key_size += kwds_size * 2 + 1;
if (typed)
- key_size *= 2;
- if (sorted_items)
- key_size++;
+ key_size += PyTuple_GET_SIZE(args) + kwds_size;
key = PyTuple_New(key_size);
if (key == NULL)
- goto done;
+ return NULL;
key_pos = 0;
for (pos = 0; pos < PyTuple_GET_SIZE(args); ++pos) {
Py_INCREF(item);
PyTuple_SET_ITEM(key, key_pos++, item);
}
- if (sorted_items) {
+ if (kwds_size) {
Py_INCREF(kwd_mark);
PyTuple_SET_ITEM(key, key_pos++, kwd_mark);
- for (pos = 0; pos < PyList_GET_SIZE(sorted_items); ++pos) {
- PyObject *item = PyList_GET_ITEM(sorted_items, pos);
- Py_INCREF(item);
- PyTuple_SET_ITEM(key, key_pos++, item);
+ for (pos = 0; PyDict_Next(kwds, &pos, &keyword, &value);) {
+ Py_INCREF(keyword);
+ PyTuple_SET_ITEM(key, key_pos++, keyword);
+ Py_INCREF(value);
+ PyTuple_SET_ITEM(key, key_pos++, value);
}
+ assert(key_pos == PyTuple_GET_SIZE(args) + kwds_size * 2 + 1);
}
if (typed) {
for (pos = 0; pos < PyTuple_GET_SIZE(args); ++pos) {
Py_INCREF(item);
PyTuple_SET_ITEM(key, key_pos++, item);
}
- if (sorted_items) {
- for (pos = 0; pos < PyList_GET_SIZE(sorted_items); ++pos) {
- PyObject *tp_items = PyList_GET_ITEM(sorted_items, pos);
- PyObject *item = (PyObject *)Py_TYPE(PyTuple_GET_ITEM(tp_items, 1));
+ if (kwds_size) {
+ for (pos = 0; PyDict_Next(kwds, &pos, &keyword, &value);) {
+ PyObject *item = (PyObject *)Py_TYPE(value);
Py_INCREF(item);
PyTuple_SET_ITEM(key, key_pos++, item);
}
}
}
assert(key_pos == key_size);
-
-done:
- if (sorted_items)
- Py_DECREF(sorted_items);
return key;
}
}
if (self->full && self->root.next != &self->root) {
/* Use the oldest item to store the new key and result. */
- PyObject *oldkey, *oldresult;
+ PyObject *oldkey, *oldresult, *popresult;
/* Extricate the oldest item. */
link = self->root.next;
lru_cache_extricate_link(link);
/* Remove it from the cache.
The cache dict holds one reference to the link,
and the linked list holds yet one reference to it. */
- if (_PyDict_DelItem_KnownHash(self->cache, link->key,
- link->hash) < 0) {
+ popresult = _PyDict_Pop_KnownHash(self->cache,
+ link->key, link->hash,
+ Py_None);
+ if (popresult == Py_None) {
+ /* Getting here means that this same key was added to the
+ cache while the lock was released. Since the link
+ update is already done, we need only return the
+ computed result and update the count of misses. */
+ Py_DECREF(popresult);
+ Py_DECREF(link);
+ Py_DECREF(key);
+ }
+ else if (popresult == NULL) {
lru_cache_append_link(self, link);
Py_DECREF(key);
Py_DECREF(result);
return NULL;
}
- /* Keep a reference to the old key and old result to
- prevent their ref counts from going to zero during the
- update. That will prevent potentially arbitrary object
- clean-up code (i.e. __del__) from running while we're
- still adjusting the links. */
- oldkey = link->key;
- oldresult = link->result;
-
- link->hash = hash;
- link->key = key;
- link->result = result;
- if (_PyDict_SetItem_KnownHash(self->cache, key, (PyObject *)link,
- hash) < 0) {
- Py_DECREF(link);
+ else {
+ Py_DECREF(popresult);
+ /* Keep a reference to the old key and old result to
+ prevent their ref counts from going to zero during the
+ update. That will prevent potentially arbitrary object
+ clean-up code (i.e. __del__) from running while we're
+ still adjusting the links. */
+ oldkey = link->key;
+ oldresult = link->result;
+
+ link->hash = hash;
+ link->key = key;
+ link->result = result;
+ if (_PyDict_SetItem_KnownHash(self->cache, key, (PyObject *)link,
+ hash) < 0) {
+ Py_DECREF(link);
+ Py_DECREF(oldkey);
+ Py_DECREF(oldresult);
+ return NULL;
+ }
+ lru_cache_append_link(self, link);
+ Py_INCREF(result); /* for return */
Py_DECREF(oldkey);
Py_DECREF(oldresult);
- return NULL;
}
- lru_cache_append_link(self, link);
- Py_INCREF(result); /* for return */
- Py_DECREF(oldkey);
- Py_DECREF(oldresult);
} else {
/* Put result in a new link at the front of the queue. */
link = (lru_list_elem *)PyObject_GC_New(lru_list_elem,
/* UnsupportedOperation inherits from ValueError and IOError */
state->unsupported_operation = PyObject_CallFunction(
(PyObject *)&PyType_Type, "s(OO){}",
- "UnsupportedOperation", PyExc_ValueError, PyExc_IOError);
+ "UnsupportedOperation", PyExc_OSError, PyExc_ValueError);
if (state->unsupported_operation == NULL)
goto fail;
Py_INCREF(state->unsupported_operation);
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
int closefd, PyObject *opener)
/*[clinic end generated code: output=23413f68e6484bbd input=193164e293d6c097]*/
{
- const char *name = NULL;
- PyObject *stringobj = NULL;
- const char *s;
#ifdef MS_WINDOWS
Py_UNICODE *widename = NULL;
+#else
+ const char *name = NULL;
#endif
+ PyObject *stringobj = NULL;
+ const char *s;
int ret = 0;
int rwa = 0, plus = 0;
int flags = 0;
PyErr_Clear();
}
+ if (fd < 0) {
#ifdef MS_WINDOWS
- if (PyUnicode_Check(nameobj)) {
Py_ssize_t length;
- widename = PyUnicode_AsUnicodeAndSize(nameobj, &length);
- if (widename == NULL)
- return -1;
- if (wcslen(widename) != length) {
- PyErr_SetString(PyExc_ValueError, "embedded null character");
+ if (!PyUnicode_FSDecoder(nameobj, &stringobj)) {
return -1;
}
- } else
-#endif
- if (fd < 0)
- {
+ widename = PyUnicode_AsUnicodeAndSize(stringobj, &length);
+ if (widename == NULL)
+ return -1;
+#else
if (!PyUnicode_FSConverter(nameobj, &stringobj)) {
return -1;
}
name = PyBytes_AS_STRING(stringobj);
+#endif
}
s = mode;
do {
Py_BEGIN_ALLOW_THREADS
#ifdef MS_WINDOWS
- if (widename != NULL)
- self->fd = _wopen(widename, flags, 0666);
- else
+ self->fd = _wopen(widename, flags, 0666);
+#else
+ self->fd = open(name, flags, 0666);
#endif
- self->fd = open(name, flags, 0666);
Py_END_ALLOW_THREADS
} while (self->fd < 0 && errno == EINTR &&
!(async_err = PyErr_CheckSignals()));
errors);
if (self->encoder == NULL)
goto error;
- /* Get the normalized named of the codec */
+ /* Get the normalized name of the codec */
res = _PyObject_GetAttrId(codec_info, &PyId_name);
if (res == NULL) {
if (PyErr_ExceptionMatches(PyExc_AttributeError))
}
char _PyIO_get_console_type(PyObject *path_or_fd) {
- int fd;
-
- fd = PyLong_AsLong(path_or_fd);
+ int fd = PyLong_AsLong(path_or_fd);
PyErr_Clear();
if (fd >= 0) {
HANDLE handle;
_Py_BEGIN_SUPPRESS_IPH
handle = (HANDLE)_get_osfhandle(fd);
_Py_END_SUPPRESS_IPH
- if (!handle)
+ if (handle == INVALID_HANDLE_VALUE)
return '\0';
return _get_console_type(handle);
}
- PyObject *decoded, *decoded_upper;
+ PyObject *decoded;
+ wchar_t *decoded_wstr;
- int d = PyUnicode_FSDecoder(path_or_fd, &decoded);
- if (!d) {
+ if (!PyUnicode_FSDecoder(path_or_fd, &decoded)) {
PyErr_Clear();
return '\0';
}
- if (!PyUnicode_Check(decoded)) {
- Py_CLEAR(decoded);
- return '\0';
- }
- decoded_upper = PyObject_CallMethod(decoded, "upper", "");
+ decoded_wstr = PyUnicode_AsWideCharString(decoded, NULL);
Py_CLEAR(decoded);
- if (!decoded_upper) {
+ if (!decoded_wstr) {
PyErr_Clear();
return '\0';
}
char m = '\0';
- if (_PyUnicode_EqualToASCIIString(decoded_upper, "CONIN$")) {
+ if (!_wcsicmp(decoded_wstr, L"CONIN$")) {
m = 'r';
- } else if (_PyUnicode_EqualToASCIIString(decoded_upper, "CONOUT$")) {
+ } else if (!_wcsicmp(decoded_wstr, L"CONOUT$")) {
m = 'w';
- } else if (_PyUnicode_EqualToASCIIString(decoded_upper, "CON")) {
+ } else if (!_wcsicmp(decoded_wstr, L"CON")) {
m = 'x';
}
+ if (m) {
+ PyMem_Free(decoded_wstr);
+ return m;
+ }
- Py_CLEAR(decoded_upper);
+ DWORD length;
+ wchar_t name_buf[MAX_PATH], *pname_buf = name_buf;
+
+ length = GetFullPathNameW(decoded_wstr, MAX_PATH, pname_buf, NULL);
+ if (length > MAX_PATH) {
+ pname_buf = PyMem_New(wchar_t, length);
+ if (pname_buf)
+ length = GetFullPathNameW(decoded_wstr, length, pname_buf, NULL);
+ else
+ length = 0;
+ }
+ PyMem_Free(decoded_wstr);
+
+ if (length) {
+ wchar_t *name = pname_buf;
+ if (length >= 4 && name[3] == L'\\' &&
+ (name[2] == L'.' || name[2] == L'?') &&
+ name[1] == L'\\' && name[0] == L'\\') {
+ name += 4;
+ }
+ if (!_wcsicmp(name, L"CONIN$")) {
+ m = 'r';
+ } else if (!_wcsicmp(name, L"CONOUT$")) {
+ m = 'w';
+ } else if (!_wcsicmp(name, L"CON")) {
+ m = 'x';
+ }
+ }
+
+ if (pname_buf != name_buf)
+ PyMem_Free(pname_buf);
return m;
}
+
/*[clinic input]
module _io
class _io._WindowsConsoleIO "winconsoleio *" "&PyWindowsConsoleIO_Type"
Py_CLEAR(decodedname);
if (name == NULL)
return -1;
+ if (console_type == '\0') {
+ PyErr_SetString(PyExc_ValueError,
+ "Cannot open non-console file");
+ return -1;
+ }
if (wcslen(name) != length) {
PyMem_Free(name);
if (console_type == '\0')
console_type = _get_console_type(self->handle);
+ if (console_type == '\0') {
+ PyErr_SetString(PyExc_ValueError,
+ "Cannot open non-console file");
+ goto error;
+ }
if (self->writable && console_type != 'w') {
PyErr_SetString(PyExc_ValueError,
"Cannot open console input buffer for writing");
int kind;
Py_ssize_t end_idx;
PyObject *val = NULL;
- PyObject *rval = PyList_New(0);
+ PyObject *rval;
Py_ssize_t next_idx;
- if (rval == NULL)
- return NULL;
if (PyUnicode_READY(pystr) == -1)
return NULL;
+ rval = PyList_New(0);
+ if (rval == NULL)
+ return NULL;
+
str = PyUnicode_DATA(pystr);
kind = PyUnicode_KIND(pystr);
end_idx = PyUnicode_GET_LENGTH(pystr) - 1;
return -1;
}
- if (Py_EnterRecursiveCall(" while encoding a JSON object"))
+ if (Py_EnterRecursiveCall(" while encoding a JSON object")) {
+ Py_DECREF(newobj);
+ Py_XDECREF(ident);
return -1;
+ }
rv = encoder_listencode_obj(s, acc, newobj, indent_level);
Py_LeaveRecursiveCall();
if (open_dict == NULL || close_dict == NULL || empty_dict == NULL)
return -1;
}
- if (Py_SIZE(dct) == 0)
+ if (PyDict_Size(dct) == 0) /* Fast path */
return _PyAccu_Accumulate(acc, empty_dict);
if (s->markers != Py_None) {
}
static PyObject *
-get_dotted_path(PyObject *obj, PyObject *name) {
+get_dotted_path(PyObject *obj, PyObject *name)
+{
_Py_static_string(PyId_dot, ".");
- _Py_static_string(PyId_locals, "<locals>");
PyObject *dotted_path;
Py_ssize_t i, n;
assert(n >= 1);
for (i = 0; i < n; i++) {
PyObject *subpath = PyList_GET_ITEM(dotted_path, i);
- PyObject *result = PyUnicode_RichCompare(
- subpath, _PyUnicode_FromId(&PyId_locals), Py_EQ);
- int is_equal = (result == Py_True);
- assert(PyBool_Check(result));
- Py_DECREF(result);
- if (is_equal) {
+ if (_PyUnicode_EqualToASCIIString(subpath, "<locals>")) {
if (obj == NULL)
PyErr_Format(PyExc_AttributeError,
"Can't pickle local object %R", name);
}
else if (PyUnicode_Check(name)) {
_Py_IDENTIFIER(__newobj_ex__);
- use_newobj_ex = PyUnicode_Compare(
- name, _PyUnicode_FromId(&PyId___newobj_ex__)) == 0;
+ use_newobj_ex = _PyUnicode_EqualToASCIIId(
+ name, &PyId___newobj_ex__);
if (!use_newobj_ex) {
_Py_IDENTIFIER(__newobj__);
- use_newobj = PyUnicode_Compare(
- name, _PyUnicode_FromId(&PyId___newobj__)) == 0;
+ use_newobj = _PyUnicode_EqualToASCIIId(name, &PyId___newobj__);
}
}
Py_XDECREF(name);
/* ------------------------------------------------------------------
The code in this module was based on a download from:
- http://www.math.keio.ac.jp/~matumoto/MT2002/emt19937ar.html
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html
It was modified in 2002 by Raymond Hettinger as follows:
Any feedback is very welcome.
- http://www.math.keio.ac.jp/matumoto/emt.html
- email: matumoto@math.keio.ac.jp
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
*/
/* ---------------------------------------------------------------*/
return NULL;
if (arg == NULL || arg == Py_None) {
- if (random_seed_urandom(self) >= 0) {
+ if (random_seed_urandom(self) < 0) {
PyErr_Clear();
/* Reading system entropy failed, fall back on the worst entropy:
pysqlite_statement_reset(self->statement);
pysqlite_statement_mark_dirty(self->statement);
- /* For backwards compatibility reasons, do not start a transaction if a
- DDL statement is encountered. If anybody wants transactional DDL,
- they can issue a BEGIN statement manually. */
- if (self->connection->begin_statement && !sqlite3_stmt_readonly(self->statement->st) && !self->statement->is_ddl) {
+ /* We start a transaction implicitly before a DML statement.
+ SELECT is the only exception. See #9924. */
+ if (self->connection->begin_statement && self->statement->is_dml) {
if (sqlite3_get_autocommit(self->connection->db)) {
result = _pysqlite_connection_begin(self->connection);
if (!result) {
}
}
- if (!sqlite3_stmt_readonly(self->statement->st)) {
+ if (self->statement->is_dml) {
self->rowcount += (long)sqlite3_changes(self->connection->db);
} else {
self->rowcount= -1L;
Py_INCREF(sql);
self->sql = sql;
- /* determine if the statement is a DDL statement */
- self->is_ddl = 0;
+ /* Determine if the statement is a DML statement.
+ SELECT is the only exception. See #9924. */
+ self->is_dml = 0;
for (p = sql_cstr; *p != 0; p++) {
switch (*p) {
case ' ':
continue;
}
- self->is_ddl = (PyOS_strnicmp(p, "create ", 7) == 0)
- || (PyOS_strnicmp(p, "drop ", 5) == 0)
- || (PyOS_strnicmp(p, "reindex ", 8) == 0);
+ self->is_dml = (PyOS_strnicmp(p, "insert ", 7) == 0)
+ || (PyOS_strnicmp(p, "update ", 7) == 0)
+ || (PyOS_strnicmp(p, "delete ", 7) == 0)
+ || (PyOS_strnicmp(p, "replace ", 8) == 0);
break;
}
sqlite3_stmt* st;
PyObject* sql;
int in_use;
- int is_ddl;
+ int is_dml;
PyObject* in_weakreflist; /* List of weak references */
} pysqlite_Statement;
Py_buffer view;
PyObject *result;
void* ptr;
+ Py_ssize_t i, j;
if (index < 0 || index >= self->groups) {
/* raise IndexError if we were given a bad group number */
ptr = getstring(self->string, &length, &isbytes, &charsize, &view);
if (ptr == NULL)
return NULL;
- result = getslice(isbytes, ptr,
- self->string, self->mark[index], self->mark[index+1]);
+
+ i = self->mark[index];
+ j = self->mark[index+1];
+ i = Py_MIN(i, length);
+ j = Py_MIN(j, length);
+ result = getslice(isbytes, ptr, self->string, i, j);
if (isbytes && view.buf != NULL)
PyBuffer_Release(&view);
return result;
#endif
-#ifndef OPENSSL_NO_ECDH
+#if !defined(OPENSSL_NO_ECDH) && !defined(OPENSSL_VERSION_1_1)
/* Allow automatic ECDH curve selection (on OpenSSL 1.0.2+), or use
prime256v1 by default. This is Apache mod_ssl's initialization
policy, so we should be safe. OpenSSL 1.1 has it enabled by default.
*/
-#if defined(SSL_CTX_set_ecdh_auto) && !defined(OPENSSL_VERSION_1_1)
+#if defined(SSL_CTX_set_ecdh_auto)
SSL_CTX_set_ecdh_auto(self->ctx, 1);
#else
{
PyObject *calcsize = NULL;
/* cache simple format string */
-static const char simple_fmt[] = "B";
+static const char *simple_fmt = "B";
PyObject *simple_format = NULL;
#define SIMPLE_FORMAT(fmt) (fmt == NULL || strcmp(fmt, "B") == 0)
#define FIX_FORMAT(fmt) (fmt == NULL ? "B" : fmt)
Py_ssize_t *dest;
Py_ssize_t x, i;
+ /* ndim = len <= ND_MAX_NDIM, so PyMem_New() is actually not needed. */
dest = PyMem_New(Py_ssize_t, len);
if (dest == NULL) {
PyErr_NoMemory();
}
+static int
+is_dead_weakref(PyObject *value)
+{
+ if (!PyWeakref_Check(value)) {
+ PyErr_SetString(PyExc_TypeError, "not a weakref");
+ return -1;
+ }
+ return PyWeakref_GET_OBJECT(value) == Py_None;
+}
+
+/*[clinic input]
+
+_weakref._remove_dead_weakref -> object
+
+ dct: object(subclass_of='&PyDict_Type')
+ key: object
+ /
+
+Atomically remove key from dict if it points to a dead weakref.
+[clinic start generated code]*/
+
+static PyObject *
+_weakref__remove_dead_weakref_impl(PyObject *module, PyObject *dct,
+ PyObject *key)
+/*[clinic end generated code: output=d9ff53061fcb875c input=19fc91f257f96a1d]*/
+{
+ if (_PyDict_DelItemIf(dct, key, is_dead_weakref) < 0) {
+ if (PyErr_ExceptionMatches(PyExc_KeyError))
+ /* This function is meant to allow safe weak-value dicts
+ with GC in another thread (see issue #28427), so it's
+ ok if the key doesn't exist anymore.
+ */
+ PyErr_Clear();
+ else
+ return NULL;
+ }
+ Py_RETURN_NONE;
+}
+
+
PyDoc_STRVAR(weakref_getweakrefs__doc__,
"getweakrefs(object) -- return a list of all weak reference objects\n"
"that point to 'object'.");
static PyMethodDef
weakref_functions[] = {
_WEAKREF_GETWEAKREFCOUNT_METHODDEF
+ _WEAKREF__REMOVE_DEAD_WEAKREF_METHODDEF
{"getweakrefs", weakref_getweakrefs, METH_O,
weakref_getweakrefs__doc__},
{"proxy", weakref_proxy, METH_VARARGS,
crc: unsigned_int(bitwise=True)
/
-Compute hqx CRC incrementally.
+Compute CRC-CCITT incrementally.
[clinic start generated code]*/
static unsigned int
binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc)
-/*[clinic end generated code: output=8ec2a78590d19170 input=add8c53712ccceda]*/
+/*[clinic end generated code: output=8ec2a78590d19170 input=f18240ff8c705b79]*/
{
const unsigned char *bin_data;
Py_ssize_t len;
PyObject *return_value = NULL;
static const char * const _keywords[] = {"loop", NULL};
static _PyArg_Parser _parser = {"|O:current_task", _keywords, 0};
- PyObject *loop = NULL;
+ PyObject *loop = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
&loop)) {
PyObject *return_value = NULL;
static const char * const _keywords[] = {"loop", NULL};
static _PyArg_Parser _parser = {"|O:all_tasks", _keywords, 0};
- PyObject *loop = NULL;
+ PyObject *loop = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
&loop)) {
exit:
return return_value;
}
-/*[clinic end generated code: output=8f036321bb083066 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=40ca6c9da517da73 input=a9049054013a1b77]*/
exit:
return return_value;
}
-/*[clinic end generated code: output=e1ad587147323e19 input=a9049054013a1b77]*/
+
+PyDoc_STRVAR(_weakref__remove_dead_weakref__doc__,
+"_remove_dead_weakref($module, dct, key, /)\n"
+"--\n"
+"\n"
+"Atomically remove key from dict if it points to a dead weakref.");
+
+#define _WEAKREF__REMOVE_DEAD_WEAKREF_METHODDEF \
+ {"_remove_dead_weakref", (PyCFunction)_weakref__remove_dead_weakref, METH_VARARGS, _weakref__remove_dead_weakref__doc__},
+
+static PyObject *
+_weakref__remove_dead_weakref_impl(PyObject *module, PyObject *dct,
+ PyObject *key);
+
+static PyObject *
+_weakref__remove_dead_weakref(PyObject *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ PyObject *dct;
+ PyObject *key;
+
+ if (!PyArg_ParseTuple(args, "O!O:_remove_dead_weakref",
+ &PyDict_Type, &dct, &key)) {
+ goto exit;
+ }
+ return_value = _weakref__remove_dead_weakref_impl(module, dct, key);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=e860dd818a44bc9b input=a9049054013a1b77]*/
"crc_hqx($module, data, crc, /)\n"
"--\n"
"\n"
-"Compute hqx CRC incrementally.");
+"Compute CRC-CCITT incrementally.");
#define BINASCII_CRC_HQX_METHODDEF \
{"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_VARARGS, binascii_crc_hqx__doc__},
return return_value;
}
-/*[clinic end generated code: output=1f8d6e48f75f6d1e input=a9049054013a1b77]*/
+/*[clinic end generated code: output=458eb09731cb7877 input=a9049054013a1b77]*/
"Perform a stat system call on the given path.\n"
"\n"
" path\n"
-" Path to be examined; can be string, bytes, or open-file-descriptor int.\n"
+" Path to be examined; can be string, bytes, path-like object or\n"
+" open-file-descriptor int.\n"
" dir_fd\n"
" If not None, it should be a file descriptor open to a directory,\n"
" and path should be a relative string; path will then be relative to\n"
#ifndef OS_GETRANDOM_METHODDEF
#define OS_GETRANDOM_METHODDEF
#endif /* !defined(OS_GETRANDOM_METHODDEF) */
-/*[clinic end generated code: output=50cfb7ebc44efb67 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=455def991740915a input=a9049054013a1b77]*/
#endif
/* XXX Only unix build process has been tested */
-#ifndef HGVERSION
-#define HGVERSION ""
+#ifndef GITVERSION
+#define GITVERSION ""
#endif
-#ifndef HGTAG
-#define HGTAG ""
+#ifndef GITTAG
+#define GITTAG ""
#endif
-#ifndef HGBRANCH
-#define HGBRANCH ""
+#ifndef GITBRANCH
+#define GITBRANCH ""
#endif
const char *
Py_GetBuildInfo(void)
{
- static char buildinfo[50 + sizeof(HGVERSION) +
- ((sizeof(HGTAG) > sizeof(HGBRANCH)) ?
- sizeof(HGTAG) : sizeof(HGBRANCH))];
- const char *revision = _Py_hgversion();
+ static char buildinfo[50 + sizeof(GITVERSION) +
+ ((sizeof(GITTAG) > sizeof(GITBRANCH)) ?
+ sizeof(GITTAG) : sizeof(GITBRANCH))];
+ const char *revision = _Py_gitversion();
const char *sep = *revision ? ":" : "";
- const char *hgid = _Py_hgidentifier();
- if (!(*hgid))
- hgid = "default";
+ const char *gitid = _Py_gitidentifier();
+ if (!(*gitid))
+ gitid = "default";
PyOS_snprintf(buildinfo, sizeof(buildinfo),
- "%s%s%s, %.20s, %.9s", hgid, sep, revision,
+ "%s%s%s, %.20s, %.9s", gitid, sep, revision,
DATE, TIME);
return buildinfo;
}
const char *
-_Py_hgversion(void)
+_Py_gitversion(void)
{
- return HGVERSION;
+ return GITVERSION;
}
const char *
-_Py_hgidentifier(void)
+_Py_gitidentifier(void)
{
- const char *hgtag, *hgid;
- hgtag = HGTAG;
- if ((*hgtag) && strcmp(hgtag, "tip") != 0)
- hgid = hgtag;
+ const char *gittag, *gitid;
+ gittag = GITTAG;
+ if ((*gittag) && strcmp(gittag, "undefined") != 0)
+ gitid = gittag;
else
- hgid = HGBRANCH;
- return hgid;
+ gitid = GITBRANCH;
+ return gitid;
}
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
#include <windows.h>
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
return 0;
}
-static int
-RunMainFromImporter(wchar_t *filename)
+static PyObject *
+AsImportPathEntry(wchar_t *filename)
{
- PyObject *argv0 = NULL, *importer, *sys_path;
- int sts;
+ PyObject *sys_path0 = NULL, *importer;
- argv0 = PyUnicode_FromWideChar(filename, wcslen(filename));
- if (argv0 == NULL)
+ sys_path0 = PyUnicode_FromWideChar(filename, wcslen(filename));
+ if (sys_path0 == NULL)
goto error;
- importer = PyImport_GetImporter(argv0);
+ importer = PyImport_GetImporter(sys_path0);
if (importer == NULL)
goto error;
if (importer == Py_None) {
- Py_DECREF(argv0);
+ Py_DECREF(sys_path0);
Py_DECREF(importer);
- return -1;
+ return NULL;
}
Py_DECREF(importer);
+ return sys_path0;
+
+error:
+ Py_XDECREF(sys_path0);
+ PySys_WriteStderr("Failed checking if argv[0] is an import path entry\n");
+ PyErr_Print();
+ PyErr_Clear();
+ return NULL;
+}
- /* argv0 is usable as an import source, so put it in sys.path[0]
- and import __main__ */
+
+static int
+RunMainFromImporter(PyObject *sys_path0)
+{
+ PyObject *sys_path;
+ int sts;
+
+ /* Assume sys_path0 has already been checked by AsImportPathEntry,
+ * so put it in sys.path[0] and import __main__ */
sys_path = PySys_GetObject("path");
if (sys_path == NULL) {
PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path");
goto error;
}
- if (PyList_SetItem(sys_path, 0, argv0)) {
- argv0 = NULL;
+ sts = PyList_Insert(sys_path, 0, sys_path0);
+ if (sts) {
+ sys_path0 = NULL;
goto error;
}
- Py_INCREF(argv0);
sts = RunModule(L"__main__", 0);
return sts != 0;
error:
- Py_XDECREF(argv0);
+ Py_XDECREF(sys_path0);
PyErr_Print();
return 1;
}
int saw_unbuffered_flag = 0;
char *opt;
PyCompilerFlags cf;
+ PyObject *main_importer_path = NULL;
PyObject *warning_option = NULL;
PyObject *warning_options = NULL;
argv[_PyOS_optind] = L"-m";
}
- PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
+ if (filename != NULL) {
+ main_importer_path = AsImportPathEntry(filename);
+ }
+
+ if (main_importer_path != NULL) {
+ /* Let RunMainFromImporter adjust sys.path[0] later */
+ PySys_SetArgvEx(argc-_PyOS_optind, argv+_PyOS_optind, 0);
+ } else {
+ /* Use config settings to decide whether or not to update sys.path[0] */
+ PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
+ }
if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
isatty(fileno(stdin)) &&
sts = -1; /* keep track of whether we've already run __main__ */
- if (filename != NULL) {
- sts = RunMainFromImporter(filename);
+ if (main_importer_path != NULL) {
+ sts = RunMainFromImporter(main_importer_path);
}
- if (sts==-1 && filename!=NULL) {
+ if (sts==-1 && filename != NULL) {
fp = _Py_wfopen(filename, L"r");
if (fp == NULL) {
char *cfilename_buffer;
for mod in $MODS
do
EXTDECLS="${EXTDECLS}extern PyObject* PyInit_$mod(void);$NL"
- INITBITS="${INITBITS} {\"$mod\", PyInit_$mod},$NL"
+ INITBITS="${INITBITS} {\"$mod\", PyInit_$mod},$NL"
done
* The length of the path in characters, if specified as
* a string.
* path.object
- * The original object passed in.
+ * The original object passed in (if get a PathLike object,
+ * the result of PyOS_FSPath() is treated as the original object).
+ * Own a reference to the object.
* path.cleanup
* For internal use only. May point to a temporary object.
* (Pay no attention to the man behind the curtain.)
#endif
static void
-path_cleanup(path_t *path) {
- if (path->cleanup) {
- Py_CLEAR(path->cleanup);
- }
+path_cleanup(path_t *path)
+{
+ Py_CLEAR(path->object);
+ Py_CLEAR(path->cleanup);
}
static int
path_converter(PyObject *o, void *p)
{
path_t *path = (path_t *)p;
- PyObject *bytes, *to_cleanup = NULL;
- Py_ssize_t length;
+ PyObject *bytes = NULL;
+ Py_ssize_t length = 0;
int is_index, is_buffer, is_bytes, is_unicode;
- /* Default to failure, forcing explicit signaling of succcess. */
- int ret = 0;
const char *narrow;
#ifdef MS_WINDOWS
- PyObject *wo;
+ PyObject *wo = NULL;
const wchar_t *wide;
#endif
}
/* Ensure it's always safe to call path_cleanup(). */
- path->cleanup = NULL;
+ path->object = path->cleanup = NULL;
+ /* path->object owns a reference to the original object */
+ Py_INCREF(o);
if ((o == Py_None) && path->nullable) {
path->wide = NULL;
#else
path->narrow = NULL;
#endif
- path->length = 0;
- path->object = o;
path->fd = -1;
- return 1;
+ goto success_exit;
}
/* Only call this here so that we don't treat the return value of
func = _PyObject_LookupSpecial(o, &PyId___fspath__);
if (NULL == func) {
- goto error_exit;
+ goto error_format;
}
-
- o = to_cleanup = PyObject_CallFunctionObjArgs(func, NULL);
+ /* still owns a reference to the original object */
+ Py_DECREF(o);
+ o = _PyObject_CallNoArg(func);
Py_DECREF(func);
if (NULL == o) {
goto error_exit;
is_bytes = 1;
}
else {
- goto error_exit;
+ goto error_format;
}
}
#ifdef MS_WINDOWS
wide = PyUnicode_AsUnicodeAndSize(o, &length);
if (!wide) {
- goto exit;
+ goto error_exit;
}
if (length > 32767) {
FORMAT_EXCEPTION(PyExc_ValueError, "%s too long for Windows");
- goto exit;
+ goto error_exit;
}
if (wcslen(wide) != length) {
FORMAT_EXCEPTION(PyExc_ValueError, "embedded null character in %s");
- goto exit;
+ goto error_exit;
}
path->wide = wide;
- path->length = length;
- path->object = o;
+ path->narrow = FALSE;
path->fd = -1;
- ret = 1;
- goto exit;
+ goto success_exit;
#else
if (!PyUnicode_FSConverter(o, &bytes)) {
- goto exit;
+ goto error_exit;
}
#endif
}
path->nullable ? "string, bytes, os.PathLike or None" :
"string, bytes or os.PathLike",
Py_TYPE(o)->tp_name)) {
- goto exit;
+ goto error_exit;
}
bytes = PyBytes_FromObject(o);
if (!bytes) {
- goto exit;
+ goto error_exit;
}
}
else if (is_index) {
if (!_fd_converter(o, &path->fd)) {
- goto exit;
+ goto error_exit;
}
path->wide = NULL;
#ifdef MS_WINDOWS
#else
path->narrow = NULL;
#endif
- path->length = 0;
- path->object = o;
- ret = 1;
- goto exit;
+ goto success_exit;
}
else {
- error_exit:
+ error_format:
PyErr_Format(PyExc_TypeError, "%s%s%s should be %s, not %.200s",
path->function_name ? path->function_name : "",
path->function_name ? ": " : "",
path->nullable ? "string, bytes, os.PathLike or None" :
"string, bytes or os.PathLike",
Py_TYPE(o)->tp_name);
- goto exit;
+ goto error_exit;
}
length = PyBytes_GET_SIZE(bytes);
narrow = PyBytes_AS_STRING(bytes);
if ((size_t)length != strlen(narrow)) {
FORMAT_EXCEPTION(PyExc_ValueError, "embedded null character in %s");
- Py_DECREF(bytes);
- goto exit;
+ goto error_exit;
}
#ifdef MS_WINDOWS
length
);
if (!wo) {
- goto exit;
+ goto error_exit;
}
- wide = PyUnicode_AsWideCharString(wo, &length);
- Py_DECREF(wo);
-
+ wide = PyUnicode_AsUnicodeAndSize(wo, &length);
if (!wide) {
- goto exit;
+ goto error_exit;
}
if (length > 32767) {
FORMAT_EXCEPTION(PyExc_ValueError, "%s too long for Windows");
- goto exit;
+ goto error_exit;
}
if (wcslen(wide) != length) {
FORMAT_EXCEPTION(PyExc_ValueError, "embedded null character in %s");
- goto exit;
+ goto error_exit;
}
path->wide = wide;
path->narrow = TRUE;
+ path->cleanup = wo;
+ Py_DECREF(bytes);
#else
path->wide = NULL;
path->narrow = narrow;
-#endif
- path->length = length;
- path->object = o;
- path->fd = -1;
if (bytes == o) {
+ /* Still a reference owned by path->object, don't have to
+ worry about path->narrow is used after free. */
Py_DECREF(bytes);
- ret = 1;
}
else {
path->cleanup = bytes;
- ret = Py_CLEANUP_SUPPORTED;
}
- exit:
- Py_XDECREF(to_cleanup);
- return ret;
+#endif
+ path->fd = -1;
+
+ success_exit:
+ path->length = length;
+ path->object = o;
+ return Py_CLEANUP_SUPPORTED;
+
+ error_exit:
+ Py_XDECREF(o);
+ Py_XDECREF(bytes);
+#ifdef MS_WINDOWS
+ Py_XDECREF(wo);
+#endif
+ return 0;
}
static void
os.stat
path : path_t(allow_fd=True)
- Path to be examined; can be string, bytes, or open-file-descriptor int.
+ Path to be examined; can be string, bytes, path-like object or
+ open-file-descriptor int.
*
static PyObject *
os_stat_impl(PyObject *module, path_t *path, int dir_fd, int follow_symlinks)
-/*[clinic end generated code: output=7d4976e6f18a59c5 input=099d356c306fa24a]*/
+/*[clinic end generated code: output=7d4976e6f18a59c5 input=270bd64e7bb3c8f7]*/
{
return posix_do_stat("stat", path, dir_fd, follow_symlinks);
}
}
}
- Py_CLEAR(iterator->path.object);
path_cleanup(&iterator->path);
/* Restore the saved exception. */
path_converter, &iterator->path))
goto error;
- /* path_converter doesn't keep path.object around, so do it
- manually for the lifetime of the iterator here (the refcount
- is decremented in ScandirIterator_dealloc)
- */
- Py_XINCREF(iterator->path.object);
-
#ifdef MS_WINDOWS
iterator->first_time = 1;
}
static int
-py2rlimit(PyObject *curobj, PyObject *maxobj, struct rlimit *rl_out)
+py2rlimit(PyObject *limits, struct rlimit *rl_out)
{
+ PyObject *curobj, *maxobj;
+ limits = PySequence_Tuple(limits);
+ if (!limits)
+ /* Here limits is a borrowed reference */
+ return -1;
+
+ if (PyTuple_GET_SIZE(limits) != 2) {
+ PyErr_SetString(PyExc_ValueError,
+ "expected a tuple of 2 integers");
+ goto error;
+ }
+ curobj = PyTuple_GET_ITEM(limits, 0);
+ maxobj = PyTuple_GET_ITEM(limits, 1);
#if !defined(HAVE_LARGEFILE_SUPPORT)
rl_out->rlim_cur = PyLong_AsLong(curobj);
if (rl_out->rlim_cur == (rlim_t)-1 && PyErr_Occurred())
- return -1;
+ goto error;
rl_out->rlim_max = PyLong_AsLong(maxobj);
if (rl_out->rlim_max == (rlim_t)-1 && PyErr_Occurred())
- return -1;
+ goto error;
#else
/* The limits are probably bigger than a long */
rl_out->rlim_cur = PyLong_AsLongLong(curobj);
if (rl_out->rlim_cur == (rlim_t)-1 && PyErr_Occurred())
- return -1;
+ goto error;
rl_out->rlim_max = PyLong_AsLongLong(maxobj);
if (rl_out->rlim_max == (rlim_t)-1 && PyErr_Occurred())
- return -1;
+ goto error;
#endif
+ Py_DECREF(limits);
rl_out->rlim_cur = rl_out->rlim_cur & RLIM_INFINITY;
rl_out->rlim_max = rl_out->rlim_max & RLIM_INFINITY;
return 0;
+error:
+ Py_DECREF(limits);
+ return -1;
}
static PyObject*
{
struct rlimit rl;
int resource;
- PyObject *limits, *curobj, *maxobj;
+ PyObject *limits;
if (!PyArg_ParseTuple(args, "iO:setrlimit", &resource, &limits))
return NULL;
return NULL;
}
- limits = PySequence_Tuple(limits);
- if (!limits)
- /* Here limits is a borrowed reference */
+ if (py2rlimit(limits, &rl) < 0) {
return NULL;
-
- if (PyTuple_GET_SIZE(limits) != 2) {
- PyErr_SetString(PyExc_ValueError,
- "expected a tuple of 2 integers");
- goto error;
- }
- curobj = PyTuple_GET_ITEM(limits, 0);
- maxobj = PyTuple_GET_ITEM(limits, 1);
-
- if (py2rlimit(curobj, maxobj, &rl) < 0) {
- goto error;
}
if (setrlimit(resource, &rl) == -1) {
"not allowed to raise maximum limit");
else
PyErr_SetFromErrno(PyExc_OSError);
- goto error;
+ return NULL;
}
- Py_DECREF(limits);
- Py_INCREF(Py_None);
- return Py_None;
-
- error:
- Py_DECREF(limits);
- return NULL;
+ Py_RETURN_NONE;
}
#ifdef HAVE_PRLIMIT
struct rlimit old_limit, new_limit;
int resource, retval;
pid_t pid;
- PyObject *curobj=NULL, *maxobj=NULL;
+ PyObject *limits = NULL;
- if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i|(OO):prlimit",
- &pid, &resource, &curobj, &maxobj))
+ if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i|O:prlimit",
+ &pid, &resource, &limits))
return NULL;
if (resource < 0 || resource >= RLIM_NLIMITS) {
return NULL;
}
- if (curobj != NULL) {
- if (py2rlimit(curobj, maxobj, &new_limit) < 0) {
+ if (limits != NULL) {
+ if (py2rlimit(limits, &new_limit) < 0) {
return NULL;
}
retval = prlimit(pid, resource, &new_limit, &old_limit);
struct tm local = buf;
char zone[100];
int gmtoff;
- strftime(zone, sizeof(buf), "%Z", &buf);
+ strftime(zone, sizeof(zone), "%Z", &buf);
gmtoff = timegm(&buf) - when;
return tmtotuple(&local, zone, gmtoff);
}
newXxoObject(PyObject *arg)
{
XxoObject *self;
- self = PyObject_New(XxoObject, (PyTypeObject*)Xxo_Type);
+ self = PyObject_GC_New(XxoObject, (PyTypeObject*)Xxo_Type);
if (self == NULL)
return NULL;
self->x_attr = NULL;
ChangeLog file for zlib
+Changes in 1.2.11 (15 Jan 2017)
+- Fix deflate stored bug when pulling last block from window
+- Permit immediate deflateParams changes before any deflate input
+
+Changes in 1.2.10 (2 Jan 2017)
+- Avoid warnings on snprintf() return value
+- Fix bug in deflate_stored() for zero-length input
+- Fix bug in gzwrite.c that produced corrupt gzip files
+- Remove files to be installed before copying them in Makefile.in
+- Add warnings when compiling with assembler code
+
+Changes in 1.2.9 (31 Dec 2016)
+- Fix contrib/minizip to permit unzipping with desktop API [Zouzou]
+- Improve contrib/blast to return unused bytes
+- Assure that gzoffset() is correct when appending
+- Improve compress() and uncompress() to support large lengths
+- Fix bug in test/example.c where error code not saved
+- Remedy Coverity warning [Randers-Pehrson]
+- Improve speed of gzprintf() in transparent mode
+- Fix inflateInit2() bug when windowBits is 16 or 32
+- Change DEBUG macro to ZLIB_DEBUG
+- Avoid uninitialized access by gzclose_w()
+- Allow building zlib outside of the source directory
+- Fix bug that accepted invalid zlib header when windowBits is zero
+- Fix gzseek() problem on MinGW due to buggy _lseeki64 there
+- Loop on write() calls in gzwrite.c in case of non-blocking I/O
+- Add --warn (-w) option to ./configure for more compiler warnings
+- Reject a window size of 256 bytes if not using the zlib wrapper
+- Fix bug when level 0 used with Z_HUFFMAN or Z_RLE
+- Add --debug (-d) option to ./configure to define ZLIB_DEBUG
+- Fix bugs in creating a very large gzip header
+- Add uncompress2() function, which returns the input size used
+- Assure that deflateParams() will not switch functions mid-block
+- Dramatically speed up deflation for level 0 (storing)
+- Add gzfread(), duplicating the interface of fread()
+- Add gzfwrite(), duplicating the interface of fwrite()
+- Add deflateGetDictionary() function
+- Use snprintf() for later versions of Microsoft C
+- Fix *Init macros to use z_ prefix when requested
+- Replace as400 with os400 for OS/400 support [Monnerat]
+- Add crc32_z() and adler32_z() functions with size_t lengths
+- Update Visual Studio project files [AraHaan]
+
Changes in 1.2.8 (28 Apr 2013)
- Update contrib/minizip/iowin32.c for Windows RT [Vollant]
- Do not force Z_CONST for C++
-- Clean up contrib/vstudio [Ro§]
+- Clean up contrib/vstudio [Roß]
- Correct spelling error in zlib.h
- Fix mixed line endings in contrib/vstudio
- Clean up the usage of z_const and respect const usage within zlib
- Clean up examples/gzlog.[ch] comparisons of different types
- Avoid shift equal to bits in type (caused endless loop)
-- Fix unintialized value bug in gzputc() introduced by const patches
+- Fix uninitialized value bug in gzputc() introduced by const patches
- Fix memory allocation error in examples/zran.c [Nor]
- Fix bug where gzopen(), gzclose() would write an empty file
- Fix bug in gzclose() when gzwrite() runs out of memory
- Add a transparent write mode to gzopen() when 'T' is in the mode
- Update python link in zlib man page
- Get inffixed.h and MAKEFIXED result to match
-- Add a ./config --solo option to make zlib subset with no libary use
+- Add a ./config --solo option to make zlib subset with no library use
- Add undocumented inflateResetKeep() function for CAB file decoding
- Add --cover option to ./configure for gcc coverage testing
- Add #define ZLIB_CONST option to use const in the z_stream interface
- Update make_vms.com [Zinser]
- Use -fPIC for shared build in configure [Teredesai, Nicholson]
- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen]
-- Use fdopen() (not _fdopen()) for Interix in zutil.h [B\8ack]
+- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck]
- Add some FAQ entries about the contrib directory
- Update the MVS question in the FAQ
- Avoid extraneous reads after EOF in gzio.c [Brown]
386 asm code replacing longest_match().
contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
A C++ I/O streams interface to the zlib gz* functions
- contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
+ contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
Another C++ I/O streams interface
contrib/untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
A very simple tar.gz file extractor using zlib
- fix array overlay in deflate.c which sometimes caused bad compressed data
- fix inflate bug with empty stored block
- fix MSDOS medium model which was broken in 0.99
-- fix deflateParams() which could generated bad compressed data.
+- fix deflateParams() which could generate bad compressed data.
- Bytef is define'd instead of typedef'ed (work around Borland bug)
- added an INDEX file
- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
# Makefile for zlib
-# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler
+# Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
# For conditions of distribution and use, see copyright notice in zlib.h
# To compile and test, type:
CFLAGS=-O
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
-#CFLAGS=-g -DDEBUG
+#CFLAGS=-g -DZLIB_DEBUG
#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
# -Wstrict-prototypes -Wmissing-prototypes
STATICLIB=libz.a
SHAREDLIB=libz.so
-SHAREDLIBV=libz.so.1.2.8
+SHAREDLIBV=libz.so.1.2.10
SHAREDLIBM=libz.so.1
LIBS=$(STATICLIB) $(SHAREDLIBV)
mandir = ${prefix}/share/man
man3dir = ${mandir}/man3
pkgconfigdir = ${libdir}/pkgconfig
+SRCDIR=
+ZINC=
+ZINCOUT=-I.
OBJZ = adler32.o crc32.o deflate.o infback.o inffast.o inflate.o inftrees.o trees.o zutil.o
OBJG = compress.o uncompr.o gzclose.o gzlib.o gzread.o gzwrite.o
fi; \
rm -f $$TMP64
-infcover.o: test/infcover.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -c -o $@ test/infcover.c
+infcover.o: $(SRCDIR)test/infcover.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/infcover.c
infcover: infcover.o libz.a
$(CC) $(CFLAGS) -o $@ infcover.o libz.a
mv _match.o match.lo
rm -f _match.s
-example.o: test/example.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -c -o $@ test/example.c
+example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c
-minigzip.o: test/minigzip.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -c -o $@ test/minigzip.c
+minigzip.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/minigzip.c
-example64.o: test/example.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -D_FILE_OFFSET_BITS=64 -c -o $@ test/example.c
+example64.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/example.c
-minigzip64.o: test/minigzip.c zlib.h zconf.h
- $(CC) $(CFLAGS) -I. -D_FILE_OFFSET_BITS=64 -c -o $@ test/minigzip.c
+minigzip64.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/minigzip.c
-.SUFFIXES: .lo
-.c.lo:
+adler32.o: $(SRCDIR)adler32.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)adler32.c
+
+crc32.o: $(SRCDIR)crc32.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)crc32.c
+
+deflate.o: $(SRCDIR)deflate.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)deflate.c
+
+infback.o: $(SRCDIR)infback.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)infback.c
+
+inffast.o: $(SRCDIR)inffast.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inffast.c
+
+inflate.o: $(SRCDIR)inflate.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inflate.c
+
+inftrees.o: $(SRCDIR)inftrees.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inftrees.c
+
+trees.o: $(SRCDIR)trees.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)trees.c
+
+zutil.o: $(SRCDIR)zutil.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)zutil.c
+
+compress.o: $(SRCDIR)compress.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)compress.c
+
+uncompr.o: $(SRCDIR)uncompr.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)uncompr.c
+
+gzclose.o: $(SRCDIR)gzclose.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzclose.c
+
+gzlib.o: $(SRCDIR)gzlib.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzlib.c
+
+gzread.o: $(SRCDIR)gzread.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzread.c
+
+gzwrite.o: $(SRCDIR)gzwrite.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzwrite.c
+
+
+adler32.lo: $(SRCDIR)adler32.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/adler32.o $(SRCDIR)adler32.c
+ -@mv objs/adler32.o $@
+
+crc32.lo: $(SRCDIR)crc32.c
-@mkdir objs 2>/dev/null || test -d objs
- $(CC) $(SFLAGS) -DPIC -c -o objs/$*.o $<
- -@mv objs/$*.o $@
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/crc32.o $(SRCDIR)crc32.c
+ -@mv objs/crc32.o $@
+
+deflate.lo: $(SRCDIR)deflate.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/deflate.o $(SRCDIR)deflate.c
+ -@mv objs/deflate.o $@
+
+infback.lo: $(SRCDIR)infback.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/infback.o $(SRCDIR)infback.c
+ -@mv objs/infback.o $@
+
+inffast.lo: $(SRCDIR)inffast.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inffast.o $(SRCDIR)inffast.c
+ -@mv objs/inffast.o $@
+
+inflate.lo: $(SRCDIR)inflate.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inflate.o $(SRCDIR)inflate.c
+ -@mv objs/inflate.o $@
+
+inftrees.lo: $(SRCDIR)inftrees.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inftrees.o $(SRCDIR)inftrees.c
+ -@mv objs/inftrees.o $@
+
+trees.lo: $(SRCDIR)trees.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/trees.o $(SRCDIR)trees.c
+ -@mv objs/trees.o $@
+
+zutil.lo: $(SRCDIR)zutil.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/zutil.o $(SRCDIR)zutil.c
+ -@mv objs/zutil.o $@
+
+compress.lo: $(SRCDIR)compress.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/compress.o $(SRCDIR)compress.c
+ -@mv objs/compress.o $@
+
+uncompr.lo: $(SRCDIR)uncompr.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/uncompr.o $(SRCDIR)uncompr.c
+ -@mv objs/uncompr.o $@
+
+gzclose.lo: $(SRCDIR)gzclose.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzclose.o $(SRCDIR)gzclose.c
+ -@mv objs/gzclose.o $@
+
+gzlib.lo: $(SRCDIR)gzlib.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzlib.o $(SRCDIR)gzlib.c
+ -@mv objs/gzlib.o $@
+
+gzread.lo: $(SRCDIR)gzread.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzread.o $(SRCDIR)gzread.c
+ -@mv objs/gzread.o $@
+
+gzwrite.lo: $(SRCDIR)gzwrite.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzwrite.o $(SRCDIR)gzwrite.c
+ -@mv objs/gzwrite.o $@
+
placebo $(SHAREDLIBV): $(PIC_OBJS) libz.a
$(LDSHARED) $(SFLAGS) -o $@ $(PIC_OBJS) $(LDSHAREDLIBC) $(LDFLAGS)
-@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi
-@if [ ! -d $(DESTDIR)$(man3dir) ]; then mkdir -p $(DESTDIR)$(man3dir); fi
-@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi
+ rm -f $(DESTDIR)$(libdir)/$(STATICLIB)
cp $(STATICLIB) $(DESTDIR)$(libdir)
chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB)
-@($(RANLIB) $(DESTDIR)$(libdir)/libz.a || true) >/dev/null 2>&1
-@if test -n "$(SHAREDLIBV)"; then \
+ rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir); \
echo "cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)"; \
chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
($(LDCONFIG) || true) >/dev/null 2>&1; \
fi
- cp zlib.3 $(DESTDIR)$(man3dir)
+ rm -f $(DESTDIR)$(man3dir)/zlib.3
+ cp $(SRCDIR)zlib.3 $(DESTDIR)$(man3dir)
chmod 644 $(DESTDIR)$(man3dir)/zlib.3
+ rm -f $(DESTDIR)$(pkgconfigdir)/zlib.pc
cp zlib.pc $(DESTDIR)$(pkgconfigdir)
chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc
# The ranlib in install is needed on NeXTSTEP which checks file times
install: install-libs
-@if [ ! -d $(DESTDIR)$(includedir) ]; then mkdir -p $(DESTDIR)$(includedir); fi
- cp zlib.h zconf.h $(DESTDIR)$(includedir)
+ rm -f $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
+ cp $(SRCDIR)zlib.h zconf.h $(DESTDIR)$(includedir)
chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
uninstall:
docs: zlib.3.pdf
-zlib.3.pdf: zlib.3
- groff -mandoc -f H -T ps zlib.3 | ps2pdf - zlib.3.pdf
+zlib.3.pdf: $(SRCDIR)zlib.3
+ groff -mandoc -f H -T ps $(SRCDIR)zlib.3 | ps2pdf - $@
-zconf.h.cmakein: zconf.h.in
+zconf.h.cmakein: $(SRCDIR)zconf.h.in
-@ TEMPFILE=zconfh_$$; \
echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
- sed -f $$TEMPFILE zconf.h.in > zconf.h.cmakein &&\
- touch -r zconf.h.in zconf.h.cmakein &&\
+ sed -f $$TEMPFILE $(SRCDIR)zconf.h.in > $@ &&\
+ touch -r $(SRCDIR)zconf.h.in $@ &&\
rm $$TEMPFILE
-zconf: zconf.h.in
- cp -p zconf.h.in zconf.h
+zconf: $(SRCDIR)zconf.h.in
+ cp -p $(SRCDIR)zconf.h.in zconf.h
mostlyclean: clean
clean:
distclean: clean zconf zconf.h.cmakein docs
rm -f Makefile zlib.pc configure.log
-@rm -f .DS_Store
- -@printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile
- -@printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile
- -@touch -r Makefile.in Makefile
+ @if [ -f Makefile.in ]; then \
+ printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile ; \
+ printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile ; \
+ touch -r $(SRCDIR)Makefile.in Makefile ; fi
+ @if [ ! -f zconf.h.in ]; then rm -f zconf.h zconf.h.cmakein ; fi
+ @if [ ! -f zlib.3 ]; then rm -f zlib.3.pdf ; fi
tags:
- etags *.[ch]
-
-depend:
- makedepend -- $(CFLAGS) -- *.[ch]
-
-# DO NOT DELETE THIS LINE -- make depend depends on it.
-
-adler32.o zutil.o: zutil.h zlib.h zconf.h
-gzclose.o gzlib.o gzread.o gzwrite.o: zlib.h zconf.h gzguts.h
-compress.o example.o minigzip.o uncompr.o: zlib.h zconf.h
-crc32.o: zutil.h zlib.h zconf.h crc32.h
-deflate.o: deflate.h zutil.h zlib.h zconf.h
-infback.o inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h inffixed.h
-inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
-inftrees.o: zutil.h zlib.h zconf.h inftrees.h
-trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
-
-adler32.lo zutil.lo: zutil.h zlib.h zconf.h
-gzclose.lo gzlib.lo gzread.lo gzwrite.lo: zlib.h zconf.h gzguts.h
-compress.lo example.lo minigzip.lo uncompr.lo: zlib.h zconf.h
-crc32.lo: zutil.h zlib.h zconf.h crc32.h
-deflate.lo: deflate.h zutil.h zlib.h zconf.h
-infback.lo inflate.lo: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h inffixed.h
-inffast.lo: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
-inftrees.lo: zutil.h zlib.h zconf.h inftrees.h
-trees.lo: deflate.h zutil.h zlib.h zconf.h trees.h
+ etags $(SRCDIR)*.[ch]
+
+adler32.o zutil.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+compress.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
+crc32.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+deflate.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+infback.o inflate.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+inffast.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
+inftrees.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
+trees.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
+
+adler32.lo zutil.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
+crc32.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+deflate.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+infback.lo inflate.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+inffast.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
+inftrees.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
+trees.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
ZLIB DATA COMPRESSION LIBRARY
-zlib 1.2.8 is a general purpose data compression library. All the code is
+zlib 1.2.11 is a general purpose data compression library. All the code is
thread safe. The data format used by the zlib library is described by RFCs
(Request for Comments) 1950 to 1952 in the files
http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
issue of Dr. Dobb's Journal; a copy of the article is available at
http://marknelson.us/1997/01/01/zlib-engine/ .
-The changes made in version 1.2.8 are documented in the file ChangeLog.
+The changes made in version 1.2.11 are documented in the file ChangeLog.
Unsupported third party contributions are provided in directory contrib/ .
Copyright notice:
- (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ (C) 1995-2017 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
/* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-2011 Mark Adler
+ * Copyright (C) 1995-2011, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "zutil.h"
-#define local static
-
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
-#define BASE 65521 /* largest prime smaller than 65536 */
+#define BASE 65521U /* largest prime smaller than 65536 */
#define NMAX 5552
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
#endif
/* ========================================================================= */
-uLong ZEXPORT adler32(adler, buf, len)
+uLong ZEXPORT adler32_z(adler, buf, len)
uLong adler;
const Bytef *buf;
- uInt len;
+ z_size_t len;
{
unsigned long sum2;
unsigned n;
}
/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+ uLong adler;
+ const Bytef *buf;
+ uInt len;
+{
+ return adler32_z(adler, buf, len);
+}
+
+/* ========================================================================= */
local uLong adler32_combine_(adler1, adler2, len2)
uLong adler1;
uLong adler2;
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
if (sum1 >= BASE) sum1 -= BASE;
if (sum1 >= BASE) sum1 -= BASE;
- if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
+ if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
if (sum2 >= BASE) sum2 -= BASE;
return sum1 | (sum2 << 16);
}
/* compress.c -- compress a memory buffer
- * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
{
z_stream stream;
int err;
+ const uInt max = (uInt)-1;
+ uLong left;
- stream.next_in = (z_const Bytef *)source;
- stream.avail_in = (uInt)sourceLen;
-#ifdef MAXSEG_64K
- /* Check for source > 64K on 16-bit machine: */
- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-#endif
- stream.next_out = dest;
- stream.avail_out = (uInt)*destLen;
- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+ left = *destLen;
+ *destLen = 0;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
err = deflateInit(&stream, level);
if (err != Z_OK) return err;
- err = deflate(&stream, Z_FINISH);
- if (err != Z_STREAM_END) {
- deflateEnd(&stream);
- return err == Z_OK ? Z_BUF_ERROR : err;
- }
- *destLen = stream.total_out;
+ stream.next_out = dest;
+ stream.avail_out = 0;
+ stream.next_in = (z_const Bytef *)source;
+ stream.avail_in = 0;
+
+ do {
+ if (stream.avail_out == 0) {
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
+ left -= stream.avail_out;
+ }
+ if (stream.avail_in == 0) {
+ stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+ sourceLen -= stream.avail_in;
+ }
+ err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+ } while (err == Z_OK);
- err = deflateEnd(&stream);
- return err;
+ *destLen = stream.total_out;
+ deflateEnd(&stream);
+ return err == Z_STREAM_END ? Z_OK : err;
}
/* ===========================================================================
echo $0 $* >> configure.log
date >> configure.log
+# get source directory
+SRCDIR=`dirname $0`
+if test $SRCDIR = "."; then
+ ZINC=""
+ ZINCOUT="-I."
+ SRCDIR=""
+else
+ ZINC='-include zconf.h'
+ ZINCOUT='-I. -I$(SRCDIR)'
+ SRCDIR="$SRCDIR/"
+fi
+
# set command prefix for cross-compilation
if [ -n "${CHOST}" ]; then
uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`"
STATICLIB=libz.a
# extract zlib version numbers from zlib.h
-VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`
-VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < zlib.h`
-VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < zlib.h`
-VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < zlib.h`
+VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}zlib.h`
+VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < ${SRCDIR}zlib.h`
+VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
+VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
# establish commands for library building
if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
zconst=0
build64=0
gcc=0
+warn=0
+debug=0
old_cc="$CC"
old_cflags="$CFLAGS"
OBJC='$(OBJZ) $(OBJG)'
--sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
--localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
-c* | --const) zconst=1; shift ;;
+ -w* | --warn) warn=1; shift ;;
+ -d* | --debug) debug=1; shift ;;
*)
echo "unknown option: $1" | tee -a configure.log
echo "$0 --help for help" | tee -a configure.log
esac
case `$cc -v 2>&1` in
*gcc*) gcc=1 ;;
+ *clang*) gcc=1 ;;
esac
show $cc -c $test.c
if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
echo ... using gcc >> configure.log
CC="$cc"
- CFLAGS="${CFLAGS--O3} ${ARCHS}"
+ CFLAGS="${CFLAGS--O3}"
SFLAGS="${CFLAGS--O3} -fPIC"
- LDFLAGS="${LDFLAGS} ${ARCHS}"
+ if test "$ARCHS"; then
+ CFLAGS="${CFLAGS} ${ARCHS}"
+ LDFLAGS="${LDFLAGS} ${ARCHS}"
+ fi
if test $build64 -eq 1; then
CFLAGS="${CFLAGS} -m64"
SFLAGS="${SFLAGS} -m64"
fi
- if test "${ZLIBGCCWARN}" = "YES"; then
+ if test "$warn" -eq 1; then
if test "$zconst" -eq 1; then
CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST"
else
CFLAGS="${CFLAGS} -Wall -Wextra -pedantic"
fi
fi
+ if test $debug -eq 1; then
+ CFLAGS="${CFLAGS} -DZLIB_DEBUG"
+ SFLAGS="${SFLAGS} -DZLIB_DEBUG"
+ fi
if test -z "$uname"; then
uname=`(uname -s || echo unknown) 2>/dev/null`
fi
case "$uname" in
Linux* | linux* | GNU | GNU/* | solaris*)
- LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"} ;;
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"} ;;
*BSD | *bsd* | DragonFly)
- LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"}
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"}
LDCONFIG="ldconfig -m" ;;
CYGWIN* | Cygwin* | cygwin* | OS/2*)
EXE='.exe' ;;
esac
fi
fi
+ if test -n "$ZINC"; then
+ ZINC='-I- -I. -I$(SRCDIR)'
+ fi
;;
SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"}
CFLAGS=${CFLAGS-"-O2"}
}
echo - using any output from compiler to indicate an error >> configure.log
else
-try()
-{
- show $*
- ( $* ) >> configure.log 2>&1
- ret=$?
- if test $ret -ne 0; then
- echo "(exit code "$ret")" >> configure.log
- fi
- return $ret
-}
+ try()
+ {
+ show $*
+ ( $* ) >> configure.log 2>&1
+ ret=$?
+ if test $ret -ne 0; then
+ echo "(exit code "$ret")" >> configure.log
+ fi
+ return $ret
+ }
fi
tryboth()
echo >> configure.log
+# check for size_t
+cat > $test.c <<EOF
+#include <stdio.h>
+#include <stdlib.h>
+size_t dummy = 0;
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for size_t... Yes." | tee -a configure.log
+ need_sizet=0
+else
+ echo "Checking for size_t... No." | tee -a configure.log
+ need_sizet=1
+fi
+
+echo >> configure.log
+
+# find the size_t integer type, if needed
+if test $need_sizet -eq 1; then
+ cat > $test.c <<EOF
+long long dummy = 0;
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for long long... Yes." | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ if (sizeof(void *) <= sizeof(int)) puts("int");
+ else if (sizeof(void *) <= sizeof(long)) puts("long");
+ else puts("z_longlong");
+ return 0;
+}
+EOF
+ else
+ echo "Checking for long long... No." | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ if (sizeof(void *) <= sizeof(int)) puts("int");
+ else puts("long");
+ return 0;
+}
+EOF
+ fi
+ if try $CC $CFLAGS -o $test $test.c; then
+ sizet=`./$test`
+ echo "Checking for a pointer-size integer type..." $sizet"." | tee -a configure.log
+ else
+ echo "Failed to find a pointer-size integer type." | tee -a configure.log
+ leave 1
+ fi
+fi
+
+if test $need_sizet -eq 1; then
+ CFLAGS="${CFLAGS} -DNO_SIZE_T=${sizet}"
+ SFLAGS="${SFLAGS} -DNO_SIZE_T=${sizet}"
+fi
+
+echo >> configure.log
+
# check for large file support, and if none, check for fseeko()
cat > $test.c <<EOF
#include <sys/types.h>
fi
# copy clean zconf.h for subsequent edits
-cp -p zconf.h.in zconf.h
+cp -p ${SRCDIR}zconf.h.in zconf.h
echo >> configure.log
echo TEST = $TEST >> configure.log
echo VER = $VER >> configure.log
echo Z_U4 = $Z_U4 >> configure.log
+echo SRCDIR = $SRCDIR >> configure.log
echo exec_prefix = $exec_prefix >> configure.log
echo includedir = $includedir >> configure.log
echo libdir = $libdir >> configure.log
echo uname = $uname >> configure.log
# udpate Makefile with the configure results
-sed < Makefile.in "
+sed < ${SRCDIR}Makefile.in "
/^CC *=/s#=.*#=$CC#
/^CFLAGS *=/s#=.*#=$CFLAGS#
/^SFLAGS *=/s#=.*#=$SFLAGS#
/^LDCONFIG *=/s#=.*#=$LDCONFIG#
/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
/^EXE *=/s#=.*#=$EXE#
+/^SRCDIR *=/s#=.*#=$SRCDIR#
+/^ZINC *=/s#=.*#=$ZINC#
+/^ZINCOUT *=/s#=.*#=$ZINCOUT#
/^prefix *=/s#=.*#=$prefix#
/^exec_prefix *=/s#=.*#=$exec_prefix#
/^libdir *=/s#=.*#=$libdir#
" > Makefile
# create zlib.pc with the configure results
-sed < zlib.pc.in "
+sed < ${SRCDIR}zlib.pc.in "
/^CC *=/s#=.*#=$CC#
/^CFLAGS *=/s#=.*#=$CFLAGS#
/^CPP *=/s#=.*#=$CPP#
/* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
+ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
#include "zutil.h" /* for STDC and FAR definitions */
-#define local static
-
/* Definitions for doing the crc four data bytes at a time. */
#if !defined(NOBYFOUR) && defined(Z_U4)
# define BYFOUR
#endif
#ifdef BYFOUR
local unsigned long crc32_little OF((unsigned long,
- const unsigned char FAR *, unsigned));
+ const unsigned char FAR *, z_size_t));
local unsigned long crc32_big OF((unsigned long,
- const unsigned char FAR *, unsigned));
+ const unsigned char FAR *, z_size_t));
# define TBLS 8
#else
# define TBLS 1
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
/* ========================================================================= */
-unsigned long ZEXPORT crc32(crc, buf, len)
+unsigned long ZEXPORT crc32_z(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
- uInt len;
+ z_size_t len;
{
if (buf == Z_NULL) return 0UL;
return crc ^ 0xffffffffUL;
}
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ uInt len;
+{
+ return crc32_z(crc, buf, len);
+}
+
#ifdef BYFOUR
+/*
+ This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
+ integer pointer type. This violates the strict aliasing rule, where a
+ compiler can assume, for optimization purposes, that two pointers to
+ fundamentally different types won't ever point to the same memory. This can
+ manifest as a problem only if one of the pointers is written to. This code
+ only reads from those pointers. So long as this code remains isolated in
+ this compilation unit, there won't be a problem. For this reason, this code
+ should not be copied and pasted into a compilation unit in which other code
+ writes to the buffer that is passed to these routines.
+ */
+
/* ========================================================================= */
#define DOLIT4 c ^= *buf4++; \
c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
local unsigned long crc32_little(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
- unsigned len;
+ z_size_t len;
{
register z_crc_t c;
register const z_crc_t FAR *buf4;
}
/* ========================================================================= */
-#define DOBIG4 c ^= *++buf4; \
+#define DOBIG4 c ^= *buf4++; \
c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
local unsigned long crc32_big(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
- unsigned len;
+ z_size_t len;
{
register z_crc_t c;
register const z_crc_t FAR *buf4;
}
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
- buf4--;
while (len >= 32) {
DOBIG32;
len -= 32;
DOBIG4;
len -= 4;
}
- buf4++;
buf = (const unsigned char FAR *)buf4;
if (len) do {
/* deflate.c -- compress data using the deflation algorithm
- * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ * Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "deflate.h"
const char deflate_copyright[] =
- " deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ";
+ " deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler ";
/*
If you use the zlib library in a product, an acknowledgment is welcome
in the documentation of your product. If for some reason you cannot
typedef block_state (*compress_func) OF((deflate_state *s, int flush));
/* Compression function. Returns the block state after the call. */
+local int deflateStateCheck OF((z_streamp strm));
+local void slide_hash OF((deflate_state *s));
local void fill_window OF((deflate_state *s));
local block_state deflate_stored OF((deflate_state *s, int flush));
local block_state deflate_fast OF((deflate_state *s, int flush));
local void lm_init OF((deflate_state *s));
local void putShortMSB OF((deflate_state *s, uInt b));
local void flush_pending OF((z_streamp strm));
-local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
+local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
#ifdef ASMV
+# pragma message("Assembler code may have bugs -- use at your own risk")
void match_init OF((void)); /* asm code initialization */
uInt longest_match OF((deflate_state *s, IPos cur_match));
#else
local uInt longest_match OF((deflate_state *s, IPos cur_match));
#endif
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
local void check_match OF((deflate_state *s, IPos start, IPos match,
int length));
#endif
* meaning.
*/
-#define EQUAL 0
-/* result of memcmp for equal strings */
-
-#ifndef NO_DUMMY_DECL
-struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
-#endif
-
/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
-#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0))
+#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
/* ===========================================================================
* Update a hash value with the given input byte
- * IN assertion: all calls to to UPDATE_HASH are made with consecutive
- * input characters, so that a running hash key can be computed from the
- * previous key instead of complete recalculation each time.
+ * IN assertion: all calls to UPDATE_HASH are made with consecutive input
+ * characters, so that a running hash key can be computed from the previous
+ * key instead of complete recalculation each time.
*/
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
* the previous length of the hash chain.
* If this file is compiled with -DFASTEST, the compression level is forced
* to 1, and no hash chains are maintained.
- * IN assertion: all calls to to INSERT_STRING are made with consecutive
- * input characters and the first MIN_MATCH bytes of str are valid
- * (except for the last MIN_MATCH-1 bytes of the input file).
+ * IN assertion: all calls to INSERT_STRING are made with consecutive input
+ * characters and the first MIN_MATCH bytes of str are valid (except for
+ * the last MIN_MATCH-1 bytes of the input file).
*/
#ifdef FASTEST
#define INSERT_STRING(s, str, match_head) \
s->head[s->hash_size-1] = NIL; \
zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+/* ===========================================================================
+ * Slide the hash table when sliding the window down (could be avoided with 32
+ * bit values at the expense of memory usage). We slide even when level == 0 to
+ * keep the hash table consistent if we switch back to level > 0 later.
+ */
+local void slide_hash(s)
+ deflate_state *s;
+{
+ unsigned n, m;
+ Posf *p;
+ uInt wsize = s->w_size;
+
+ n = s->hash_size;
+ p = &s->head[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m - wsize : NIL);
+ } while (--n);
+ n = wsize;
+#ifndef FASTEST
+ p = &s->prev[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m - wsize : NIL);
+ /* If n is not on any hash chain, prev[n] is garbage but
+ * its value will never be used.
+ */
+ } while (--n);
+#endif
+}
+
/* ========================================================================= */
int ZEXPORT deflateInit_(strm, level, version, stream_size)
z_streamp strm;
#endif
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
- strategy < 0 || strategy > Z_FIXED) {
+ strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {
return Z_STREAM_ERROR;
}
if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
if (s == Z_NULL) return Z_MEM_ERROR;
strm->state = (struct internal_state FAR *)s;
s->strm = strm;
+ s->status = INIT_STATE; /* to pass state test in deflateReset() */
s->wrap = wrap;
s->gzhead = Z_NULL;
- s->w_bits = windowBits;
+ s->w_bits = (uInt)windowBits;
s->w_size = 1 << s->w_bits;
s->w_mask = s->w_size - 1;
- s->hash_bits = memLevel + 7;
+ s->hash_bits = (uInt)memLevel + 7;
s->hash_size = 1 << s->hash_bits;
s->hash_mask = s->hash_size - 1;
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
return deflateReset(strm);
}
+/* =========================================================================
+ * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+ */
+local int deflateStateCheck (strm)
+ z_streamp strm;
+{
+ deflate_state *s;
+ if (strm == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+ return 1;
+ s = strm->state;
+ if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
+#ifdef GZIP
+ s->status != GZIP_STATE &&
+#endif
+ s->status != EXTRA_STATE &&
+ s->status != NAME_STATE &&
+ s->status != COMMENT_STATE &&
+ s->status != HCRC_STATE &&
+ s->status != BUSY_STATE &&
+ s->status != FINISH_STATE))
+ return 1;
+ return 0;
+}
+
/* ========================================================================= */
int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
z_streamp strm;
unsigned avail;
z_const unsigned char *next;
- if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
+ if (deflateStateCheck(strm) || dictionary == Z_NULL)
return Z_STREAM_ERROR;
s = strm->state;
wrap = s->wrap;
}
/* ========================================================================= */
+int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
+ z_streamp strm;
+ Bytef *dictionary;
+ uInt *dictLength;
+{
+ deflate_state *s;
+ uInt len;
+
+ if (deflateStateCheck(strm))
+ return Z_STREAM_ERROR;
+ s = strm->state;
+ len = s->strstart + s->lookahead;
+ if (len > s->w_size)
+ len = s->w_size;
+ if (dictionary != Z_NULL && len)
+ zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
+ if (dictLength != Z_NULL)
+ *dictLength = len;
+ return Z_OK;
+}
+
+/* ========================================================================= */
int ZEXPORT deflateResetKeep (strm)
z_streamp strm;
{
deflate_state *s;
- if (strm == Z_NULL || strm->state == Z_NULL ||
- strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
+ if (deflateStateCheck(strm)) {
return Z_STREAM_ERROR;
}
if (s->wrap < 0) {
s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
}
- s->status = s->wrap ? INIT_STATE : BUSY_STATE;
+ s->status =
+#ifdef GZIP
+ s->wrap == 2 ? GZIP_STATE :
+#endif
+ s->wrap ? INIT_STATE : BUSY_STATE;
strm->adler =
#ifdef GZIP
s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
z_streamp strm;
gz_headerp head;
{
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
- if (strm->state->wrap != 2) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm) || strm->state->wrap != 2)
+ return Z_STREAM_ERROR;
strm->state->gzhead = head;
return Z_OK;
}
int *bits;
z_streamp strm;
{
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
if (pending != Z_NULL)
*pending = strm->state->pending;
if (bits != Z_NULL)
deflate_state *s;
int put;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
return Z_BUF_ERROR;
{
deflate_state *s;
compress_func func;
- int err = Z_OK;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
#ifdef FASTEST
func = configuration_table[s->level].func;
if ((strategy != s->strategy || func != configuration_table[level].func) &&
- strm->total_in != 0) {
+ s->high_water) {
/* Flush the last buffer: */
- err = deflate(strm, Z_BLOCK);
- if (err == Z_BUF_ERROR && s->pending == 0)
- err = Z_OK;
+ int err = deflate(strm, Z_BLOCK);
+ if (err == Z_STREAM_ERROR)
+ return err;
+ if (strm->avail_out == 0)
+ return Z_BUF_ERROR;
}
if (s->level != level) {
+ if (s->level == 0 && s->matches != 0) {
+ if (s->matches == 1)
+ slide_hash(s);
+ else
+ CLEAR_HASH(s);
+ s->matches = 0;
+ }
s->level = level;
s->max_lazy_match = configuration_table[level].max_lazy;
s->good_match = configuration_table[level].good_length;
s->max_chain_length = configuration_table[level].max_chain;
}
s->strategy = strategy;
- return err;
+ return Z_OK;
}
/* ========================================================================= */
{
deflate_state *s;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
- s->good_match = good_length;
- s->max_lazy_match = max_lazy;
+ s->good_match = (uInt)good_length;
+ s->max_lazy_match = (uInt)max_lazy;
s->nice_match = nice_length;
- s->max_chain_length = max_chain;
+ s->max_chain_length = (uInt)max_chain;
return Z_OK;
}
{
deflate_state *s;
uLong complen, wraplen;
- Bytef *str;
/* conservative upper bound for compressed data */
complen = sourceLen +
((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
/* if can't get parameters, return conservative bound plus zlib wrapper */
- if (strm == Z_NULL || strm->state == Z_NULL)
+ if (deflateStateCheck(strm))
return complen + 6;
/* compute wrapper length */
case 1: /* zlib wrapper */
wraplen = 6 + (s->strstart ? 4 : 0);
break;
+#ifdef GZIP
case 2: /* gzip wrapper */
wraplen = 18;
if (s->gzhead != Z_NULL) { /* user-supplied gzip header */
+ Bytef *str;
if (s->gzhead->extra != Z_NULL)
wraplen += 2 + s->gzhead->extra_len;
str = s->gzhead->name;
wraplen += 2;
}
break;
+#endif
default: /* for compiler happiness */
wraplen = 6;
}
}
/* =========================================================================
- * Flush as much pending output as possible. All deflate() output goes
- * through this function so some applications may wish to modify it
- * to avoid allocating a large strm->next_out buffer and copying into it.
- * (See also read_buf()).
+ * Flush as much pending output as possible. All deflate() output, except for
+ * some deflate_stored() output, goes through this function so some
+ * applications may wish to modify it to avoid allocating a large
+ * strm->next_out buffer and copying into it. (See also read_buf()).
*/
local void flush_pending(strm)
z_streamp strm;
strm->next_out += len;
s->pending_out += len;
strm->total_out += len;
- strm->avail_out -= len;
- s->pending -= len;
+ strm->avail_out -= len;
+ s->pending -= len;
if (s->pending == 0) {
s->pending_out = s->pending_buf;
}
}
+/* ===========================================================================
+ * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
+ */
+#define HCRC_UPDATE(beg) \
+ do { \
+ if (s->gzhead->hcrc && s->pending > (beg)) \
+ strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
+ s->pending - (beg)); \
+ } while (0)
+
/* ========================================================================= */
int ZEXPORT deflate (strm, flush)
z_streamp strm;
int old_flush; /* value of flush param for previous deflate call */
deflate_state *s;
- if (strm == Z_NULL || strm->state == Z_NULL ||
- flush > Z_BLOCK || flush < 0) {
+ if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
return Z_STREAM_ERROR;
}
s = strm->state;
if (strm->next_out == Z_NULL ||
- (strm->next_in == Z_NULL && strm->avail_in != 0) ||
+ (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
(s->status == FINISH_STATE && flush != Z_FINISH)) {
ERR_RETURN(strm, Z_STREAM_ERROR);
}
if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
- s->strm = strm; /* just in case */
old_flush = s->last_flush;
s->last_flush = flush;
+ /* Flush as much pending output as possible */
+ if (s->pending != 0) {
+ flush_pending(strm);
+ if (strm->avail_out == 0) {
+ /* Since avail_out is 0, deflate will be called again with
+ * more output space, but possibly with both pending and
+ * avail_in equal to zero. There won't be anything to do,
+ * but this is not an error situation so make sure we
+ * return OK instead of BUF_ERROR at next call of deflate:
+ */
+ s->last_flush = -1;
+ return Z_OK;
+ }
+
+ /* Make sure there is something to do and avoid duplicate consecutive
+ * flushes. For repeated and useless calls with Z_FINISH, we keep
+ * returning Z_STREAM_END instead of Z_BUF_ERROR.
+ */
+ } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
+ flush != Z_FINISH) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
+ /* User must not provide more input after the first FINISH: */
+ if (s->status == FINISH_STATE && strm->avail_in != 0) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
/* Write the header */
if (s->status == INIT_STATE) {
-#ifdef GZIP
- if (s->wrap == 2) {
- strm->adler = crc32(0L, Z_NULL, 0);
- put_byte(s, 31);
- put_byte(s, 139);
- put_byte(s, 8);
- if (s->gzhead == Z_NULL) {
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, 0);
- put_byte(s, s->level == 9 ? 2 :
- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
- 4 : 0));
- put_byte(s, OS_CODE);
- s->status = BUSY_STATE;
- }
- else {
- put_byte(s, (s->gzhead->text ? 1 : 0) +
- (s->gzhead->hcrc ? 2 : 0) +
- (s->gzhead->extra == Z_NULL ? 0 : 4) +
- (s->gzhead->name == Z_NULL ? 0 : 8) +
- (s->gzhead->comment == Z_NULL ? 0 : 16)
- );
- put_byte(s, (Byte)(s->gzhead->time & 0xff));
- put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
- put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
- put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
- put_byte(s, s->level == 9 ? 2 :
- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
- 4 : 0));
- put_byte(s, s->gzhead->os & 0xff);
- if (s->gzhead->extra != Z_NULL) {
- put_byte(s, s->gzhead->extra_len & 0xff);
- put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
- }
- if (s->gzhead->hcrc)
- strm->adler = crc32(strm->adler, s->pending_buf,
- s->pending);
- s->gzindex = 0;
- s->status = EXTRA_STATE;
- }
- }
+ /* zlib header */
+ uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+ uInt level_flags;
+
+ if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+ level_flags = 0;
+ else if (s->level < 6)
+ level_flags = 1;
+ else if (s->level == 6)
+ level_flags = 2;
else
-#endif
- {
- uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
- uInt level_flags;
-
- if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
- level_flags = 0;
- else if (s->level < 6)
- level_flags = 1;
- else if (s->level == 6)
- level_flags = 2;
- else
- level_flags = 3;
- header |= (level_flags << 6);
- if (s->strstart != 0) header |= PRESET_DICT;
- header += 31 - (header % 31);
+ level_flags = 3;
+ header |= (level_flags << 6);
+ if (s->strstart != 0) header |= PRESET_DICT;
+ header += 31 - (header % 31);
+
+ putShortMSB(s, header);
+ /* Save the adler32 of the preset dictionary: */
+ if (s->strstart != 0) {
+ putShortMSB(s, (uInt)(strm->adler >> 16));
+ putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ }
+ strm->adler = adler32(0L, Z_NULL, 0);
+ s->status = BUSY_STATE;
+
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+#ifdef GZIP
+ if (s->status == GZIP_STATE) {
+ /* gzip header */
+ strm->adler = crc32(0L, Z_NULL, 0);
+ put_byte(s, 31);
+ put_byte(s, 139);
+ put_byte(s, 8);
+ if (s->gzhead == Z_NULL) {
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, OS_CODE);
s->status = BUSY_STATE;
- putShortMSB(s, header);
- /* Save the adler32 of the preset dictionary: */
- if (s->strstart != 0) {
- putShortMSB(s, (uInt)(strm->adler >> 16));
- putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+ else {
+ put_byte(s, (s->gzhead->text ? 1 : 0) +
+ (s->gzhead->hcrc ? 2 : 0) +
+ (s->gzhead->extra == Z_NULL ? 0 : 4) +
+ (s->gzhead->name == Z_NULL ? 0 : 8) +
+ (s->gzhead->comment == Z_NULL ? 0 : 16)
+ );
+ put_byte(s, (Byte)(s->gzhead->time & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, s->gzhead->os & 0xff);
+ if (s->gzhead->extra != Z_NULL) {
+ put_byte(s, s->gzhead->extra_len & 0xff);
+ put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
}
- strm->adler = adler32(0L, Z_NULL, 0);
+ if (s->gzhead->hcrc)
+ strm->adler = crc32(strm->adler, s->pending_buf,
+ s->pending);
+ s->gzindex = 0;
+ s->status = EXTRA_STATE;
}
}
-#ifdef GZIP
if (s->status == EXTRA_STATE) {
if (s->gzhead->extra != Z_NULL) {
- uInt beg = s->pending; /* start of bytes to update crc */
-
- while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
- if (s->pending == s->pending_buf_size) {
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- flush_pending(strm);
- beg = s->pending;
- if (s->pending == s->pending_buf_size)
- break;
+ ulg beg = s->pending; /* start of bytes to update crc */
+ uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
+ while (s->pending + left > s->pending_buf_size) {
+ uInt copy = s->pending_buf_size - s->pending;
+ zmemcpy(s->pending_buf + s->pending,
+ s->gzhead->extra + s->gzindex, copy);
+ s->pending = s->pending_buf_size;
+ HCRC_UPDATE(beg);
+ s->gzindex += copy;
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
}
- put_byte(s, s->gzhead->extra[s->gzindex]);
- s->gzindex++;
- }
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- if (s->gzindex == s->gzhead->extra_len) {
- s->gzindex = 0;
- s->status = NAME_STATE;
+ beg = 0;
+ left -= copy;
}
+ zmemcpy(s->pending_buf + s->pending,
+ s->gzhead->extra + s->gzindex, left);
+ s->pending += left;
+ HCRC_UPDATE(beg);
+ s->gzindex = 0;
}
- else
- s->status = NAME_STATE;
+ s->status = NAME_STATE;
}
if (s->status == NAME_STATE) {
if (s->gzhead->name != Z_NULL) {
- uInt beg = s->pending; /* start of bytes to update crc */
+ ulg beg = s->pending; /* start of bytes to update crc */
int val;
-
do {
if (s->pending == s->pending_buf_size) {
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
+ HCRC_UPDATE(beg);
flush_pending(strm);
- beg = s->pending;
- if (s->pending == s->pending_buf_size) {
- val = 1;
- break;
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
}
+ beg = 0;
}
val = s->gzhead->name[s->gzindex++];
put_byte(s, val);
} while (val != 0);
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- if (val == 0) {
- s->gzindex = 0;
- s->status = COMMENT_STATE;
- }
+ HCRC_UPDATE(beg);
+ s->gzindex = 0;
}
- else
- s->status = COMMENT_STATE;
+ s->status = COMMENT_STATE;
}
if (s->status == COMMENT_STATE) {
if (s->gzhead->comment != Z_NULL) {
- uInt beg = s->pending; /* start of bytes to update crc */
+ ulg beg = s->pending; /* start of bytes to update crc */
int val;
-
do {
if (s->pending == s->pending_buf_size) {
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
+ HCRC_UPDATE(beg);
flush_pending(strm);
- beg = s->pending;
- if (s->pending == s->pending_buf_size) {
- val = 1;
- break;
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
}
+ beg = 0;
}
val = s->gzhead->comment[s->gzindex++];
put_byte(s, val);
} while (val != 0);
- if (s->gzhead->hcrc && s->pending > beg)
- strm->adler = crc32(strm->adler, s->pending_buf + beg,
- s->pending - beg);
- if (val == 0)
- s->status = HCRC_STATE;
+ HCRC_UPDATE(beg);
}
- else
- s->status = HCRC_STATE;
+ s->status = HCRC_STATE;
}
if (s->status == HCRC_STATE) {
if (s->gzhead->hcrc) {
- if (s->pending + 2 > s->pending_buf_size)
+ if (s->pending + 2 > s->pending_buf_size) {
flush_pending(strm);
- if (s->pending + 2 <= s->pending_buf_size) {
- put_byte(s, (Byte)(strm->adler & 0xff));
- put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
- strm->adler = crc32(0L, Z_NULL, 0);
- s->status = BUSY_STATE;
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
}
+ put_byte(s, (Byte)(strm->adler & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+ strm->adler = crc32(0L, Z_NULL, 0);
}
- else
- s->status = BUSY_STATE;
- }
-#endif
+ s->status = BUSY_STATE;
- /* Flush as much pending output as possible */
- if (s->pending != 0) {
+ /* Compression must start with an empty pending buffer */
flush_pending(strm);
- if (strm->avail_out == 0) {
- /* Since avail_out is 0, deflate will be called again with
- * more output space, but possibly with both pending and
- * avail_in equal to zero. There won't be anything to do,
- * but this is not an error situation so make sure we
- * return OK instead of BUF_ERROR at next call of deflate:
- */
+ if (s->pending != 0) {
s->last_flush = -1;
return Z_OK;
}
-
- /* Make sure there is something to do and avoid duplicate consecutive
- * flushes. For repeated and useless calls with Z_FINISH, we keep
- * returning Z_STREAM_END instead of Z_BUF_ERROR.
- */
- } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
- flush != Z_FINISH) {
- ERR_RETURN(strm, Z_BUF_ERROR);
- }
-
- /* User must not provide more input after the first FINISH: */
- if (s->status == FINISH_STATE && strm->avail_in != 0) {
- ERR_RETURN(strm, Z_BUF_ERROR);
}
+#endif
/* Start a new block or continue the current one.
*/
(flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
block_state bstate;
- bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
- (s->strategy == Z_RLE ? deflate_rle(s, flush) :
- (*(configuration_table[s->level].func))(s, flush));
+ bstate = s->level == 0 ? deflate_stored(s, flush) :
+ s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
+ s->strategy == Z_RLE ? deflate_rle(s, flush) :
+ (*(configuration_table[s->level].func))(s, flush);
if (bstate == finish_started || bstate == finish_done) {
s->status = FINISH_STATE;
}
}
}
- Assert(strm->avail_out > 0, "bug2");
if (flush != Z_FINISH) return Z_OK;
if (s->wrap <= 0) return Z_STREAM_END;
{
int status;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
status = strm->state->status;
- if (status != INIT_STATE &&
- status != EXTRA_STATE &&
- status != NAME_STATE &&
- status != COMMENT_STATE &&
- status != HCRC_STATE &&
- status != BUSY_STATE &&
- status != FINISH_STATE) {
- return Z_STREAM_ERROR;
- }
/* Deallocate in reverse order of allocations: */
TRY_FREE(strm, strm->state->pending_buf);
ushf *overlay;
- if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+ if (deflateStateCheck(source) || dest == Z_NULL) {
return Z_STREAM_ERROR;
}
* allocating a large strm->next_in buffer and copying from it.
* (See also flush_pending()).
*/
-local int read_buf(strm, buf, size)
+local unsigned read_buf(strm, buf, size)
z_streamp strm;
Bytef *buf;
unsigned size;
strm->next_in += len;
strm->total_in += len;
- return (int)len;
+ return len;
}
/* ===========================================================================
{
unsigned chain_length = s->max_chain_length;/* max hash chain length */
register Bytef *scan = s->window + s->strstart; /* current string */
- register Bytef *match; /* matched string */
+ register Bytef *match; /* matched string */
register int len; /* length of current match */
- int best_len = s->prev_length; /* best match length so far */
+ int best_len = (int)s->prev_length; /* best match length so far */
int nice_match = s->nice_match; /* stop if match long enough */
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
s->strstart - (IPos)MAX_DIST(s) : NIL;
/* Do not look for matches beyond the end of the input. This is necessary
* to make deflate deterministic.
*/
- if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+ if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
#endif /* FASTEST */
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
/* ===========================================================================
* Check that the match at match_start is indeed a match.
*/
}
#else
# define check_match(s, start, match, length)
-#endif /* DEBUG */
+#endif /* ZLIB_DEBUG */
/* ===========================================================================
* Fill the window when the lookahead becomes insufficient.
local void fill_window(s)
deflate_state *s;
{
- register unsigned n, m;
- register Posf *p;
+ unsigned n;
unsigned more; /* Amount of free space at the end of the window. */
uInt wsize = s->w_size;
*/
if (s->strstart >= wsize+MAX_DIST(s)) {
- zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
+ zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);
s->match_start -= wsize;
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
s->block_start -= (long) wsize;
-
- /* Slide the hash table (could be avoided with 32 bit values
- at the expense of memory usage). We slide even when level == 0
- to keep the hash table consistent if we switch back to level > 0
- later. (Using level 0 permanently is not an optimal usage of
- zlib, so we don't care about this pathological case.)
- */
- n = s->hash_size;
- p = &s->head[n];
- do {
- m = *--p;
- *p = (Pos)(m >= wsize ? m-wsize : NIL);
- } while (--n);
-
- n = wsize;
-#ifndef FASTEST
- p = &s->prev[n];
- do {
- m = *--p;
- *p = (Pos)(m >= wsize ? m-wsize : NIL);
- /* If n is not on any hash chain, prev[n] is garbage but
- * its value will never be used.
- */
- } while (--n);
-#endif
+ slide_hash(s);
more += wsize;
}
if (s->strm->avail_in == 0) break;
if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
}
+/* Maximum stored block length in deflate format (not including header). */
+#define MAX_STORED 65535
+
+/* Minimum of a and b. */
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+
/* ===========================================================================
* Copy without compression as much as possible from the input stream, return
* the current block state.
- * This function does not insert new strings in the dictionary since
- * uncompressible data is probably not useful. This function is used
- * only for the level=0 compression option.
- * NOTE: this function should be optimized to avoid extra copying from
- * window to pending_buf.
+ *
+ * In case deflateParams() is used to later switch to a non-zero compression
+ * level, s->matches (otherwise unused when storing) keeps track of the number
+ * of hash table slides to perform. If s->matches is 1, then one hash table
+ * slide will be done when switching. If s->matches is 2, the maximum value
+ * allowed here, then the hash table will be cleared, since two or more slides
+ * is the same as a clear.
+ *
+ * deflate_stored() is written to minimize the number of times an input byte is
+ * copied. It is most efficient with large input and output buffers, which
+ * maximizes the opportunites to have a single copy from next_in to next_out.
*/
local block_state deflate_stored(s, flush)
deflate_state *s;
int flush;
{
- /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
- * to pending_buf_size, and each stored block has a 5 byte header:
+ /* Smallest worthy block size when not flushing or finishing. By default
+ * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+ * large input and output buffers, the stored block size will be larger.
*/
- ulg max_block_size = 0xffff;
- ulg max_start;
-
- if (max_block_size > s->pending_buf_size - 5) {
- max_block_size = s->pending_buf_size - 5;
- }
+ unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
- /* Copy as much as possible from input to output: */
- for (;;) {
- /* Fill the window as much as possible: */
- if (s->lookahead <= 1) {
-
- Assert(s->strstart < s->w_size+MAX_DIST(s) ||
- s->block_start >= (long)s->w_size, "slide too late");
+ /* Copy as many min_block or larger stored blocks directly to next_out as
+ * possible. If flushing, copy the remaining available input to next_out as
+ * stored blocks, if there is enough space.
+ */
+ unsigned len, left, have, last = 0;
+ unsigned used = s->strm->avail_in;
+ do {
+ /* Set len to the maximum size block that we can copy directly with the
+ * available input data and output space. Set left to how much of that
+ * would be copied from what's left in the window.
+ */
+ len = MAX_STORED; /* maximum deflate stored block length */
+ have = (s->bi_valid + 42) >> 3; /* number of header bytes */
+ if (s->strm->avail_out < have) /* need room for header */
+ break;
+ /* maximum stored block length that will fit in avail_out: */
+ have = s->strm->avail_out - have;
+ left = s->strstart - s->block_start; /* bytes left in window */
+ if (len > (ulg)left + s->strm->avail_in)
+ len = left + s->strm->avail_in; /* limit len to the input */
+ if (len > have)
+ len = have; /* limit len to the output */
+
+ /* If the stored block would be less than min_block in length, or if
+ * unable to copy all of the available input when flushing, then try
+ * copying to the window and the pending buffer instead. Also don't
+ * write an empty block when flushing -- deflate() does that.
+ */
+ if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
+ flush == Z_NO_FLUSH ||
+ len != left + s->strm->avail_in))
+ break;
- fill_window(s);
- if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
+ /* Make a dummy stored block in pending to get the header bytes,
+ * including any pending bits. This also updates the debugging counts.
+ */
+ last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
+ _tr_stored_block(s, (char *)0, 0L, last);
+
+ /* Replace the lengths in the dummy stored block with len. */
+ s->pending_buf[s->pending - 4] = len;
+ s->pending_buf[s->pending - 3] = len >> 8;
+ s->pending_buf[s->pending - 2] = ~len;
+ s->pending_buf[s->pending - 1] = ~len >> 8;
+
+ /* Write the stored block header bytes. */
+ flush_pending(s->strm);
+
+#ifdef ZLIB_DEBUG
+ /* Update debugging counts for the data about to be copied. */
+ s->compressed_len += len << 3;
+ s->bits_sent += len << 3;
+#endif
- if (s->lookahead == 0) break; /* flush the current block */
+ /* Copy uncompressed bytes from the window to next_out. */
+ if (left) {
+ if (left > len)
+ left = len;
+ zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+ s->strm->next_out += left;
+ s->strm->avail_out -= left;
+ s->strm->total_out += left;
+ s->block_start += left;
+ len -= left;
}
- Assert(s->block_start >= 0L, "block gone");
-
- s->strstart += s->lookahead;
- s->lookahead = 0;
-
- /* Emit a stored block if pending_buf will be full: */
- max_start = s->block_start + max_block_size;
- if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
- /* strstart == 0 is possible when wraparound on 16-bit machine */
- s->lookahead = (uInt)(s->strstart - max_start);
- s->strstart = (uInt)max_start;
- FLUSH_BLOCK(s, 0);
+
+ /* Copy uncompressed bytes directly from next_in to next_out, updating
+ * the check value.
+ */
+ if (len) {
+ read_buf(s->strm, s->strm->next_out, len);
+ s->strm->next_out += len;
+ s->strm->avail_out -= len;
+ s->strm->total_out += len;
}
- /* Flush if we may have to slide, otherwise block_start may become
- * negative and the data will be gone:
+ } while (last == 0);
+
+ /* Update the sliding window with the last s->w_size bytes of the copied
+ * data, or append all of the copied data to the existing window if less
+ * than s->w_size bytes were copied. Also update the number of bytes to
+ * insert in the hash tables, in the event that deflateParams() switches to
+ * a non-zero compression level.
+ */
+ used -= s->strm->avail_in; /* number of input bytes directly copied */
+ if (used) {
+ /* If any input was used, then no unused input remains in the window,
+ * therefore s->block_start == s->strstart.
*/
- if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
- FLUSH_BLOCK(s, 0);
+ if (used >= s->w_size) { /* supplant the previous history */
+ s->matches = 2; /* clear hash */
+ zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+ s->strstart = s->w_size;
}
+ else {
+ if (s->window_size - s->strstart <= used) {
+ /* Slide the window down. */
+ s->strstart -= s->w_size;
+ zmemcpy(s->window, s->window + s->w_size, s->strstart);
+ if (s->matches < 2)
+ s->matches++; /* add a pending slide_hash() */
+ }
+ zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+ s->strstart += used;
+ }
+ s->block_start = s->strstart;
+ s->insert += MIN(used, s->w_size - s->insert);
}
- s->insert = 0;
- if (flush == Z_FINISH) {
- FLUSH_BLOCK(s, 1);
+ if (s->high_water < s->strstart)
+ s->high_water = s->strstart;
+
+ /* If the last block was written to next_out, then done. */
+ if (last)
return finish_done;
+
+ /* If flushing and all input has been consumed, then done. */
+ if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
+ s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
+ return block_done;
+
+ /* Fill the window with any remaining input. */
+ have = s->window_size - s->strstart - 1;
+ if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
+ /* Slide the window down. */
+ s->block_start -= s->w_size;
+ s->strstart -= s->w_size;
+ zmemcpy(s->window, s->window + s->w_size, s->strstart);
+ if (s->matches < 2)
+ s->matches++; /* add a pending slide_hash() */
+ have += s->w_size; /* more space now */
}
- if ((long)s->strstart > s->block_start)
- FLUSH_BLOCK(s, 0);
- return block_done;
+ if (have > s->strm->avail_in)
+ have = s->strm->avail_in;
+ if (have) {
+ read_buf(s->strm, s->window + s->strstart, have);
+ s->strstart += have;
+ }
+ if (s->high_water < s->strstart)
+ s->high_water = s->strstart;
+
+ /* There was not enough avail_out to write a complete worthy or flushed
+ * stored block to next_out. Write a stored block to pending instead, if we
+ * have enough input for a worthy block, or if flushing and there is enough
+ * room for the remaining input as a stored block in the pending buffer.
+ */
+ have = (s->bi_valid + 42) >> 3; /* number of header bytes */
+ /* maximum stored block length that will fit in pending: */
+ have = MIN(s->pending_buf_size - have, MAX_STORED);
+ min_block = MIN(have, s->w_size);
+ left = s->strstart - s->block_start;
+ if (left >= min_block ||
+ ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
+ s->strm->avail_in == 0 && left <= have)) {
+ len = MIN(left, have);
+ last = flush == Z_FINISH && s->strm->avail_in == 0 &&
+ len == left ? 1 : 0;
+ _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
+ s->block_start += len;
+ flush_pending(s->strm);
+ }
+
+ /* We've done all we can with the available input and output. */
+ return last ? finish_started : need_more;
}
/* ===========================================================================
prev == *++scan && prev == *++scan &&
prev == *++scan && prev == *++scan &&
scan < strend);
- s->match_length = MAX_MATCH - (int)(strend - scan);
+ s->match_length = MAX_MATCH - (uInt)(strend - scan);
if (s->match_length > s->lookahead)
s->match_length = s->lookahead;
}
/* deflate.h -- internal compression state
- * Copyright (C) 1995-2012 Jean-loup Gailly
+ * Copyright (C) 1995-2016 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#define Buf_size 16
/* size of bit buffer in bi_buf */
-#define INIT_STATE 42
-#define EXTRA_STATE 69
-#define NAME_STATE 73
-#define COMMENT_STATE 91
-#define HCRC_STATE 103
-#define BUSY_STATE 113
-#define FINISH_STATE 666
+#define INIT_STATE 42 /* zlib header -> BUSY_STATE */
+#ifdef GZIP
+# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
+#endif
+#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
+#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
+#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
+#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
+#define BUSY_STATE 113 /* deflate -> FINISH_STATE */
+#define FINISH_STATE 666 /* stream complete */
/* Stream status */
typedef struct tree_desc_s {
ct_data *dyn_tree; /* the dynamic tree */
int max_code; /* largest code with non zero frequency */
- static_tree_desc *stat_desc; /* the corresponding static tree */
+ const static_tree_desc *stat_desc; /* the corresponding static tree */
} FAR tree_desc;
typedef ush Pos;
Bytef *pending_buf; /* output still pending */
ulg pending_buf_size; /* size of pending_buf */
Bytef *pending_out; /* next pending byte to output to the stream */
- uInt pending; /* nb of bytes in the pending buffer */
+ ulg pending; /* nb of bytes in the pending buffer */
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
gz_headerp gzhead; /* gzip header information to write */
- uInt gzindex; /* where in extra, name, or comment */
+ ulg gzindex; /* where in extra, name, or comment */
Byte method; /* can only be DEFLATED */
int last_flush; /* value of flush param for previous deflate call */
uInt matches; /* number of string matches in current block */
uInt insert; /* bytes at end of window left to insert */
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
ulg compressed_len; /* total bit length of compressed file mod 2^32 */
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
#endif
/* Output a byte on the stream.
* IN assertion: there is enough room in pending_buf.
*/
-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
* used.
*/
-#ifndef DEBUG
+#ifndef ZLIB_DEBUG
/* Inline versions of _tr_tally for speed: */
#if defined(GEN_TREES_H) || !defined(STDC)
flush = (s->last_lit == s->lit_bufsize-1); \
}
# define _tr_tally_dist(s, distance, length, flush) \
- { uch len = (length); \
- ush dist = (distance); \
+ { uch len = (uch)(length); \
+ ush dist = (ush)(distance); \
s->d_buf[s->last_lit] = dist; \
s->l_buf[s->last_lit++] = len; \
dist--; \
/* gzguts.h -- zlib internal header definitions for gz* operations
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
# include <stdlib.h>
# include <limits.h>
#endif
+
+#ifndef _POSIX_SOURCE
+# define _POSIX_SOURCE
+#endif
#include <fcntl.h>
#ifdef _WIN32
# include <io.h>
#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+# define WIDECHAR
+#endif
+
#ifdef WINAPI_FAMILY
# define open _open
# define read _read
# endif
#endif
-/* unlike snprintf (which is required in C99, yet still not supported by
- Microsoft more than a decade later!), _snprintf does not guarantee null
- termination of the result -- however this is only used in gzlib.c where
+/* unlike snprintf (which is required in C99), _snprintf does not guarantee
+ null termination of the result -- however this is only used in gzlib.c where
the result is assured to fit in the space provided */
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && _MSC_VER < 1900
# define snprintf _snprintf
#endif
#ifndef local
# define local static
#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
+/* since "static" is used to mean two completely different things in C, we
+ define "local" for the non-static meaning of "static", for readability
+ (compile with -Dlocal if your debugger can't find static symbols) */
/* gz* functions always use library allocation functions */
#ifndef STDC
char *path; /* path or fd for error messages */
unsigned size; /* buffer size, zero if not allocated yet */
unsigned want; /* requested buffer size, default is GZBUFSIZE */
- unsigned char *in; /* input buffer */
+ unsigned char *in; /* input buffer (double-sized when writing) */
unsigned char *out; /* output buffer (double-sized when reading) */
int direct; /* 0 if processing gzip, 1 if transparent */
/* just for reading */
/* gzlib.c -- zlib functions common to reading and writing gzip files
- * Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "gzguts.h"
-#if defined(_WIN32) && !defined(__BORLANDC__)
+#if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
# define LSEEK _lseeki64
#else
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
const char *mode;
{
gz_statep state;
- size_t len;
+ z_size_t len;
int oflag;
#ifdef O_CLOEXEC
int cloexec = 0;
}
/* save the path name for error messages */
-#ifdef _WIN32
+#ifdef WIDECHAR
if (fd == -2) {
len = wcstombs(NULL, path, 0);
- if (len == (size_t)-1)
+ if (len == (z_size_t)-1)
len = 0;
}
else
free(state);
return NULL;
}
-#ifdef _WIN32
+#ifdef WIDECHAR
if (fd == -2)
if (len)
wcstombs(state->path, path, len + 1);
else
#endif
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
- snprintf(state->path, len + 1, "%s", (const char *)path);
+ (void)snprintf(state->path, len + 1, "%s", (const char *)path);
#else
strcpy(state->path, path);
#endif
/* open the file with the appropriate flags (or just use fd) */
state->fd = fd > -1 ? fd : (
-#ifdef _WIN32
+#ifdef WIDECHAR
fd == -2 ? _wopen(path, oflag, 0666) :
#endif
open((const char *)path, oflag, 0666));
free(state);
return NULL;
}
- if (state->mode == GZ_APPEND)
+ if (state->mode == GZ_APPEND) {
+ LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
state->mode = GZ_WRITE; /* simplify later checks */
+ }
/* save the current position for rewinding (only if reading) */
if (state->mode == GZ_READ) {
if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
return NULL;
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
- snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */
+ (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
#else
sprintf(path, "<fd:%d>", fd); /* for debugging */
#endif
}
/* -- see zlib.h -- */
-#ifdef _WIN32
+#ifdef WIDECHAR
gzFile ZEXPORT gzopen_w(path, mode)
const wchar_t *path;
const char *mode;
return -1;
/* check and set requested size */
+ if ((size << 1) < size)
+ return -1; /* need to be able to double it */
if (size < 2)
size = 2; /* need two bytes to check magic header */
state->want = size;
return;
}
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
- snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
- "%s%s%s", state->path, ": ", msg);
+ (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
+ "%s%s%s", state->path, ": ", msg);
#else
strcpy(state->msg, state->path);
strcat(state->msg, ": ");
strcat(state->msg, msg);
#endif
- return;
}
#ifndef INT_MAX
/* gzread.c -- zlib functions for reading gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
local int gz_decomp OF((gz_statep));
local int gz_fetch OF((gz_statep));
local int gz_skip OF((gz_statep, z_off64_t));
+local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
state->fd, and update state->eof, state->err, and state->msg as appropriate.
unsigned *have;
{
int ret;
+ unsigned get, max = ((unsigned)-1 >> 2) + 1;
*have = 0;
do {
- ret = read(state->fd, buf + *have, len - *have);
+ get = len - *have;
+ if (get > max)
+ get = max;
+ ret = read(state->fd, buf + *have, get);
if (ret <= 0)
break;
- *have += ret;
+ *have += (unsigned)ret;
} while (*have < len);
if (ret < 0) {
gz_error(state, Z_ERRNO, zstrerror());
state->in = (unsigned char *)malloc(state->want);
state->out = (unsigned char *)malloc(state->want << 1);
if (state->in == NULL || state->out == NULL) {
- if (state->out != NULL)
- free(state->out);
- if (state->in != NULL)
- free(state->in);
+ free(state->out);
+ free(state->in);
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
}
return 0;
}
-/* -- see zlib.h -- */
-int ZEXPORT gzread(file, buf, len)
- gzFile file;
+/* Read len bytes into buf from file, or less than len up to the end of the
+ input. Return the number of bytes read. If zero is returned, either the
+ end of file was reached, or there was an error. state->err must be
+ consulted in that case to determine which. */
+local z_size_t gz_read(state, buf, len)
+ gz_statep state;
voidp buf;
- unsigned len;
+ z_size_t len;
{
- unsigned got, n;
- gz_statep state;
- z_streamp strm;
-
- /* get internal structure */
- if (file == NULL)
- return -1;
- state = (gz_statep)file;
- strm = &(state->strm);
-
- /* check that we're reading and that there's no (serious) error */
- if (state->mode != GZ_READ ||
- (state->err != Z_OK && state->err != Z_BUF_ERROR))
- return -1;
-
- /* since an int is returned, make sure len fits in one, otherwise return
- with an error (this avoids the flaw in the interface) */
- if ((int)len < 0) {
- gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
- return -1;
- }
+ z_size_t got;
+ unsigned n;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
if (state->seek) {
state->seek = 0;
if (gz_skip(state, state->skip) == -1)
- return -1;
+ return 0;
}
/* get len bytes to buf, or less than len if at the end */
got = 0;
do {
+ /* set n to the maximum amount of len that fits in an unsigned int */
+ n = -1;
+ if (n > len)
+ n = len;
+
/* first just try copying data from the output buffer */
if (state->x.have) {
- n = state->x.have > len ? len : state->x.have;
+ if (state->x.have < n)
+ n = state->x.have;
memcpy(buf, state->x.next, n);
state->x.next += n;
state->x.have -= n;
}
/* output buffer empty -- return if we're at the end of the input */
- else if (state->eof && strm->avail_in == 0) {
+ else if (state->eof && state->strm.avail_in == 0) {
state->past = 1; /* tried to read past end */
break;
}
/* need output data -- for small len or new stream load up our output
buffer */
- else if (state->how == LOOK || len < (state->size << 1)) {
+ else if (state->how == LOOK || n < (state->size << 1)) {
/* get more output, looking for header if required */
if (gz_fetch(state) == -1)
- return -1;
+ return 0;
continue; /* no progress yet -- go back to copy above */
/* the copy above assures that we will leave with space in the
output buffer, allowing at least one gzungetc() to succeed */
/* large len -- read directly into user buffer */
else if (state->how == COPY) { /* read directly */
- if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
- return -1;
+ if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
+ return 0;
}
/* large len -- decompress directly into user buffer */
else { /* state->how == GZIP */
- strm->avail_out = len;
- strm->next_out = (unsigned char *)buf;
+ state->strm.avail_out = n;
+ state->strm.next_out = (unsigned char *)buf;
if (gz_decomp(state) == -1)
- return -1;
+ return 0;
n = state->x.have;
state->x.have = 0;
}
state->x.pos += n;
} while (len);
- /* return number of bytes read into user buffer (will fit in int) */
- return (int)got;
+ /* return number of bytes read into user buffer */
+ return got;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzread(file, buf, len)
+ gzFile file;
+ voidp buf;
+ unsigned len;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return -1;
+
+ /* since an int is returned, make sure len fits in one, otherwise return
+ with an error (this avoids a flaw in the interface) */
+ if ((int)len < 0) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
+ return -1;
+ }
+
+ /* read len or fewer bytes to buf */
+ len = gz_read(state, buf, len);
+
+ /* check for an error */
+ if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
+ return -1;
+
+ /* return the number of bytes read (this is assured to fit in an int) */
+ return (int)len;
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfread(buf, size, nitems, file)
+ voidp buf;
+ z_size_t size;
+ z_size_t nitems;
+ gzFile file;
+{
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return 0;
+
+ /* compute bytes to read -- error on overflow */
+ len = nitems * size;
+ if (size && len / size != nitems) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+ return 0;
+ }
+
+ /* read len or fewer bytes to buf, return the number of full items read */
+ return len ? gz_read(state, buf, len) / size : 0;
}
/* -- see zlib.h -- */
return *(state->x.next)++;
}
- /* nothing there -- try gzread() */
- ret = gzread(file, buf, 1);
+ /* nothing there -- try gz_read() */
+ ret = gz_read(state, buf, 1);
return ret < 1 ? -1 : buf[0];
}
if (state->x.have == 0) {
state->x.have = 1;
state->x.next = state->out + (state->size << 1) - 1;
- state->x.next[0] = c;
+ state->x.next[0] = (unsigned char)c;
state->x.pos--;
state->past = 0;
return c;
}
state->x.have++;
state->x.next--;
- state->x.next[0] = c;
+ state->x.next[0] = (unsigned char)c;
state->x.pos--;
state->past = 0;
return c;
/* gzwrite.c -- zlib functions for writing gzip files
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * Copyright (C) 2004-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
local int gz_init OF((gz_statep));
local int gz_comp OF((gz_statep, int));
local int gz_zero OF((gz_statep, z_off64_t));
+local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
/* Initialize state for writing a gzip file. Mark initialization by setting
- state->size to non-zero. Return -1 on failure or 0 on success. */
+ state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
+ success. */
local int gz_init(state)
gz_statep state;
{
int ret;
z_streamp strm = &(state->strm);
- /* allocate input buffer */
- state->in = (unsigned char *)malloc(state->want);
+ /* allocate input buffer (double size for gzprintf) */
+ state->in = (unsigned char *)malloc(state->want << 1);
if (state->in == NULL) {
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
}
+ strm->next_in = NULL;
}
/* mark state as initialized */
}
/* Compress whatever is at avail_in and next_in and write to the output file.
- Return -1 if there is an error writing to the output file, otherwise 0.
- flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH,
- then the deflate() state is reset to start a new gzip stream. If gz->direct
- is true, then simply write to the output file without compressing, and
- ignore flush. */
+ Return -1 if there is an error writing to the output file or if gz_init()
+ fails to allocate memory, otherwise 0. flush is assumed to be a valid
+ deflate() flush value. If flush is Z_FINISH, then the deflate() state is
+ reset to start a new gzip stream. If gz->direct is true, then simply write
+ to the output file without compressing, and ignore flush. */
local int gz_comp(state, flush)
gz_statep state;
int flush;
{
- int ret, got;
- unsigned have;
+ int ret, writ;
+ unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
z_streamp strm = &(state->strm);
/* allocate memory if this is the first time through */
/* write directly if requested */
if (state->direct) {
- got = write(state->fd, strm->next_in, strm->avail_in);
- if (got < 0 || (unsigned)got != strm->avail_in) {
- gz_error(state, Z_ERRNO, zstrerror());
- return -1;
+ while (strm->avail_in) {
+ put = strm->avail_in > max ? max : strm->avail_in;
+ writ = write(state->fd, strm->next_in, put);
+ if (writ < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ strm->avail_in -= (unsigned)writ;
+ strm->next_in += writ;
}
- strm->avail_in = 0;
return 0;
}
doing Z_FINISH then don't write until we get to Z_STREAM_END */
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
(flush != Z_FINISH || ret == Z_STREAM_END))) {
- have = (unsigned)(strm->next_out - state->x.next);
- if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
- (unsigned)got != have)) {
- gz_error(state, Z_ERRNO, zstrerror());
- return -1;
+ while (strm->next_out > state->x.next) {
+ put = strm->next_out - state->x.next > (int)max ? max :
+ (unsigned)(strm->next_out - state->x.next);
+ writ = write(state->fd, state->x.next, put);
+ if (writ < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ state->x.next += writ;
}
if (strm->avail_out == 0) {
strm->avail_out = state->size;
strm->next_out = state->out;
+ state->x.next = state->out;
}
- state->x.next = strm->next_out;
}
/* compress */
return 0;
}
-/* Compress len zeros to output. Return -1 on error, 0 on success. */
+/* Compress len zeros to output. Return -1 on a write error or memory
+ allocation failure by gz_comp(), or 0 on success. */
local int gz_zero(state, len)
gz_statep state;
z_off64_t len;
return 0;
}
-/* -- see zlib.h -- */
-int ZEXPORT gzwrite(file, buf, len)
- gzFile file;
+/* Write len bytes from buf to file. Return the number of bytes written. If
+ the returned value is less than len, then there was an error. */
+local z_size_t gz_write(state, buf, len)
+ gz_statep state;
voidpc buf;
- unsigned len;
+ z_size_t len;
{
- unsigned put = len;
- gz_statep state;
- z_streamp strm;
-
- /* get internal structure */
- if (file == NULL)
- return 0;
- state = (gz_statep)file;
- strm = &(state->strm);
-
- /* check that we're writing and that there's no error */
- if (state->mode != GZ_WRITE || state->err != Z_OK)
- return 0;
-
- /* since an int is returned, make sure len fits in one, otherwise return
- with an error (this avoids the flaw in the interface) */
- if ((int)len < 0) {
- gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
- return 0;
- }
+ z_size_t put = len;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
do {
unsigned have, copy;
- if (strm->avail_in == 0)
- strm->next_in = state->in;
- have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
+ if (state->strm.avail_in == 0)
+ state->strm.next_in = state->in;
+ have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
+ state->in);
copy = state->size - have;
if (copy > len)
copy = len;
memcpy(state->in + have, buf, copy);
- strm->avail_in += copy;
+ state->strm.avail_in += copy;
state->x.pos += copy;
buf = (const char *)buf + copy;
len -= copy;
}
else {
/* consume whatever's left in the input buffer */
- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
+ if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
return 0;
/* directly compress user buffer to file */
- strm->avail_in = len;
- strm->next_in = (z_const Bytef *)buf;
- state->x.pos += len;
- if (gz_comp(state, Z_NO_FLUSH) == -1)
- return 0;
+ state->strm.next_in = (z_const Bytef *)buf;
+ do {
+ unsigned n = (unsigned)-1;
+ if (n > len)
+ n = len;
+ state->strm.avail_in = n;
+ state->x.pos += n;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return 0;
+ len -= n;
+ } while (len);
+ }
+
+ /* input was all buffered or compressed */
+ return put;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzwrite(file, buf, len)
+ gzFile file;
+ voidpc buf;
+ unsigned len;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return 0;
+
+ /* since an int is returned, make sure len fits in one, otherwise return
+ with an error (this avoids a flaw in the interface) */
+ if ((int)len < 0) {
+ gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
+ return 0;
+ }
+
+ /* write len bytes from buf (the return value will fit in an int) */
+ return (int)gz_write(state, buf, len);
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
+ voidpc buf;
+ z_size_t size;
+ z_size_t nitems;
+ gzFile file;
+{
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return 0;
+
+ /* compute bytes to read -- error on overflow */
+ len = nitems * size;
+ if (size && len / size != nitems) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+ return 0;
}
- /* input was all buffered or compressed (put will fit in int) */
- return (int)put;
+ /* write len bytes to buf, return the number of full items written */
+ return len ? gz_write(state, buf, len) / size : 0;
}
/* -- see zlib.h -- */
strm->next_in = state->in;
have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
if (have < state->size) {
- state->in[have] = c;
+ state->in[have] = (unsigned char)c;
strm->avail_in++;
state->x.pos++;
return c & 0xff;
}
/* no room in buffer or not initialized, use gz_write() */
- buf[0] = c;
- if (gzwrite(file, buf, 1) != 1)
+ buf[0] = (unsigned char)c;
+ if (gz_write(state, buf, 1) != 1)
return -1;
return c & 0xff;
}
const char *str;
{
int ret;
- unsigned len;
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return -1;
/* write string */
- len = (unsigned)strlen(str);
- ret = gzwrite(file, str, len);
+ len = strlen(str);
+ ret = gz_write(state, str, len);
return ret == 0 && len != 0 ? -1 : ret;
}
/* -- see zlib.h -- */
int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
{
- int size, len;
+ int len;
+ unsigned left;
+ char *next;
gz_statep state;
z_streamp strm;
/* get internal structure */
if (file == NULL)
- return -1;
+ return Z_STREAM_ERROR;
state = (gz_statep)file;
strm = &(state->strm);
/* check that we're writing and that there's no error */
if (state->mode != GZ_WRITE || state->err != Z_OK)
- return 0;
+ return Z_STREAM_ERROR;
/* make sure we have some buffer space */
if (state->size == 0 && gz_init(state) == -1)
- return 0;
+ return state->err;
/* check for seek request */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return 0;
+ return state->err;
}
- /* consume whatever's left in the input buffer */
- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
- return 0;
-
- /* do the printf() into the input buffer, put length in len */
- size = (int)(state->size);
- state->in[size - 1] = 0;
+ /* do the printf() into the input buffer, put length in len -- the input
+ buffer is double-sized just for this function, so there is guaranteed to
+ be state->size bytes available after the current contents */
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
+ next[state->size - 1] = 0;
#ifdef NO_vsnprintf
# ifdef HAS_vsprintf_void
- (void)vsprintf((char *)(state->in), format, va);
- for (len = 0; len < size; len++)
- if (state->in[len] == 0) break;
+ (void)vsprintf(next, format, va);
+ for (len = 0; len < state->size; len++)
+ if (next[len] == 0) break;
# else
- len = vsprintf((char *)(state->in), format, va);
+ len = vsprintf(next, format, va);
# endif
#else
# ifdef HAS_vsnprintf_void
- (void)vsnprintf((char *)(state->in), size, format, va);
- len = strlen((char *)(state->in));
+ (void)vsnprintf(next, state->size, format, va);
+ len = strlen(next);
# else
- len = vsnprintf((char *)(state->in), size, format, va);
+ len = vsnprintf(next, state->size, format, va);
# endif
#endif
/* check that printf() results fit in buffer */
- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
+ if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
return 0;
- /* update buffer and position, defer compression until needed */
- strm->avail_in = (unsigned)len;
- strm->next_in = state->in;
+ /* update buffer and position, compress first half if past that */
+ strm->avail_in += (unsigned)len;
state->x.pos += len;
+ if (strm->avail_in >= state->size) {
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return state->err;
+ memcpy(state->in, state->in + state->size, left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
return len;
}
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
{
- int size, len;
+ unsigned len, left;
+ char *next;
gz_statep state;
z_streamp strm;
/* get internal structure */
if (file == NULL)
- return -1;
+ return Z_STREAM_ERROR;
state = (gz_statep)file;
strm = &(state->strm);
/* check that can really pass pointer in ints */
if (sizeof(int) != sizeof(void *))
- return 0;
+ return Z_STREAM_ERROR;
/* check that we're writing and that there's no error */
if (state->mode != GZ_WRITE || state->err != Z_OK)
- return 0;
+ return Z_STREAM_ERROR;
/* make sure we have some buffer space */
if (state->size == 0 && gz_init(state) == -1)
- return 0;
+ return state->error;
/* check for seek request */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return 0;
+ return state->error;
}
- /* consume whatever's left in the input buffer */
- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
- return 0;
-
- /* do the printf() into the input buffer, put length in len */
- size = (int)(state->size);
- state->in[size - 1] = 0;
+ /* do the printf() into the input buffer, put length in len -- the input
+ buffer is double-sized just for this function, so there is guaranteed to
+ be state->size bytes available after the current contents */
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ next = (char *)(strm->next_in + strm->avail_in);
+ next[state->size - 1] = 0;
#ifdef NO_snprintf
# ifdef HAS_sprintf_void
- sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
+ a13, a14, a15, a16, a17, a18, a19, a20);
for (len = 0; len < size; len++)
- if (state->in[len] == 0) break;
+ if (next[len] == 0)
+ break;
# else
- len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
+ a12, a13, a14, a15, a16, a17, a18, a19, a20);
# endif
#else
# ifdef HAS_snprintf_void
- snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
- len = strlen((char *)(state->in));
+ snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = strlen(next);
# else
- len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6,
- a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
- a19, a20);
+ len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
# endif
#endif
/* check that printf() results fit in buffer */
- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
+ if (len == 0 || len >= state->size || next[state->size - 1] != 0)
return 0;
- /* update buffer and position, defer compression until needed */
- strm->avail_in = (unsigned)len;
- strm->next_in = state->in;
+ /* update buffer and position, compress first half if past that */
+ strm->avail_in += len;
state->x.pos += len;
- return len;
+ if (strm->avail_in >= state->size) {
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return state->err;
+ memcpy(state->in, state->in + state->size, left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
+ return (int)len;
}
#endif
/* get internal structure */
if (file == NULL)
- return -1;
+ return Z_STREAM_ERROR;
state = (gz_statep)file;
/* check that we're writing and that there's no error */
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return -1;
+ return state->err;
}
/* compress remaining data with requested flush */
- gz_comp(state, flush);
+ (void)gz_comp(state, flush);
return state->err;
}
if (state->seek) {
state->seek = 0;
if (gz_zero(state, state->skip) == -1)
- return -1;
+ return state->err;
}
/* change compression parameters for subsequent input */
if (state->size) {
/* flush previous input with previous parameters before changing */
- if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
+ if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
return state->err;
deflateParams(strm, level, strategy);
}
/* infback.c -- inflate using a call-back interface
- * Copyright (C) 1995-2011 Mark Adler
+ * Copyright (C) 1995-2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
state->dmax = 32768U;
- state->wbits = windowBits;
+ state->wbits = (uInt)windowBits;
state->wsize = 1U << windowBits;
state->window = window;
state->wnext = 0;
/* inffast.c -- fast decoding
- * Copyright (C) 1995-2008, 2010, 2013 Mark Adler
+ * Copyright (C) 1995-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "inflate.h"
#include "inffast.h"
-#ifndef ASMINF
-
-/* Allow machine dependent optimization for post-increment or pre-increment.
- Based on testing to date,
- Pre-increment preferred for:
- - PowerPC G3 (Adler)
- - MIPS R5000 (Randers-Pehrson)
- Post-increment preferred for:
- - none
- No measurable difference:
- - Pentium III (Anderson)
- - M68060 (Nikl)
- */
-#ifdef POSTINC
-# define OFF 0
-# define PUP(a) *(a)++
+#ifdef ASMINF
+# pragma message("Assembler code may have bugs -- use at your own risk")
#else
-# define OFF 1
-# define PUP(a) *++(a)
-#endif
/*
Decode literal, length, and distance codes and write out the resulting
/* copy state to local variables */
state = (struct inflate_state FAR *)strm->state;
- in = strm->next_in - OFF;
+ in = strm->next_in;
last = in + (strm->avail_in - 5);
- out = strm->next_out - OFF;
+ out = strm->next_out;
beg = out - (start - strm->avail_out);
end = out + (strm->avail_out - 257);
#ifdef INFLATE_STRICT
input data or output space */
do {
if (bits < 15) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
here = lcode[hold & lmask];
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
"inflate: literal '%c'\n" :
"inflate: literal 0x%02x\n", here.val));
- PUP(out) = (unsigned char)(here.val);
+ *out++ = (unsigned char)(here.val);
}
else if (op & 16) { /* length base */
len = (unsigned)(here.val);
op &= 15; /* number of extra bits */
if (op) {
if (bits < op) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
len += (unsigned)hold & ((1U << op) - 1);
}
Tracevv((stderr, "inflate: length %u\n", len));
if (bits < 15) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
here = dcode[hold & dmask];
dist = (unsigned)(here.val);
op &= 15; /* number of extra bits */
if (bits < op) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
if (bits < op) {
- hold += (unsigned long)(PUP(in)) << bits;
+ hold += (unsigned long)(*in++) << bits;
bits += 8;
}
}
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
if (len <= op - whave) {
do {
- PUP(out) = 0;
+ *out++ = 0;
} while (--len);
continue;
}
len -= op - whave;
do {
- PUP(out) = 0;
+ *out++ = 0;
} while (--op > whave);
if (op == 0) {
from = out - dist;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--len);
continue;
}
#endif
}
- from = window - OFF;
+ from = window;
if (wnext == 0) { /* very common case */
from += wsize - op;
if (op < len) { /* some from window */
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
from = out - dist; /* rest from output */
}
if (op < len) { /* some from end of window */
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
- from = window - OFF;
+ from = window;
if (wnext < len) { /* some from start of window */
op = wnext;
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
from = out - dist; /* rest from output */
}
if (op < len) { /* some from window */
len -= op;
do {
- PUP(out) = PUP(from);
+ *out++ = *from++;
} while (--op);
from = out - dist; /* rest from output */
}
}
while (len > 2) {
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
+ *out++ = *from++;
+ *out++ = *from++;
+ *out++ = *from++;
len -= 3;
}
if (len) {
- PUP(out) = PUP(from);
+ *out++ = *from++;
if (len > 1)
- PUP(out) = PUP(from);
+ *out++ = *from++;
}
}
else {
from = out - dist; /* copy direct from output */
do { /* minimum length is three */
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
- PUP(out) = PUP(from);
+ *out++ = *from++;
+ *out++ = *from++;
+ *out++ = *from++;
len -= 3;
} while (len > 2);
if (len) {
- PUP(out) = PUP(from);
+ *out++ = *from++;
if (len > 1)
- PUP(out) = PUP(from);
+ *out++ = *from++;
}
}
}
hold &= (1U << bits) - 1;
/* update state and return */
- strm->next_in = in + OFF;
- strm->next_out = out + OFF;
+ strm->next_in = in;
+ strm->next_out = out;
strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
strm->avail_out = (unsigned)(out < end ?
257 + (end - out) : 257 - (out - end));
/* inflate.c -- zlib decompression
- * Copyright (C) 1995-2012 Mark Adler
+ * Copyright (C) 1995-2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#endif
/* function prototypes */
+local int inflateStateCheck OF((z_streamp strm));
local void fixedtables OF((struct inflate_state FAR *state));
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
unsigned copy));
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
unsigned len));
+local int inflateStateCheck(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (strm == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+ return 1;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state == Z_NULL || state->strm != strm ||
+ state->mode < HEAD || state->mode > SYNC)
+ return 1;
+ return 0;
+}
+
int ZEXPORT inflateResetKeep(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
strm->total_in = strm->total_out = state->total = 0;
strm->msg = Z_NULL;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
state->wsize = 0;
state->whave = 0;
struct inflate_state FAR *state;
/* get the state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* extract wrap request from windowBits parameter */
windowBits = -windowBits;
}
else {
- wrap = (windowBits >> 4) + 1;
+ wrap = (windowBits >> 4) + 5;
#ifdef GUNZIP
if (windowBits < 48)
windowBits &= 15;
if (state == Z_NULL) return Z_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
+ state->strm = strm;
state->window = Z_NULL;
+ state->mode = HEAD; /* to pass state test in inflateReset2() */
ret = inflateReset2(strm, windowBits);
if (ret != Z_OK) {
ZFREE(strm, state);
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (bits < 0) {
state->hold = 0;
state->bits = 0;
return Z_OK;
}
- if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
+ if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
value &= (1L << bits) - 1;
- state->hold += value << state->bits;
- state->bits += bits;
+ state->hold += (unsigned)value << state->bits;
+ state->bits += (uInt)bits;
return Z_OK;
}
static const unsigned short order[19] = /* permutation of code lengths */
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
- if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
+ if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
(strm->next_in == Z_NULL && strm->avail_in != 0))
return Z_STREAM_ERROR;
NEEDBITS(16);
#ifdef GUNZIP
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
+ if (state->wbits == 0)
+ state->wbits = 15;
state->check = crc32(0L, Z_NULL, 0);
CRC2(state->check, hold);
INITBITS();
len = BITS(4) + 8;
if (state->wbits == 0)
state->wbits = len;
- else if (len > state->wbits) {
+ if (len > 15 || len > state->wbits) {
strm->msg = (char *)"invalid window size";
state->mode = BAD;
break;
}
if (state->head != Z_NULL)
state->head->text = (int)((hold >> 8) & 1);
- if (state->flags & 0x0200) CRC2(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC2(state->check, hold);
INITBITS();
state->mode = TIME;
case TIME:
NEEDBITS(32);
if (state->head != Z_NULL)
state->head->time = hold;
- if (state->flags & 0x0200) CRC4(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC4(state->check, hold);
INITBITS();
state->mode = OS;
case OS:
state->head->xflags = (int)(hold & 0xff);
state->head->os = (int)(hold >> 8);
}
- if (state->flags & 0x0200) CRC2(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC2(state->check, hold);
INITBITS();
state->mode = EXLEN;
case EXLEN:
state->length = (unsigned)(hold);
if (state->head != Z_NULL)
state->head->extra_len = (unsigned)hold;
- if (state->flags & 0x0200) CRC2(state->check, hold);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ CRC2(state->check, hold);
INITBITS();
}
else if (state->head != Z_NULL)
len + copy > state->head->extra_max ?
state->head->extra_max - len : copy);
}
- if (state->flags & 0x0200)
+ if ((state->flags & 0x0200) && (state->wrap & 4))
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
if (state->head != Z_NULL &&
state->head->name != Z_NULL &&
state->length < state->head->name_max)
- state->head->name[state->length++] = len;
+ state->head->name[state->length++] = (Bytef)len;
} while (len && copy < have);
- if (state->flags & 0x0200)
+ if ((state->flags & 0x0200) && (state->wrap & 4))
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
if (state->head != Z_NULL &&
state->head->comment != Z_NULL &&
state->length < state->head->comm_max)
- state->head->comment[state->length++] = len;
+ state->head->comment[state->length++] = (Bytef)len;
} while (len && copy < have);
- if (state->flags & 0x0200)
+ if ((state->flags & 0x0200) && (state->wrap & 4))
state->check = crc32(state->check, next, copy);
have -= copy;
next += copy;
case HCRC:
if (state->flags & 0x0200) {
NEEDBITS(16);
- if (hold != (state->check & 0xffff)) {
+ if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
strm->msg = (char *)"header crc mismatch";
state->mode = BAD;
break;
out -= left;
strm->total_out += out;
state->total += out;
- if (out)
+ if ((state->wrap & 4) && out)
strm->adler = state->check =
UPDATE(state->check, put - out, out);
out = left;
- if ((
+ if ((state->wrap & 4) && (
#ifdef GUNZIP
state->flags ? hold :
#endif
strm->total_in += in;
strm->total_out += out;
state->total += out;
- if (state->wrap && out)
+ if ((state->wrap & 4) && out)
strm->adler = state->check =
UPDATE(state->check, strm->next_out - out, out);
- strm->data_type = state->bits + (state->last ? 64 : 0) +
+ strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
(state->mode == TYPE ? 128 : 0) +
(state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
z_streamp strm;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ if (inflateStateCheck(strm))
return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (state->window != Z_NULL) ZFREE(strm, state->window);
struct inflate_state FAR *state;
/* check state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* copy dictionary */
int ret;
/* check state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (state->wrap != 0 && state->mode != DICT)
return Z_STREAM_ERROR;
struct inflate_state FAR *state;
/* check state */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
struct inflate_state FAR *state;
/* check parameters */
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
return state->mode == STORED && state->bits == 0;
}
unsigned wsize;
/* check input */
- if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
- source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
+ if (inflateStateCheck(source) || dest == Z_NULL)
return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)source->state;
/* copy state */
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
+ copy->strm = dest;
if (state->lencode >= state->codes &&
state->lencode <= state->codes + ENOUGH - 1) {
copy->lencode = copy->codes + (state->lencode - state->codes);
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
- state->sane = !subvert;
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ state->sane = !subvert;
return Z_OK;
#else
+ (void)subvert;
state->sane = 1;
return Z_DATA_ERROR;
#endif
}
+int ZEXPORT inflateValidate(strm, check)
+z_streamp strm;
+int check;
+{
+ struct inflate_state FAR *state;
+
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (check)
+ state->wrap |= 4;
+ else
+ state->wrap &= ~4;
+ return Z_OK;
+}
+
long ZEXPORT inflateMark(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
- if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
+ if (inflateStateCheck(strm))
+ return -(1L << 16);
state = (struct inflate_state FAR *)strm->state;
- return ((long)(state->back) << 16) +
+ return (long)(((unsigned long)((long)state->back)) << 16) +
(state->mode == COPY ? state->length :
(state->mode == MATCH ? state->was - state->length : 0));
}
+
+unsigned long ZEXPORT inflateCodesUsed(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (inflateStateCheck(strm)) return (unsigned long)-1;
+ state = (struct inflate_state FAR *)strm->state;
+ return (unsigned long)(state->next - state->codes);
+}
/* inflate.h -- internal inflate state definition
- * Copyright (C) 1995-2009 Mark Adler
+ * Copyright (C) 1995-2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* Possible inflate modes between inflate() calls */
typedef enum {
- HEAD, /* i: waiting for magic header */
+ HEAD = 16180, /* i: waiting for magic header */
FLAGS, /* i: waiting for method and flags (gzip) */
TIME, /* i: waiting for modification time (gzip) */
OS, /* i: waiting for extra flags and operating system (gzip) */
CHECK -> LENGTH -> DONE
*/
-/* state maintained between inflate() calls. Approximately 10K bytes. */
+/* State maintained between inflate() calls -- approximately 7K bytes, not
+ including the allocated sliding window, which is up to 32K bytes. */
struct inflate_state {
+ z_streamp strm; /* pointer back to this zlib stream */
inflate_mode mode; /* current inflate mode */
int last; /* true if processing last block */
- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip,
+ bit 2 true to validate check value */
int havedict; /* true if dictionary provided */
int flags; /* gzip header method and flags (0 if zlib) */
unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
/* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2013 Mark Adler
+ * Copyright (C) 1995-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#define MAXBITS 15
const char inflate_copyright[] =
- " inflate 1.2.8 Copyright 1995-2013 Mark Adler ";
+ " inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
/*
If you use the zlib library in a product, an acknowledgment is welcome
in the documentation of your product. If for some reason you cannot
code FAR *next; /* next available space in table */
const unsigned short FAR *base; /* base value table to use */
const unsigned short FAR *extra; /* extra bits table to use */
- int end; /* use base and extra for symbol > end */
+ unsigned match; /* use base and extra for symbol >= match */
unsigned short count[MAXBITS+1]; /* number of codes of each length */
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
switch (type) {
case CODES:
base = extra = work; /* dummy value--not used */
- end = 19;
+ match = 20;
break;
case LENS:
base = lbase;
- base -= 257;
extra = lext;
- extra -= 257;
- end = 256;
+ match = 257;
break;
- default: /* DISTS */
+ default: /* DISTS */
base = dbase;
extra = dext;
- end = -1;
+ match = 0;
}
/* initialize state for loop */
for (;;) {
/* create table entry */
here.bits = (unsigned char)(len - drop);
- if ((int)(work[sym]) < end) {
+ if (work[sym] + 1U < match) {
here.op = (unsigned char)0;
here.val = work[sym];
}
- else if ((int)(work[sym]) > end) {
- here.op = (unsigned char)(extra[work[sym]]);
- here.val = base[work[sym]];
+ else if (work[sym] >= match) {
+ here.op = (unsigned char)(extra[work[sym] - match]);
+ here.val = base[work[sym] - match];
}
else {
here.op = (unsigned char)(32 + 64); /* end of block */
/* trees.c -- output deflated data using Huffman coding
- * Copyright (C) 1995-2012 Jean-loup Gailly
+ * Copyright (C) 1995-2017 Jean-loup Gailly
* detect_data_type() function provided freely by Cosmin Truta, 2006
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "deflate.h"
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
# include <ctype.h>
#endif
int max_length; /* max bit length for the codes */
};
-local static_tree_desc static_l_desc =
+local const static_tree_desc static_l_desc =
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
-local static_tree_desc static_d_desc =
+local const static_tree_desc static_d_desc =
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
-local static_tree_desc static_bl_desc =
+local const static_tree_desc static_bl_desc =
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
/* ===========================================================================
local unsigned bi_reverse OF((unsigned value, int length));
local void bi_windup OF((deflate_state *s));
local void bi_flush OF((deflate_state *s));
-local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
- int header));
#ifdef GEN_TREES_H
local void gen_trees_header OF((void));
#endif
-#ifndef DEBUG
+#ifndef ZLIB_DEBUG
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
/* Send a code of the given tree. c and tree must not have side effects */
-#else /* DEBUG */
+#else /* !ZLIB_DEBUG */
# define send_code(s, c, tree) \
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
send_bits(s, tree[c].Code, tree[c].Len); }
* Send a value on a given number of bits.
* IN assertion: length <= 16 and value fits in length bits.
*/
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
local void send_bits OF((deflate_state *s, int value, int length));
local void send_bits(s, value, length)
s->bi_valid += length;
}
}
-#else /* !DEBUG */
+#else /* !ZLIB_DEBUG */
#define send_bits(s, value, length) \
{ int len = length;\
if (s->bi_valid > (int)Buf_size - len) {\
- int val = value;\
+ int val = (int)value;\
s->bi_buf |= (ush)val << s->bi_valid;\
put_short(s, s->bi_buf);\
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
s->bi_valid += len;\
}\
}
-#endif /* DEBUG */
+#endif /* ZLIB_DEBUG */
/* the arguments must not have side effects */
* Genererate the file trees.h describing the static trees.
*/
#ifdef GEN_TREES_H
-# ifndef DEBUG
+# ifndef ZLIB_DEBUG
# include <stdio.h>
# endif
s->bi_buf = 0;
s->bi_valid = 0;
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len = 0L;
s->bits_sent = 0L;
#endif
xbits = 0;
if (n >= base) xbits = extra[n-base];
f = tree[n].Freq;
- s->opt_len += (ulg)f * (bits + xbits);
- if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
+ s->opt_len += (ulg)f * (unsigned)(bits + xbits);
+ if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
}
if (overflow == 0) return;
- Trace((stderr,"\nbit length overflow\n"));
+ Tracev((stderr,"\nbit length overflow\n"));
/* This happens for example on obj2 and pic of the Calgary corpus */
/* Find the first bit length which could increase: */
m = s->heap[--h];
if (m > max_code) continue;
if ((unsigned) tree[m].Len != (unsigned) bits) {
- Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
- s->opt_len += ((long)bits - (long)tree[m].Len)
- *(long)tree[m].Freq;
+ Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+ s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
tree[m].Len = (ush)bits;
}
n--;
ushf *bl_count; /* number of codes at each bit length */
{
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
- ush code = 0; /* running code value */
+ unsigned code = 0; /* running code value */
int bits; /* bit index */
int n; /* code index */
* without bit reversal.
*/
for (bits = 1; bits <= MAX_BITS; bits++) {
- next_code[bits] = code = (code + bl_count[bits-1]) << 1;
+ code = (code + bl_count[bits-1]) << 1;
+ next_code[bits] = (ush)code;
}
/* Check that the bit counts in bl_count are consistent. The last code
* must be all ones.
int len = tree[n].Len;
if (len == 0) continue;
/* Now reverse the bits */
- tree[n].Code = bi_reverse(next_code[len]++, len);
+ tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
}
/* Update opt_len to include the bit length tree and counts */
- s->opt_len += 3*(max_blindex+1) + 5+5+4;
+ s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
s->opt_len, s->static_len));
int last; /* one if this is the last block for a file */
{
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
-#ifdef DEBUG
+ bi_windup(s); /* align on byte boundary */
+ put_short(s, (ush)stored_len);
+ put_short(s, (ush)~stored_len);
+ zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
+ s->pending += stored_len;
+#ifdef ZLIB_DEBUG
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
s->compressed_len += (stored_len + 4) << 3;
+ s->bits_sent += 2*16;
+ s->bits_sent += stored_len<<3;
#endif
- copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
}
/* ===========================================================================
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
/* ===========================================================================
* Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file.
+ * trees or store, and write out the encoded block.
*/
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
deflate_state *s;
send_bits(s, (STATIC_TREES<<1)+last, 3);
compress_block(s, (const ct_data *)static_ltree,
(const ct_data *)static_dtree);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->static_len;
#endif
} else {
max_blindex+1);
compress_block(s, (const ct_data *)s->dyn_ltree,
(const ct_data *)s->dyn_dtree);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->opt_len;
#endif
}
if (last) {
bi_windup(s);
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->compressed_len += 7; /* align on byte boundary */
#endif
}
send_code(s, code, dtree); /* send the distance code */
extra = extra_dbits[code];
if (extra != 0) {
- dist -= base_dist[code];
+ dist -= (unsigned)base_dist[code];
send_bits(s, dist, extra); /* send the extra distance bits */
}
} /* literal or match pair ? */
}
s->bi_buf = 0;
s->bi_valid = 0;
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
-
-/* ===========================================================================
- * Copy a stored block, storing first the length and its
- * one's complement if requested.
- */
-local void copy_block(s, buf, len, header)
- deflate_state *s;
- charf *buf; /* the input data */
- unsigned len; /* its length */
- int header; /* true if block header must be written */
-{
- bi_windup(s); /* align on byte boundary */
-
- if (header) {
- put_short(s, (ush)len);
- put_short(s, (ush)~len);
-#ifdef DEBUG
- s->bits_sent += 2*16;
-#endif
- }
-#ifdef DEBUG
- s->bits_sent += (ulg)len<<3;
-#endif
- while (len--) {
- put_byte(s, *buf++);
- }
-}
/* uncompr.c -- decompress a memory buffer
- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
+ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "zlib.h"
/* ===========================================================================
- Decompresses the source buffer into the destination buffer. sourceLen is
- the byte length of the source buffer. Upon entry, destLen is the total
- size of the destination buffer, which must be large enough to hold the
- entire uncompressed data. (The size of the uncompressed data must have
- been saved previously by the compressor and transmitted to the decompressor
- by some mechanism outside the scope of this compression library.)
- Upon exit, destLen is the actual size of the compressed buffer.
-
- uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
- enough memory, Z_BUF_ERROR if there was not enough room in the output
- buffer, or Z_DATA_ERROR if the input data was corrupted.
+ Decompresses the source buffer into the destination buffer. *sourceLen is
+ the byte length of the source buffer. Upon entry, *destLen is the total size
+ of the destination buffer, which must be large enough to hold the entire
+ uncompressed data. (The size of the uncompressed data must have been saved
+ previously by the compressor and transmitted to the decompressor by some
+ mechanism outside the scope of this compression library.) Upon exit,
+ *destLen is the size of the decompressed data and *sourceLen is the number
+ of source bytes consumed. Upon return, source + *sourceLen points to the
+ first unused input byte.
+
+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
+ Z_DATA_ERROR if the input data was corrupted, including if the input data is
+ an incomplete zlib stream.
*/
-int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
- uLong sourceLen;
+ uLong *sourceLen;
{
z_stream stream;
int err;
+ const uInt max = (uInt)-1;
+ uLong len, left;
+ Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
- stream.next_in = (z_const Bytef *)source;
- stream.avail_in = (uInt)sourceLen;
- /* Check for source > 64K on 16-bit machine: */
- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-
- stream.next_out = dest;
- stream.avail_out = (uInt)*destLen;
- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+ len = *sourceLen;
+ if (*destLen) {
+ left = *destLen;
+ *destLen = 0;
+ }
+ else {
+ left = 1;
+ dest = buf;
+ }
+ stream.next_in = (z_const Bytef *)source;
+ stream.avail_in = 0;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
+ stream.opaque = (voidpf)0;
err = inflateInit(&stream);
if (err != Z_OK) return err;
- err = inflate(&stream, Z_FINISH);
- if (err != Z_STREAM_END) {
- inflateEnd(&stream);
- if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
- return Z_DATA_ERROR;
- return err;
- }
- *destLen = stream.total_out;
+ stream.next_out = dest;
+ stream.avail_out = 0;
- err = inflateEnd(&stream);
- return err;
+ do {
+ if (stream.avail_out == 0) {
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
+ left -= stream.avail_out;
+ }
+ if (stream.avail_in == 0) {
+ stream.avail_in = len > (uLong)max ? max : (uInt)len;
+ len -= stream.avail_in;
+ }
+ err = inflate(&stream, Z_NO_FLUSH);
+ } while (err == Z_OK);
+
+ *sourceLen -= len + stream.avail_in;
+ if (dest != buf)
+ *destLen = stream.total_out;
+ else if (stream.total_out && err == Z_BUF_ERROR)
+ left = 1;
+
+ inflateEnd(&stream);
+ return err == Z_STREAM_END ? Z_OK :
+ err == Z_NEED_DICT ? Z_DATA_ERROR :
+ err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
+ err;
+}
+
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ return uncompress2(dest, destLen, source, &sourceLen);
}
/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
# define Z_PREFIX_SET
-/* all linked symbols */
+/* all linked symbols and init macros */
# define _dist_code z__dist_code
# define _length_code z__length_code
# define _tr_align z__tr_align
# define adler32 z_adler32
# define adler32_combine z_adler32_combine
# define adler32_combine64 z_adler32_combine64
+# define adler32_z z_adler32_z
# ifndef Z_SOLO
# define compress z_compress
# define compress2 z_compress2
# define crc32 z_crc32
# define crc32_combine z_crc32_combine
# define crc32_combine64 z_crc32_combine64
+# define crc32_z z_crc32_z
# define deflate z_deflate
# define deflateBound z_deflateBound
# define deflateCopy z_deflateCopy
# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
# define deflateInit2_ z_deflateInit2_
# define deflateInit_ z_deflateInit_
# define deflateParams z_deflateParams
# define gzeof z_gzeof
# define gzerror z_gzerror
# define gzflush z_gzflush
+# define gzfread z_gzfread
+# define gzfwrite z_gzfwrite
# define gzgetc z_gzgetc
# define gzgetc_ z_gzgetc_
# define gzgets z_gzgets
# define gzopen_w z_gzopen_w
# endif
# define gzprintf z_gzprintf
-# define gzvprintf z_gzvprintf
# define gzputc z_gzputc
# define gzputs z_gzputs
# define gzread z_gzread
# define gztell z_gztell
# define gztell64 z_gztell64
# define gzungetc z_gzungetc
+# define gzvprintf z_gzvprintf
# define gzwrite z_gzwrite
# endif
# define inflate z_inflate
# define inflateBack z_inflateBack
# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
# define inflateCopy z_inflateCopy
# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
# define inflateInit2_ z_inflateInit2_
# define inflateInit_ z_inflateInit_
# define inflateMark z_inflateMark
# define inflatePrime z_inflatePrime
# define inflateReset z_inflateReset
# define inflateReset2 z_inflateReset2
+# define inflateResetKeep z_inflateResetKeep
# define inflateSetDictionary z_inflateSetDictionary
-# define inflateGetDictionary z_inflateGetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateUndermine z_inflateUndermine
-# define inflateResetKeep z_inflateResetKeep
+# define inflateValidate z_inflateValidate
# define inflate_copyright z_inflate_copyright
# define inflate_fast z_inflate_fast
# define inflate_table z_inflate_table
# ifndef Z_SOLO
# define uncompress z_uncompress
+# define uncompress2 z_uncompress2
# endif
# define zError z_zError
# ifndef Z_SOLO
# define z_const
#endif
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-# define NO_DUMMY_DECL
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
#endif
/* Maximum value for memLevel in deflateInit2 */
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
for small objects.
*/
/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
# define Z_PREFIX_SET
-/* all linked symbols */
+/* all linked symbols and init macros */
# define _dist_code z__dist_code
# define _length_code z__length_code
# define _tr_align z__tr_align
# define adler32 z_adler32
# define adler32_combine z_adler32_combine
# define adler32_combine64 z_adler32_combine64
+# define adler32_z z_adler32_z
# ifndef Z_SOLO
# define compress z_compress
# define compress2 z_compress2
# define crc32 z_crc32
# define crc32_combine z_crc32_combine
# define crc32_combine64 z_crc32_combine64
+# define crc32_z z_crc32_z
# define deflate z_deflate
# define deflateBound z_deflateBound
# define deflateCopy z_deflateCopy
# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
# define deflateInit2_ z_deflateInit2_
# define deflateInit_ z_deflateInit_
# define deflateParams z_deflateParams
# define gzeof z_gzeof
# define gzerror z_gzerror
# define gzflush z_gzflush
+# define gzfread z_gzfread
+# define gzfwrite z_gzfwrite
# define gzgetc z_gzgetc
# define gzgetc_ z_gzgetc_
# define gzgets z_gzgets
# define gzopen_w z_gzopen_w
# endif
# define gzprintf z_gzprintf
-# define gzvprintf z_gzvprintf
# define gzputc z_gzputc
# define gzputs z_gzputs
# define gzread z_gzread
# define gztell z_gztell
# define gztell64 z_gztell64
# define gzungetc z_gzungetc
+# define gzvprintf z_gzvprintf
# define gzwrite z_gzwrite
# endif
# define inflate z_inflate
# define inflateBack z_inflateBack
# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
# define inflateCopy z_inflateCopy
# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
# define inflateInit2_ z_inflateInit2_
# define inflateInit_ z_inflateInit_
# define inflateMark z_inflateMark
# define inflatePrime z_inflatePrime
# define inflateReset z_inflateReset
# define inflateReset2 z_inflateReset2
+# define inflateResetKeep z_inflateResetKeep
# define inflateSetDictionary z_inflateSetDictionary
-# define inflateGetDictionary z_inflateGetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateUndermine z_inflateUndermine
-# define inflateResetKeep z_inflateResetKeep
+# define inflateValidate z_inflateValidate
# define inflate_copyright z_inflate_copyright
# define inflate_fast z_inflate_fast
# define inflate_table z_inflate_table
# ifndef Z_SOLO
# define uncompress z_uncompress
+# define uncompress2 z_uncompress2
# endif
# define zError z_zError
# ifndef Z_SOLO
# define z_const
#endif
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-# define NO_DUMMY_DECL
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
#endif
/* Maximum value for memLevel in deflateInit2 */
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
for small objects.
*/
/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
# define Z_PREFIX_SET
-/* all linked symbols */
+/* all linked symbols and init macros */
# define _dist_code z__dist_code
# define _length_code z__length_code
# define _tr_align z__tr_align
# define adler32 z_adler32
# define adler32_combine z_adler32_combine
# define adler32_combine64 z_adler32_combine64
+# define adler32_z z_adler32_z
# ifndef Z_SOLO
# define compress z_compress
# define compress2 z_compress2
# define crc32 z_crc32
# define crc32_combine z_crc32_combine
# define crc32_combine64 z_crc32_combine64
+# define crc32_z z_crc32_z
# define deflate z_deflate
# define deflateBound z_deflateBound
# define deflateCopy z_deflateCopy
# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
# define deflateInit2_ z_deflateInit2_
# define deflateInit_ z_deflateInit_
# define deflateParams z_deflateParams
# define gzeof z_gzeof
# define gzerror z_gzerror
# define gzflush z_gzflush
+# define gzfread z_gzfread
+# define gzfwrite z_gzfwrite
# define gzgetc z_gzgetc
# define gzgetc_ z_gzgetc_
# define gzgets z_gzgets
# define gzopen_w z_gzopen_w
# endif
# define gzprintf z_gzprintf
-# define gzvprintf z_gzvprintf
# define gzputc z_gzputc
# define gzputs z_gzputs
# define gzread z_gzread
# define gztell z_gztell
# define gztell64 z_gztell64
# define gzungetc z_gzungetc
+# define gzvprintf z_gzvprintf
# define gzwrite z_gzwrite
# endif
# define inflate z_inflate
# define inflateBack z_inflateBack
# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
# define inflateCopy z_inflateCopy
# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
# define inflateInit2_ z_inflateInit2_
# define inflateInit_ z_inflateInit_
# define inflateMark z_inflateMark
# define inflatePrime z_inflatePrime
# define inflateReset z_inflateReset
# define inflateReset2 z_inflateReset2
+# define inflateResetKeep z_inflateResetKeep
# define inflateSetDictionary z_inflateSetDictionary
-# define inflateGetDictionary z_inflateGetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateUndermine z_inflateUndermine
-# define inflateResetKeep z_inflateResetKeep
+# define inflateValidate z_inflateValidate
# define inflate_copyright z_inflate_copyright
# define inflate_fast z_inflate_fast
# define inflate_table z_inflate_table
# ifndef Z_SOLO
# define uncompress z_uncompress
+# define uncompress2 z_uncompress2
# endif
# define zError z_zError
# ifndef Z_SOLO
# define z_const
#endif
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-# define NO_DUMMY_DECL
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
#endif
/* Maximum value for memLevel in deflateInit2 */
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
for small objects.
*/
-.TH ZLIB 3 "28 Apr 2013"
+.TH ZLIB 3 "15 Jan 2017"
.SH NAME
zlib \- compression/decompression library
.SH SYNOPSIS
that accompanies the source.
.LP
.I zlib
-is available in Java using the java.util.zip package:
-.IP
-http://java.sun.com/developer/technicalArticles/Programming/compression/
-.LP
-A Perl interface to
-.IR zlib ,
-written by Paul Marquess (pmqs@cpan.org),
-is available at CPAN (Comprehensive Perl Archive Network) sites,
-including:
-.IP
-http://search.cpan.org/~pmqs/IO-Compress-Zlib/
-.LP
-A Python interface to
-.IR zlib ,
-written by A.M. Kuchling (amk@magnet.com),
-is available in Python 1.5 and later versions:
-.IP
-http://docs.python.org/library/zlib.html
-.LP
-.I zlib
-is built into
-.IR tcl:
-.IP
-http://wiki.tcl.tk/4610
+is built in to many languages and operating systems, including but not limited to
+Java, Python, .NET, PHP, Perl, Ruby, Swift, and Go.
.LP
-An experimental package to read and write files in .zip format,
+An experimental package to read and write files in the .zip format,
written on top of
.I zlib
by Gilles Vollant (info@winimage.com),
.IP
http://zlib.net/
.LP
-The data format used by the zlib library is described by RFC
+The data format used by the
+.I zlib
+library is described by RFC
(Request for Comments) 1950 to 1952 in the files:
.IP
http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format)
before asking for help.
Send questions and/or comments to zlib@gzip.org,
or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
-.SH AUTHORS
-Version 1.2.8
-Copyright (C) 1995-2013 Jean-loup Gailly (jloup@gzip.org)
-and Mark Adler (madler@alumni.caltech.edu).
-.LP
-This software is provided "as-is,"
-without any express or implied warranty.
-In no event will the authors be held liable for any damages
+.SH AUTHORS AND LICENSE
+Version 1.2.11
+.LP
+Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+.LP
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
-See the distribution directory with respect to requirements
-governing redistribution.
+.LP
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+.LP
+.nr step 1 1
+.IP \n[step]. 3
+The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+.IP \n+[step].
+Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+.IP \n+[step].
+This notice may not be removed or altered from any source distribution.
+.LP
+Jean-loup Gailly Mark Adler
+.br
+jloup@gzip.org madler@alumni.caltech.edu
+.LP
The deflate format used by
.I zlib
was defined by Phil Katz.
/* zlib.h -- interface of the 'zlib' general purpose compression library
- version 1.2.8, April 28th, 2013
+ version 1.2.11, January 15th, 2017
- Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
+ Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
extern "C" {
#endif
-#define ZLIB_VERSION "1.2.8"
-#define ZLIB_VERNUM 0x1280
+#define ZLIB_VERSION "1.2.11"
+#define ZLIB_VERNUM 0x12b0
#define ZLIB_VER_MAJOR 1
#define ZLIB_VER_MINOR 2
-#define ZLIB_VER_REVISION 8
+#define ZLIB_VER_REVISION 11
#define ZLIB_VER_SUBREVISION 0
/*
with "gz". The gzip format is different from the zlib format. gzip is a
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
- This library can optionally read and write gzip streams in memory as well.
+ This library can optionally read and write gzip and raw deflate streams in
+ memory as well.
The zlib format was designed to be compact and fast for use in memory
and on communications channels. The gzip format was designed for single-
The library does not install any signal handler. The decoder checks
the consistency of the compressed data, so the library should never crash
- even in case of corrupted input.
+ even in the case of corrupted input.
*/
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
uInt avail_in; /* number of bytes available at next_in */
uLong total_in; /* total number of input bytes read so far */
- Bytef *next_out; /* next output byte should be put there */
+ Bytef *next_out; /* next output byte will go here */
uInt avail_out; /* remaining free space at next_out */
uLong total_out; /* total number of bytes output so far */
free_func zfree; /* used to free the internal state */
voidpf opaque; /* private data object passed to zalloc and zfree */
- int data_type; /* best guess about the data type: binary or text */
- uLong adler; /* adler32 value of the uncompressed data */
+ int data_type; /* best guess about the data type: binary or text
+ for deflate, or the decoding state for inflate */
+ uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */
uLong reserved; /* reserved for future use */
} z_stream;
zalloc must return Z_NULL if there is not enough memory for the object.
If zlib is used in a multi-threaded application, zalloc and zfree must be
- thread safe.
+ thread safe. In that case, zlib is thread-safe. When zalloc and zfree are
+ Z_NULL on entry to the initialization function, they are set to internal
+ routines that use the standard library functions malloc() and free().
On 16-bit systems, the functions zalloc and zfree must be able to allocate
exactly 65536 bytes, but will not be required to allocate more than this if
The fields total_in and total_out can be used for statistics or progress
reports. After compression, total_in holds the total size of the
- uncompressed data and may be saved for use in the decompressor (particularly
+ uncompressed data and may be saved for use by the decompressor (particularly
if the decompressor wants to decompress everything in a single step).
*/
#define Z_TEXT 1
#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
#define Z_UNKNOWN 2
-/* Possible values of the data_type field (though see inflate()) */
+/* Possible values of the data_type field for deflate() */
#define Z_DEFLATED 8
/* The deflate compression method (the only one supported in this version) */
enough room in the output buffer), next_in and avail_in are updated and
processing will resume at this point for the next call of deflate().
- - Provide more output starting at next_out and update next_out and avail_out
+ - Generate more output starting at next_out and update next_out and avail_out
accordingly. This action is forced if the parameter flush is non zero.
Forcing flush frequently degrades the compression ratio, so this parameter
- should be set only when necessary (in interactive applications). Some
- output may be provided even if flush is not set.
+ should be set only when necessary. Some output may be provided even if
+ flush is zero.
Before the call of deflate(), the application should ensure that at least
one of the actions is possible, by providing more input and/or consuming more
output when it wants, for example when the output buffer is full (avail_out
== 0), or after each call of deflate(). If deflate returns Z_OK and with
zero avail_out, it must be called again after making room in the output
- buffer because there might be more output pending.
+ buffer because there might be more output pending. See deflatePending(),
+ which can be used if desired to determine whether or not there is more ouput
+ in that case.
Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
decide how much data to accumulate before producing output, in order to
input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
This completes the current deflate block and follows it with an empty fixed
codes block that is 10 bits long. This assures that enough bytes are output
- in order for the decompressor to finish the block before the empty fixed code
- block.
+ in order for the decompressor to finish the block before the empty fixed
+ codes block.
If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
If the parameter flush is set to Z_FINISH, pending input is processed,
pending output is flushed and deflate returns with Z_STREAM_END if there was
- enough output space; if deflate returns with Z_OK, this function must be
- called again with Z_FINISH and more output space (updated avail_out) but no
- more input data, until it returns with Z_STREAM_END or an error. After
- deflate has returned Z_STREAM_END, the only possible operations on the stream
- are deflateReset or deflateEnd.
-
- Z_FINISH can be used immediately after deflateInit if all the compression
- is to be done in a single step. In this case, avail_out must be at least the
- value returned by deflateBound (see below). Then deflate is guaranteed to
- return Z_STREAM_END. If not enough output space is provided, deflate will
- not return Z_STREAM_END, and it must be called again as described above.
-
- deflate() sets strm->adler to the adler32 checksum of all input read
- so far (that is, total_in bytes).
+ enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, this
+ function must be called again with Z_FINISH and more output space (updated
+ avail_out) but no more input data, until it returns with Z_STREAM_END or an
+ error. After deflate has returned Z_STREAM_END, the only possible operations
+ on the stream are deflateReset or deflateEnd.
+
+ Z_FINISH can be used in the first deflate call after deflateInit if all the
+ compression is to be done in a single step. In order to complete in one
+ call, avail_out must be at least the value returned by deflateBound (see
+ below). Then deflate is guaranteed to return Z_STREAM_END. If not enough
+ output space is provided, deflate will not return Z_STREAM_END, and it must
+ be called again as described above.
+
+ deflate() sets strm->adler to the Adler-32 checksum of all input read
+ so far (that is, total_in bytes). If a gzip stream is being generated, then
+ strm->adler will be the CRC-32 checksum of the input read so far. (See
+ deflateInit2 below.)
deflate() may update strm->data_type if it can make a good guess about
- the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
- binary. This field is only for information purposes and does not affect the
- compression algorithm in any manner.
+ the input data type (Z_BINARY or Z_TEXT). If in doubt, the data is
+ considered binary. This field is only for information purposes and does not
+ affect the compression algorithm in any manner.
deflate() returns Z_OK if some progress has been made (more input
processed or more output produced), Z_STREAM_END if all input has been
consumed and all output has been produced (only when flush is set to
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
- if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
- (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
- fatal, and deflate() can be called again with more input and more output
- space to continue compressing.
+ if next_in or next_out was Z_NULL or the state was inadvertently written over
+ by the application), or Z_BUF_ERROR if no progress is possible (for example
+ avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and
+ deflate() can be called again with more input and more output space to
+ continue compressing.
*/
Initializes the internal stream state for decompression. The fields
next_in, avail_in, zalloc, zfree and opaque must be initialized before by
- the caller. If next_in is not Z_NULL and avail_in is large enough (the
- exact value depends on the compression method), inflateInit determines the
- compression method from the zlib header and allocates all data structures
- accordingly; otherwise the allocation will be deferred to the first call of
- inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
- use default allocation functions.
+ the caller. In the current version of inflate, the provided input is not
+ read or consumed. The allocation of a sliding window will be deferred to
+ the first call of inflate (if the decompression does not complete on the
+ first call). If zalloc and zfree are set to Z_NULL, inflateInit updates
+ them to use default allocation functions.
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
version assumed by the caller, or Z_STREAM_ERROR if the parameters are
invalid, such as a null pointer to the structure. msg is set to null if
- there is no error message. inflateInit does not perform any decompression
- apart from possibly reading the zlib header if present: actual decompression
- will be done by inflate(). (So next_in and avail_in may be modified, but
- next_out and avail_out are unused and unchanged.) The current implementation
- of inflateInit() does not process any header information -- that is deferred
- until inflate() is called.
+ there is no error message. inflateInit does not perform any decompression.
+ Actual decompression will be done by inflate(). So next_in, and avail_in,
+ next_out, and avail_out are unused and unchanged. The current
+ implementation of inflateInit() does not process any header information --
+ that is deferred until inflate() is called.
*/
- Decompress more input starting at next_in and update next_in and avail_in
accordingly. If not all input can be processed (because there is not
- enough room in the output buffer), next_in is updated and processing will
- resume at this point for the next call of inflate().
+ enough room in the output buffer), then next_in and avail_in are updated
+ accordingly, and processing will resume at this point for the next call of
+ inflate().
- - Provide more output starting at next_out and update next_out and avail_out
+ - Generate more output starting at next_out and update next_out and avail_out
accordingly. inflate() provides as much output as possible, until there is
no more input data or no more space in the output buffer (see below about
the flush parameter).
Before the call of inflate(), the application should ensure that at least
one of the actions is possible, by providing more input and/or consuming more
- output, and updating the next_* and avail_* values accordingly. The
+ output, and updating the next_* and avail_* values accordingly. If the
+ caller of inflate() does not provide both available input and available
+ output space, it is possible that there will be no progress made. The
application can consume the uncompressed output when it wants, for example
when the output buffer is full (avail_out == 0), or after each call of
inflate(). If inflate returns Z_OK and with zero avail_out, it must be
gets to the end of that block, or when it runs out of data.
The Z_BLOCK option assists in appending to or combining deflate streams.
- Also to assist in this, on return inflate() will set strm->data_type to the
+ To assist in this, on return inflate() always sets strm->data_type to the
number of unused bits in the last byte taken from strm->next_in, plus 64 if
inflate() is currently decoding the last block in the deflate stream, plus
128 if inflate() returned immediately after decoding an end-of-block code or
this case all pending input is processed and all pending output is flushed;
avail_out must be large enough to hold all of the uncompressed data for the
operation to complete. (The size of the uncompressed data may have been
- saved by the compressor for this purpose.) The use of Z_FINISH is not
+ saved by the compressor for this purpose.) The use of Z_FINISH is not
required to perform an inflation in one step. However it may be used to
inform inflate that a faster approach can be used for the single inflate()
call. Z_FINISH also informs inflate to not maintain a sliding window if the
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
strm->adler to the Adler-32 checksum of all output produced so far (that is,
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
- below. At the end of the stream, inflate() checks that its computed adler32
+ below. At the end of the stream, inflate() checks that its computed Adler-32
checksum is equal to that saved by the compressor and returns Z_STREAM_END
only if the checksum is correct.
inflate() can decompress and check either zlib-wrapped or gzip-wrapped
deflate data. The header type is detected automatically, if requested when
initializing with inflateInit2(). Any information contained in the gzip
- header is not retained, so applications that need that information should
- instead use raw inflate, see inflateInit2() below, or inflateBack() and
- perform their own processing of the gzip header and trailer. When processing
+ header is not retained unless inflateGetHeader() is used. When processing
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
- producted so far. The CRC-32 is checked against the gzip trailer.
+ produced so far. The CRC-32 is checked against the gzip trailer, as is the
+ uncompressed length, modulo 2^32.
inflate() returns Z_OK if some progress has been made (more input processed
or more output produced), Z_STREAM_END if the end of the compressed data has
been reached and all uncompressed output has been produced, Z_NEED_DICT if a
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
corrupted (input stream not conforming to the zlib format or incorrect check
- value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
- next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
- Z_BUF_ERROR if no progress is possible or if there was not enough room in the
- output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+ value, in which case strm->msg points to a string with a more specific
+ error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+ next_in or next_out was Z_NULL, or the state was inadvertently written over
+ by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+ if no progress was possible or if there was not enough room in the output
+ buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
inflate() can be called again with more input and more output space to
continue decompressing. If Z_DATA_ERROR is returned, the application may
then call inflateSync() to look for a good compression block if a partial
- recovery of the data is desired.
+ recovery of the data is to be attempted.
*/
This function discards any unprocessed input and does not flush any pending
output.
- inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
- was inconsistent. In the error case, msg may be set but then points to a
- static string (which must not be deallocated).
+ inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
+ was inconsistent.
*/
compression at the expense of memory usage. The default value is 15 if
deflateInit is used instead.
+ For the current implementation of deflate(), a windowBits value of 8 (a
+ window size of 256 bytes) is not supported. As a result, a request for 8
+ will result in 9 (a 512-byte window). In that case, providing 8 to
+ inflateInit2() will result in an error when the zlib header with 9 is
+ checked against the initialization of inflate(). The remedy is to not use 8
+ with deflateInit2() with this initialization, or at least in that case use 9
+ with inflateInit2().
+
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
determines the window size. deflate() will then generate raw deflate data
- with no zlib header or trailer, and will not compute an adler32 check value.
+ with no zlib header or trailer, and will not compute a check value.
windowBits can also be greater than 15 for optional gzip encoding. Add
16 to windowBits to write a simple gzip header and trailer around the
compressed data instead of a zlib wrapper. The gzip header will have no
file name, no extra data, no comment, no modification time (set to zero), no
- header crc, and the operating system will be set to 255 (unknown). If a
- gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+ header crc, and the operating system will be set to the appropriate value,
+ if the operating system was determined at compile time. If a gzip stream is
+ being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+ For raw deflate or gzip encoding, a request for a 256-byte window is
+ rejected as invalid, since only the zlib header provides a means of
+ transmitting the window size to the decompressor.
The memLevel parameter specifies how much memory should be allocated
for the internal compression state. memLevel=1 uses minimum memory but is
addition, the current implementation of deflate will use at most the window
size minus 262 bytes of the provided dictionary.
- Upon return of this function, strm->adler is set to the adler32 value
+ Upon return of this function, strm->adler is set to the Adler-32 value
of the dictionary; the decompressor may later use this value to determine
- which dictionary has been used by the compressor. (The adler32 value
+ which dictionary has been used by the compressor. (The Adler-32 value
applies to the whole dictionary even if only a subset of the dictionary is
actually used by the compressor.) If a raw deflate was requested, then the
- adler32 value is not computed and strm->adler is not set.
+ Adler-32 value is not computed and strm->adler is not set.
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
not perform any compression: this will be done by deflate().
*/
+ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
+ Bytef *dictionary,
+ uInt *dictLength));
+/*
+ Returns the sliding dictionary being maintained by deflate. dictLength is
+ set to the number of bytes in the dictionary, and that many bytes are copied
+ to dictionary. dictionary must have enough space, where 32768 bytes is
+ always enough. If deflateGetDictionary() is called with dictionary equal to
+ Z_NULL, then only the dictionary length is returned, and nothing is copied.
+ Similary, if dictLength is Z_NULL, then it is not set.
+
+ deflateGetDictionary() may return a length less than the window size, even
+ when more than the window size in input has been provided. It may return up
+ to 258 bytes less in that case, due to how zlib's implementation of deflate
+ manages the sliding window and lookahead for matches, where matches can be
+ up to 258 bytes long. If the application needs the last window-size bytes of
+ input, then that would need to be saved by the application outside of zlib.
+
+ deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+ stream state is inconsistent.
+*/
+
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
z_streamp source));
/*
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
/*
- This function is equivalent to deflateEnd followed by deflateInit,
- but does not free and reallocate all the internal compression state. The
- stream will keep the same compression level and any other attributes that
- may have been set by deflateInit2.
+ This function is equivalent to deflateEnd followed by deflateInit, but
+ does not free and reallocate the internal compression state. The stream
+ will leave the compression level and any other attributes that may have been
+ set unchanged.
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
stream state was inconsistent (such as zalloc or state being Z_NULL).
int strategy));
/*
Dynamically update the compression level and compression strategy. The
- interpretation of level and strategy is as in deflateInit2. This can be
+ interpretation of level and strategy is as in deflateInit2(). This can be
used to switch between compression and straight copy of the input data, or
to switch to a different kind of input data requiring a different strategy.
- If the compression level is changed, the input available so far is
- compressed with the old level (and may be flushed); the new level will take
- effect only at the next call of deflate().
-
- Before the call of deflateParams, the stream state must be set as for
- a call of deflate(), since the currently available input may have to be
- compressed and flushed. In particular, strm->avail_out must be non-zero.
-
- deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
- stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
- strm->avail_out was zero.
+ If the compression approach (which is a function of the level) or the
+ strategy is changed, and if any input has been consumed in a previous
+ deflate() call, then the input available so far is compressed with the old
+ level and strategy using deflate(strm, Z_BLOCK). There are three approaches
+ for the compression levels 0, 1..3, and 4..9 respectively. The new level
+ and strategy will take effect at the next call of deflate().
+
+ If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+ not have enough output space to complete, then the parameter change will not
+ take effect. In this case, deflateParams() can be called again with the
+ same parameters and more output space to try again.
+
+ In order to assure a change in the parameters on the first try, the
+ deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+ request until strm.avail_out is not zero, before calling deflateParams().
+ Then no more input data should be provided before the deflateParams() call.
+ If this is done, the old level and strategy will be applied to the data
+ compressed before deflateParams(), and the new level and strategy will be
+ applied to the the data compressed after deflateParams().
+
+ deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+ state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+ there was not enough output space to complete the compression of the
+ available input data before a change in the strategy or approach. Note that
+ in the case of a Z_BUF_ERROR, the parameters are not changed. A return
+ value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+ retried with more output space.
*/
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
is for use with other formats that use the deflate compressed data format
such as zip. Those formats provide their own check values. If a custom
format is developed using the raw deflate format for compressed data, it is
- recommended that a check value such as an adler32 or a crc32 be applied to
+ recommended that a check value such as an Adler-32 or a CRC-32 be applied to
the uncompressed data as is done in the zlib, gzip, and zip formats. For
most applications, the zlib format should be used as is. Note that comments
above on the use in deflateInit2() applies to the magnitude of windowBits.
32 to windowBits to enable zlib and gzip decoding with automatic header
detection, or add 16 to decode only the gzip format (the zlib format will
return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
- crc32 instead of an adler32.
+ CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see
+ below), inflate() will not automatically decode concatenated gzip streams.
+ inflate() will return Z_STREAM_END at the end of the gzip stream. The state
+ would need to be reset to continue decoding a subsequent gzip stream.
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
Initializes the decompression dictionary from the given uncompressed byte
sequence. This function must be called immediately after a call of inflate,
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
- can be determined from the adler32 value returned by that call of inflate.
+ can be determined from the Adler-32 value returned by that call of inflate.
The compressor and decompressor must use exactly the same dictionary (see
deflateSetDictionary). For raw inflate, this function can be called at any
time to set the dictionary. If the provided dictionary is smaller than the
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
- expected one (incorrect adler32 value). inflateSetDictionary does not
+ expected one (incorrect Adler-32 value). inflateSetDictionary does not
perform any decompression: this will be done by subsequent calls of
inflate().
*/
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
/*
This function is equivalent to inflateEnd followed by inflateInit,
- but does not free and reallocate all the internal decompression state. The
+ but does not free and reallocate the internal decompression state. The
stream will keep attributes that may have been set by inflateInit2.
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
/*
This function is the same as inflateReset, but it also permits changing
the wrap and window size requests. The windowBits parameter is interpreted
- the same as it is for inflateInit2.
+ the same as it is for inflateInit2. If the window size is changed, then the
+ memory allocated for the window is freed, and the window will be reallocated
+ by inflate() if needed.
inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
stream state was inconsistent (such as zalloc or state being Z_NULL), or if
location in the input stream can be determined from avail_in and data_type
as noted in the description for the Z_BLOCK flush parameter for inflate.
- inflateMark returns the value noted above or -1 << 16 if the provided
+ inflateMark returns the value noted above, or -65536 if the provided
source stream state was inconsistent.
*/
This routine would normally be used in a utility that reads zip or gzip
files and writes out uncompressed files. The utility would decode the
header and process the trailer on its own, hence this routine expects only
- the raw deflate stream to decompress. This is different from the normal
- behavior of inflate(), which expects either a zlib or gzip header and
- trailer around the deflate stream.
+ the raw deflate stream to decompress. This is different from the default
+ behavior of inflate(), which expects a zlib header and trailer around the
+ deflate stream.
inflateBack() uses two subroutines supplied by the caller that are then
called by inflateBack() for input and output. inflateBack() calls those
parameters and return types are defined above in the in_func and out_func
typedefs. inflateBack() will call in(in_desc, &buf) which should return the
number of bytes of provided input, and a pointer to that input in buf. If
- there is no input available, in() must return zero--buf is ignored in that
- case--and inflateBack() will return a buffer error. inflateBack() will call
- out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
- should return zero on success, or non-zero on failure. If out() returns
- non-zero, inflateBack() will return with an error. Neither in() nor out()
- are permitted to change the contents of the window provided to
+ there is no input available, in() must return zero -- buf is ignored in that
+ case -- and inflateBack() will return a buffer error. inflateBack() will
+ call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
+ out() should return zero on success, or non-zero on failure. If out()
+ returns non-zero, inflateBack() will return with an error. Neither in() nor
+ out() are permitted to change the contents of the window provided to
inflateBackInit(), which is also the buffer that out() uses to write from.
The length written by out() will be at most the window size. Any non-zero
amount of input may be provided by in().
using strm->next_in which will be Z_NULL only if in() returned an error. If
strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
non-zero. (in() will always be called before out(), so strm->next_in is
- assured to be defined if out() returns non-zero.) Note that inflateBack()
+ assured to be defined if out() returns non-zero.) Note that inflateBack()
cannot return Z_OK.
*/
7.6: size of z_off_t
Compiler, assembler, and debug options:
- 8: DEBUG
+ 8: ZLIB_DEBUG
9: ASMV or ASMINF -- use ASM code
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
11: 0 (reserved)
the byte length of the source buffer. Upon entry, destLen is the total size
of the destination buffer, which must be at least the value returned by
compressBound(sourceLen). Upon exit, destLen is the actual size of the
- compressed buffer.
+ compressed data. compress() is equivalent to compress2() with a level
+ parameter of Z_DEFAULT_COMPRESSION.
compress returns Z_OK if success, Z_MEM_ERROR if there was not
enough memory, Z_BUF_ERROR if there was not enough room in the output
length of the source buffer. Upon entry, destLen is the total size of the
destination buffer, which must be at least the value returned by
compressBound(sourceLen). Upon exit, destLen is the actual size of the
- compressed buffer.
+ compressed data.
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
uncompressed data. (The size of the uncompressed data must have been saved
previously by the compressor and transmitted to the decompressor by some
mechanism outside the scope of this compression library.) Upon exit, destLen
- is the actual size of the uncompressed buffer.
+ is the actual size of the uncompressed data.
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
enough memory, Z_BUF_ERROR if there was not enough room in the output
buffer with the uncompressed data up to that point.
*/
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong *sourceLen));
+/*
+ Same as uncompress, except that sourceLen is a pointer, where the
+ length of the source is *sourceLen. On return, *sourceLen is the number of
+ source bytes consumed.
+*/
+
/* gzip file access functions */
/*
default buffer size is 8192 bytes. This function must be called after
gzopen() or gzdopen(), and before any other calls that read or write the
file. The buffer memory allocation is always deferred to the first read or
- write. Two buffers are allocated, either both of the specified size when
- writing, or one of the specified size and the other twice that size when
- reading. A larger buffer size of, for example, 64K or 128K bytes will
- noticeably increase the speed of decompression (reading).
+ write. Three times that size in buffer space is allocated. A larger buffer
+ size of, for example, 64K or 128K bytes will noticeably increase the speed
+ of decompression (reading).
The new buffer size also affects the maximum length for gzprintf().
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
/*
Dynamically update the compression level or strategy. See the description
- of deflateInit2 for the meaning of these parameters.
+ of deflateInit2 for the meaning of these parameters. Previously provided
+ data is flushed before the parameter change.
- gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
- opened for writing.
+ gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+ opened for writing, Z_ERRNO if there is an error writing the flushed data,
+ or Z_MEM_ERROR if there is a memory allocation error.
*/
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
case.
gzread returns the number of uncompressed bytes actually read, less than
- len for end of file, or -1 for error.
+ len for end of file, or -1 for error. If len is too large to fit in an int,
+ then nothing is read, -1 is returned, and the error state is set to
+ Z_STREAM_ERROR.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
+ gzFile file));
+/*
+ Read up to nitems items of size size from file to buf, otherwise operating
+ as gzread() does. This duplicates the interface of stdio's fread(), with
+ size_t request and return types. If the library defines size_t, then
+ z_size_t is identical to size_t. If not, then z_size_t is an unsigned
+ integer type that can contain a pointer.
+
+ gzfread() returns the number of full items read of size size, or zero if
+ the end of the file was reached and a full item could not be read, or if
+ there was an error. gzerror() must be consulted if zero is returned in
+ order to determine if there was an error. If the multiplication of size and
+ nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+ is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+ In the event that the end of file is reached and only a partial item is
+ available at the end, i.e. the remaining uncompressed data length is not a
+ multiple of size, then the final partial item is nevetheless read into buf
+ and the end-of-file flag is set. The length of the partial item read is not
+ provided, but could be inferred from the result of gztell(). This behavior
+ is the same as the behavior of fread() implementations in common libraries,
+ but it prevents the direct use of gzfread() to read a concurrently written
+ file, reseting and retrying on end-of-file, when size is not 1.
*/
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
error.
*/
+ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
+ z_size_t nitems, gzFile file));
+/*
+ gzfwrite() writes nitems items of size size from buf to file, duplicating
+ the interface of stdio's fwrite(), with size_t request and return types. If
+ the library defines size_t, then z_size_t is identical to size_t. If not,
+ then z_size_t is an unsigned integer type that can contain a pointer.
+
+ gzfwrite() returns the number of full items written of size size, or zero
+ if there was an error. If the multiplication of size and nitems overflows,
+ i.e. the product does not fit in a z_size_t, then nothing is written, zero
+ is returned, and the error state is set to Z_STREAM_ERROR.
+*/
+
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
/*
Converts, formats, and writes the arguments to the compressed file under
control of the format string, as in fprintf. gzprintf returns the number of
- uncompressed bytes actually written, or 0 in case of error. The number of
- uncompressed bytes written is limited to 8191, or one less than the buffer
- size given to gzbuffer(). The caller should assure that this limit is not
- exceeded. If it is exceeded, then gzprintf() will return an error (0) with
- nothing written. In this case, there may also be a buffer overflow with
- unpredictable consequences, which is possible only if zlib was compiled with
- the insecure functions sprintf() or vsprintf() because the secure snprintf()
- or vsnprintf() functions were not available. This can be determined using
- zlibCompileFlags().
+ uncompressed bytes actually written, or a negative zlib error code in case
+ of error. The number of uncompressed bytes written is limited to 8191, or
+ one less than the buffer size given to gzbuffer(). The caller should assure
+ that this limit is not exceeded. If it is exceeded, then gzprintf() will
+ return an error (0) with nothing written. In this case, there may also be a
+ buffer overflow with unpredictable consequences, which is possible only if
+ zlib was compiled with the insecure functions sprintf() or vsprintf()
+ because the secure snprintf() or vsnprintf() functions were not available.
+ This can be determined using zlibCompileFlags().
*/
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
If the flush parameter is Z_FINISH, the remaining data is written and the
gzip stream is completed in the output. If gzwrite() is called again, a new
gzip stream will be started in the output. gzread() is able to read such
- concatented gzip streams.
+ concatenated gzip streams.
gzflush should be called only when strictly necessary because it will
degrade compression if called too often.
return the updated checksum. If buf is Z_NULL, this function returns the
required initial value for the checksum.
- An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+ An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
much faster.
Usage example:
if (adler != original_adler) error();
*/
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
+ z_size_t len));
+/*
+ Same as adler32(), but with a size_t length.
+*/
+
/*
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
z_off_t len2));
if (crc != original_crc) error();
*/
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
+ z_size_t len));
+/*
+ Same as crc32(), but with a size_t length.
+*/
+
/*
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
unsigned char FAR *window,
const char *version,
int stream_size));
-#define deflateInit(strm, level) \
- deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateInit(strm) \
- inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
-#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
- deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
- (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
-#define inflateInit2(strm, windowBits) \
- inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
- (int)sizeof(z_stream))
-#define inflateBackInit(strm, windowBits, window) \
- inflateBackInit_((strm), (windowBits), (window), \
- ZLIB_VERSION, (int)sizeof(z_stream))
+#ifdef Z_PREFIX_SET
+# define z_deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+ (int)sizeof(z_stream))
+# define z_inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, (int)sizeof(z_stream))
+#else
+# define deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+# define inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+# define inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+ (int)sizeof(z_stream))
+# define inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, (int)sizeof(z_stream))
+#endif
#ifndef Z_SOLO
#ifdef Z_PREFIX_SET
# undef z_gzgetc
# define z_gzgetc(g) \
- ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
#else
# define gzgetc(g) \
- ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
+ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
#endif
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
#endif /* !Z_SOLO */
-/* hack for buggy compilers */
-#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
- struct internal_state {int dummy;};
-#endif
-
/* undocumented functions */
ZEXTERN const char * ZEXPORT zError OF((int));
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
+ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
+ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
-#if defined(_WIN32) && !defined(Z_SOLO)
+#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO)
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
const char *mode));
#endif
-ZLIB_1.2.0 {
- global:
- compressBound;
- deflateBound;
- inflateBack;
- inflateBackEnd;
- inflateBackInit_;
- inflateCopy;
- local:
- deflate_copyright;
- inflate_copyright;
- inflate_fast;
- inflate_table;
- zcalloc;
- zcfree;
- z_errmsg;
- gz_error;
- gz_intmax;
- _*;
-};
-
-ZLIB_1.2.0.2 {
- gzclearerr;
- gzungetc;
- zlibCompileFlags;
-} ZLIB_1.2.0;
-
-ZLIB_1.2.0.8 {
- deflatePrime;
-} ZLIB_1.2.0.2;
-
-ZLIB_1.2.2 {
- adler32_combine;
- crc32_combine;
- deflateSetHeader;
- inflateGetHeader;
-} ZLIB_1.2.0.8;
-
-ZLIB_1.2.2.3 {
- deflateTune;
- gzdirect;
-} ZLIB_1.2.2;
-
-ZLIB_1.2.2.4 {
- inflatePrime;
-} ZLIB_1.2.2.3;
-
-ZLIB_1.2.3.3 {
- adler32_combine64;
- crc32_combine64;
- gzopen64;
- gzseek64;
- gztell64;
- inflateUndermine;
-} ZLIB_1.2.2.4;
-
-ZLIB_1.2.3.4 {
- inflateReset2;
- inflateMark;
-} ZLIB_1.2.3.3;
-
-ZLIB_1.2.3.5 {
- gzbuffer;
- gzoffset;
- gzoffset64;
- gzclose_r;
- gzclose_w;
-} ZLIB_1.2.3.4;
-
-ZLIB_1.2.5.1 {
- deflatePending;
-} ZLIB_1.2.3.5;
-
-ZLIB_1.2.5.2 {
- deflateResetKeep;
- gzgetc_;
- inflateResetKeep;
-} ZLIB_1.2.5.1;
-
-ZLIB_1.2.7.1 {
- inflateGetDictionary;
- gzvprintf;
-} ZLIB_1.2.5.2;
+ZLIB_1.2.0 {\r
+ global:\r
+ compressBound;\r
+ deflateBound;\r
+ inflateBack;\r
+ inflateBackEnd;\r
+ inflateBackInit_;\r
+ inflateCopy;\r
+ local:\r
+ deflate_copyright;\r
+ inflate_copyright;\r
+ inflate_fast;\r
+ inflate_table;\r
+ zcalloc;\r
+ zcfree;\r
+ z_errmsg;\r
+ gz_error;\r
+ gz_intmax;\r
+ _*;\r
+};\r
+\r
+ZLIB_1.2.0.2 {\r
+ gzclearerr;\r
+ gzungetc;\r
+ zlibCompileFlags;\r
+} ZLIB_1.2.0;\r
+\r
+ZLIB_1.2.0.8 {\r
+ deflatePrime;\r
+} ZLIB_1.2.0.2;\r
+\r
+ZLIB_1.2.2 {\r
+ adler32_combine;\r
+ crc32_combine;\r
+ deflateSetHeader;\r
+ inflateGetHeader;\r
+} ZLIB_1.2.0.8;\r
+\r
+ZLIB_1.2.2.3 {\r
+ deflateTune;\r
+ gzdirect;\r
+} ZLIB_1.2.2;\r
+\r
+ZLIB_1.2.2.4 {\r
+ inflatePrime;\r
+} ZLIB_1.2.2.3;\r
+\r
+ZLIB_1.2.3.3 {\r
+ adler32_combine64;\r
+ crc32_combine64;\r
+ gzopen64;\r
+ gzseek64;\r
+ gztell64;\r
+ inflateUndermine;\r
+} ZLIB_1.2.2.4;\r
+\r
+ZLIB_1.2.3.4 {\r
+ inflateReset2;\r
+ inflateMark;\r
+} ZLIB_1.2.3.3;\r
+\r
+ZLIB_1.2.3.5 {\r
+ gzbuffer;\r
+ gzoffset;\r
+ gzoffset64;\r
+ gzclose_r;\r
+ gzclose_w;\r
+} ZLIB_1.2.3.4;\r
+\r
+ZLIB_1.2.5.1 {\r
+ deflatePending;\r
+} ZLIB_1.2.3.5;\r
+\r
+ZLIB_1.2.5.2 {\r
+ deflateResetKeep;\r
+ gzgetc_;\r
+ inflateResetKeep;\r
+} ZLIB_1.2.5.1;\r
+\r
+ZLIB_1.2.7.1 {\r
+ inflateGetDictionary;\r
+ gzvprintf;\r
+} ZLIB_1.2.5.2;\r
+\r
+ZLIB_1.2.9 {\r
+ inflateCodesUsed;\r
+ inflateValidate;\r
+ uncompress2;\r
+ gzfread;\r
+ gzfwrite;\r
+ deflateGetDictionary;\r
+ adler32_z;\r
+ crc32_z;\r
+} ZLIB_1.2.7.1;\r
/* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
+ * Copyright (C) 1995-2017 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
# include "gzguts.h"
#endif
-#ifndef NO_DUMMY_DECL
-struct internal_state {int dummy;}; /* for buggy compilers */
-#endif
-
z_const char * const z_errmsg[10] = {
-"need dictionary", /* Z_NEED_DICT 2 */
-"stream end", /* Z_STREAM_END 1 */
-"", /* Z_OK 0 */
-"file error", /* Z_ERRNO (-1) */
-"stream error", /* Z_STREAM_ERROR (-2) */
-"data error", /* Z_DATA_ERROR (-3) */
-"insufficient memory", /* Z_MEM_ERROR (-4) */
-"buffer error", /* Z_BUF_ERROR (-5) */
-"incompatible version",/* Z_VERSION_ERROR (-6) */
-""};
+ (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
+ (z_const char *)"stream end", /* Z_STREAM_END 1 */
+ (z_const char *)"", /* Z_OK 0 */
+ (z_const char *)"file error", /* Z_ERRNO (-1) */
+ (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
+ (z_const char *)"data error", /* Z_DATA_ERROR (-3) */
+ (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
+ (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
+ (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
+ (z_const char *)""
+};
const char * ZEXPORT zlibVersion()
case 8: flags += 2 << 6; break;
default: flags += 3 << 6;
}
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
flags += 1 << 8;
#endif
#if defined(ASMV) || defined(ASMINF)
return flags;
}
-#ifdef DEBUG
-
+#ifdef ZLIB_DEBUG
+#include <stdlib.h>
# ifndef verbose
# define verbose 0
# endif
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
{
- voidpf buf = opaque; /* just to make some compilers happy */
+ voidpf buf;
ulg bsize = (ulg)items*size;
+ (void)opaque;
+
/* If we allocate less than 65520 bytes, we assume that farmalloc
* will return a usable pointer which doesn't have to be normalized.
*/
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
{
int n;
+
+ (void)opaque;
+
if (*(ush*)&ptr != 0) { /* object < 64K */
farfree(ptr);
return;
next_ptr--;
return;
}
- ptr = opaque; /* just to make some compilers happy */
Assert(0, "zcfree: ptr not found");
}
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
{
- if (opaque) opaque = 0; /* to make compiler happy */
+ (void)opaque;
return _halloc((long)items, size);
}
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
{
- if (opaque) opaque = 0; /* to make compiler happy */
+ (void)opaque;
_hfree(ptr);
}
unsigned items;
unsigned size;
{
- if (opaque) items += size - size; /* make compiler happy */
+ (void)opaque;
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
(voidpf)calloc(items, size);
}
voidpf opaque;
voidpf ptr;
{
+ (void)opaque;
free(ptr);
- if (opaque) return; /* make compiler happy */
}
#endif /* MY_ZCALLOC */
/* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifndef local
# define local static
#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
+/* since "static" is used to mean two completely different things in C, we
+ define "local" for the non-static meaning of "static", for readability
+ (compile with -Dlocal if your debugger can't find static symbols) */
typedef unsigned char uch;
typedef uch FAR uchf;
#endif
#ifdef AMIGA
-# define OS_CODE 0x01
+# define OS_CODE 1
#endif
#if defined(VAXC) || defined(VMS)
-# define OS_CODE 0x02
+# define OS_CODE 2
# define F_OPEN(name, mode) \
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
#endif
+#ifdef __370__
+# if __TARGET_LIB__ < 0x20000000
+# define OS_CODE 4
+# elif __TARGET_LIB__ < 0x40000000
+# define OS_CODE 11
+# else
+# define OS_CODE 8
+# endif
+#endif
+
#if defined(ATARI) || defined(atarist)
-# define OS_CODE 0x05
+# define OS_CODE 5
#endif
#ifdef OS2
-# define OS_CODE 0x06
+# define OS_CODE 6
# if defined(M_I86) && !defined(Z_SOLO)
# include <malloc.h>
# endif
#endif
#if defined(MACOS) || defined(TARGET_OS_MAC)
-# define OS_CODE 0x07
+# define OS_CODE 7
# ifndef Z_SOLO
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
# include <unix.h> /* for fdopen */
# endif
#endif
-#ifdef TOPS20
-# define OS_CODE 0x0a
+#ifdef __acorn
+# define OS_CODE 13
#endif
-#ifdef WIN32
-# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
-# define OS_CODE 0x0b
-# endif
+#if defined(WIN32) && !defined(__CYGWIN__)
+# define OS_CODE 10
+#endif
+
+#ifdef _BEOS_
+# define OS_CODE 16
+#endif
+
+#ifdef __TOS_OS400__
+# define OS_CODE 18
#endif
-#ifdef __50SERIES /* Prime/PRIMOS */
-# define OS_CODE 0x0f
+#ifdef __APPLE__
+# define OS_CODE 19
#endif
#if defined(_BEOS_) || defined(RISCOS)
/* common defaults */
#ifndef OS_CODE
-# define OS_CODE 0x03 /* assume Unix */
+# define OS_CODE 3 /* assume Unix */
#endif
#ifndef F_OPEN
#endif
/* Diagnostic functions */
-#ifdef DEBUG
+#ifdef ZLIB_DEBUG
# include <stdio.h>
extern int ZLIB_INTERNAL z_verbose;
extern void ZLIB_INTERNAL z_error OF((char *m));
return result;
}
-/* Positional arguments are obj followed args. */
+/* Positional arguments are obj followed by args. */
PyObject *
_PyObject_Call_Prepend(PyObject *func,
PyObject *obj, PyObject *args, PyObject *kwargs)
if (PyIndex_Check(arg)) {
count = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
if (count == -1 && PyErr_Occurred()) {
- return -1;
- }
- if (count < 0) {
- PyErr_SetString(PyExc_ValueError, "negative count");
- return -1;
+ if (PyErr_ExceptionMatches(PyExc_OverflowError))
+ return -1;
+ PyErr_Clear(); /* fall through */
}
- if (count > 0) {
- if (PyByteArray_Resize((PyObject *)self, count))
+ else {
+ if (count < 0) {
+ PyErr_SetString(PyExc_ValueError, "negative count");
return -1;
- memset(PyByteArray_AS_STRING(self), 0, count);
+ }
+ if (count > 0) {
+ if (PyByteArray_Resize((PyObject *)self, count))
+ return -1;
+ memset(PyByteArray_AS_STRING(self), 0, count);
+ }
+ return 0;
}
- return 0;
}
/* Use the buffer API */
/* Write the numeric prefix for "x", "X" and "o" formats
if the alternate form is used.
For example, write "0x" for the "%#x" format. */
- if ((flags & F_ALT) && (c == 'x' || c == 'X')) {
+ if ((flags & F_ALT) && (c == 'o' || c == 'x' || c == 'X')) {
assert(pbuf[0] == '0');
assert(pbuf[1] == c);
if (fill != ' ') {
if (fill == ' ') {
if (sign)
*res++ = sign;
- if ((flags & F_ALT) &&
- (c == 'x' || c == 'X')) {
+ if ((flags & F_ALT) && (c == 'o' || c == 'x' || c == 'X')) {
assert(pbuf[0] == '0');
assert(pbuf[1] == c);
*res++ = *pbuf++;
if (PyIndex_Check(x)) {
size = PyNumber_AsSsize_t(x, PyExc_OverflowError);
if (size == -1 && PyErr_Occurred()) {
- return NULL;
+ if (PyErr_ExceptionMatches(PyExc_OverflowError))
+ return NULL;
+ PyErr_Clear(); /* fall through */
}
- if (size < 0) {
- PyErr_SetString(PyExc_ValueError, "negative count");
- return NULL;
+ else {
+ if (size < 0) {
+ PyErr_SetString(PyExc_ValueError, "negative count");
+ return NULL;
+ }
+ new = _PyBytes_FromSize(size, 1);
+ if (new == NULL)
+ return NULL;
+ return new;
}
- new = _PyBytes_FromSize(size, 1);
- if (new == NULL)
- return NULL;
- return new;
}
return PyBytes_FromObject(x);
PyTuple_SET_ITEM(tuple, i, item_key);
}
- key = PyTuple_Pack(3, Py_TYPE(op), op, tuple);
+ key = PyTuple_Pack(2, tuple, op);
Py_DECREF(tuple);
}
else if (PyFrozenSet_CheckExact(op)) {
if (set == NULL)
return NULL;
- key = PyTuple_Pack(3, Py_TYPE(op), op, set);
+ key = PyTuple_Pack(2, set, op);
Py_DECREF(set);
return key;
}
if (obj_id == NULL)
return NULL;
- key = PyTuple_Pack(3, Py_TYPE(op), op, obj_id);
+ key = PyTuple_Pack(2, obj_id, op);
Py_DECREF(obj_id);
}
return key;
_PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra *) o->co_extra;
if (co_extra == NULL) {
- o->co_extra = (_PyCodeObjectExtra*) PyMem_Malloc(
- sizeof(_PyCodeObjectExtra));
- if (o->co_extra == NULL) {
+ co_extra = PyMem_Malloc(sizeof(_PyCodeObjectExtra));
+ if (co_extra == NULL) {
return -1;
}
- co_extra = (_PyCodeObjectExtra *) o->co_extra;
co_extra->ce_extras = PyMem_Malloc(
tstate->co_extra_user_count * sizeof(void*));
if (co_extra->ce_extras == NULL) {
+ PyMem_Free(co_extra);
return -1;
}
for (Py_ssize_t i = 0; i < co_extra->ce_size; i++) {
co_extra->ce_extras[i] = NULL;
}
+
+ o->co_extra = co_extra;
}
else if (co_extra->ce_size <= index) {
- co_extra->ce_extras = PyMem_Realloc(
+ void** ce_extras = PyMem_Realloc(
co_extra->ce_extras, tstate->co_extra_user_count * sizeof(void*));
- if (co_extra->ce_extras == NULL) {
+ if (ce_extras == NULL) {
return -1;
}
- co_extra->ce_size = tstate->co_extra_user_count;
-
- for (Py_ssize_t i = co_extra->ce_size; i < co_extra->ce_size; i++) {
- co_extra->ce_extras[i] = NULL;
+ for (Py_ssize_t i = co_extra->ce_size;
+ i < tstate->co_extra_user_count;
+ i++) {
+ ce_extras[i] = NULL;
}
+
+ co_extra->ce_extras = ce_extras;
+ co_extra->ce_size = tstate->co_extra_user_count;
}
co_extra->ce_extras[index] = extra;
return NULL;
}
cr.real = PyFloat_AsDouble(tmp);
- cr.imag = 0.0; /* Shut up compiler warning */
+ cr.imag = 0.0;
Py_DECREF(tmp);
}
if (i == NULL) {
- ci.real = 0.0;
+ ci.real = cr.imag;
}
else if (PyComplex_Check(i)) {
ci = ((PyComplexObject*)i)->cval;
if (ci_is_complex) {
cr.real -= ci.imag;
}
- if (cr_is_complex) {
+ if (cr_is_complex && i != NULL) {
ci.real += cr.imag;
}
return complex_subtype_from_doubles(type, cr.real, ci.real);
* This can be used to reserve enough size to insert n entries without
* resizing.
*/
-#define ESTIMATE_SIZE(n) (((n)*3) >> 1)
+#define ESTIMATE_SIZE(n) (((n)*3+1) >> 1)
/* Alternative fraction that is otherwise close enough to 2n/3 to make
* little difference. 8 * 2/3 == 8 * 5/8 == 5. 16 * 2/3 == 16 * 5/8 == 10.
lookdict() is general-purpose, and may return DKIX_ERROR if (and only if) a
comparison raises an exception.
lookdict_unicode() below is specialized to string keys, comparison of which can
-never raise an exception; that function can never return DKIX_ERROR.
+never raise an exception; that function can never return DKIX_ERROR when key
+is string. Otherwise, it falls back to lookdict().
lookdict_unicode_nodummy is further specialized for string keys that cannot be
the <dummy> value.
For both, when the key isn't found a DKIX_EMPTY is returned. hashpos returns
PyObject *
_PyDict_NewPresized(Py_ssize_t minused)
{
+ const Py_ssize_t max_presize = 128 * 1024;
Py_ssize_t newsize;
PyDictKeysObject *new_keys;
- for (newsize = PyDict_MINSIZE;
- newsize <= minused && newsize > 0;
- newsize <<= 1)
- ;
+
+ /* There are no strict guarantee that returned dict can contain minused
+ * items without resize. So we create medium size dict instead of very
+ * large dict or MemoryError.
+ */
+ if (minused > USABLE_FRACTION(max_presize)) {
+ newsize = max_presize;
+ }
+ else {
+ Py_ssize_t minsize = ESTIMATE_SIZE(minused);
+ newsize = PyDict_MINSIZE;
+ while (newsize < minsize) {
+ newsize <<= 1;
+ }
+ }
+ assert(IS_POWER_OF_2(newsize));
+
new_keys = new_keys_object(newsize);
if (new_keys == NULL)
return NULL;
return insertdict(mp, key, hash, value);
}
+static int
+delitem_common(PyDictObject *mp, Py_ssize_t hashpos, Py_ssize_t ix,
+ PyObject **value_addr)
+{
+ PyObject *old_key, *old_value;
+ PyDictKeyEntry *ep;
+
+ old_value = *value_addr;
+ assert(old_value != NULL);
+ *value_addr = NULL;
+ mp->ma_used--;
+ mp->ma_version_tag = DICT_NEXT_VERSION();
+ ep = &DK_ENTRIES(mp->ma_keys)[ix];
+ dk_set_index(mp->ma_keys, hashpos, DKIX_DUMMY);
+ ENSURE_ALLOWS_DELETIONS(mp);
+ old_key = ep->me_key;
+ ep->me_key = NULL;
+ Py_DECREF(old_key);
+ Py_DECREF(old_value);
+
+ assert(_PyDict_CheckConsistency(mp));
+ return 0;
+}
+
int
PyDict_DelItem(PyObject *op, PyObject *key)
{
Py_hash_t hash;
-
assert(key);
if (!PyUnicode_CheckExact(key) ||
(hash = ((PyASCIIObject *) key)->hash) == -1) {
{
Py_ssize_t hashpos, ix;
PyDictObject *mp;
- PyDictKeyEntry *ep;
- PyObject *old_key, *old_value;
PyObject **value_addr;
if (!PyDict_Check(op)) {
ix = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr, &hashpos);
assert(ix >= 0);
}
+ return delitem_common(mp, hashpos, ix, value_addr);
+}
- old_value = *value_addr;
- assert(old_value != NULL);
- *value_addr = NULL;
- mp->ma_used--;
- mp->ma_version_tag = DICT_NEXT_VERSION();
- ep = &DK_ENTRIES(mp->ma_keys)[ix];
- dk_set_index(mp->ma_keys, hashpos, DKIX_DUMMY);
- ENSURE_ALLOWS_DELETIONS(mp);
- old_key = ep->me_key;
- ep->me_key = NULL;
- Py_DECREF(old_key);
- Py_DECREF(old_value);
+/* This function promises that the predicate -> deletion sequence is atomic
+ * (i.e. protected by the GIL), assuming the predicate itself doesn't
+ * release the GIL.
+ */
+int
+_PyDict_DelItemIf(PyObject *op, PyObject *key,
+ int (*predicate)(PyObject *value))
+{
+ Py_ssize_t hashpos, ix;
+ PyDictObject *mp;
+ Py_hash_t hash;
+ PyObject **value_addr;
+ int res;
- assert(_PyDict_CheckConsistency(mp));
- return 0;
+ if (!PyDict_Check(op)) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ assert(key);
+ hash = PyObject_Hash(key);
+ if (hash == -1)
+ return -1;
+ mp = (PyDictObject *)op;
+ ix = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr, &hashpos);
+ if (ix == DKIX_ERROR)
+ return -1;
+ if (ix == DKIX_EMPTY || *value_addr == NULL) {
+ _PyErr_SetKeyError(key);
+ return -1;
+ }
+ assert(dk_get_index(mp->ma_keys, hashpos) == ix);
+
+ // Split table doesn't allow deletion. Combine it.
+ if (_PyDict_HasSplitTable(mp)) {
+ if (dictresize(mp, DK_SIZE(mp->ma_keys))) {
+ return -1;
+ }
+ ix = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr, &hashpos);
+ assert(ix >= 0);
+ }
+
+ res = predicate(*value_addr);
+ if (res == -1)
+ return -1;
+ if (res > 0)
+ return delitem_common(mp, hashpos, ix, value_addr);
+ else
+ return 0;
}
+
void
PyDict_Clear(PyObject *op)
{
/* Internal version of dict.pop(). */
PyObject *
-_PyDict_Pop(PyObject *dict, PyObject *key, PyObject *deflt)
+_PyDict_Pop_KnownHash(PyObject *dict, PyObject *key, Py_hash_t hash, PyObject *deflt)
{
- Py_hash_t hash;
Py_ssize_t ix, hashpos;
PyObject *old_value, *old_key;
PyDictKeyEntry *ep;
_PyErr_SetKeyError(key);
return NULL;
}
- if (!PyUnicode_CheckExact(key) ||
- (hash = ((PyASCIIObject *) key)->hash) == -1) {
- hash = PyObject_Hash(key);
- if (hash == -1)
- return NULL;
- }
ix = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr, &hashpos);
if (ix == DKIX_ERROR)
return NULL;
return old_value;
}
+PyObject *
+_PyDict_Pop(PyObject *dict, PyObject *key, PyObject *deflt)
+{
+ Py_hash_t hash;
+
+ if (((PyDictObject *)dict)->ma_used == 0) {
+ if (deflt) {
+ Py_INCREF(deflt);
+ return deflt;
+ }
+ _PyErr_SetKeyError(key);
+ return NULL;
+ }
+ if (!PyUnicode_CheckExact(key) ||
+ (hash = ((PyASCIIObject *) key)->hash) == -1) {
+ hash = PyObject_Hash(key);
+ if (hash == -1)
+ return NULL;
+ }
+ return _PyDict_Pop_KnownHash(dict, key, hash, deflt);
+}
+
/* Internal version of dict.from_keys(). It is subclass-friendly. */
PyObject *
_PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value)
}
if (value == NULL) {
res = PyDict_DelItem(dict, key);
- if (cached != ((PyDictObject *)dict)->ma_keys) {
+ // Since key sharing dict doesn't allow deletion, PyDict_DelItem()
+ // always converts dict to combined form.
+ if ((cached = CACHED_KEYS(tp)) != NULL) {
CACHED_KEYS(tp) = NULL;
DK_DECREF(cached);
}
}
else {
- int was_shared = cached == ((PyDictObject *)dict)->ma_keys;
+ int was_shared = (cached == ((PyDictObject *)dict)->ma_keys);
res = PyDict_SetItem(dict, key, value);
- if (was_shared && cached != ((PyDictObject *)dict)->ma_keys) {
+ if (was_shared &&
+ (cached = CACHED_KEYS(tp)) != NULL &&
+ cached != ((PyDictObject *)dict)->ma_keys) {
/* PyDict_SetItem() may call dictresize and convert split table
* into combined table. In such case, convert it to split
* table again and update type's shared key only when this is
PyDoc_STRVAR(memory_doc,
-"memoryview($module, object)\n--\n\
+"memoryview(object)\n--\n\
\n\
Create a new memoryview object which references the given object.");
/* ----------------------------------------------
- MutableMappping implementations
+ MutableMapping implementations
Mapping:
}
int
-PySlice_GetIndicesEx(PyObject *_r, Py_ssize_t length,
- Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step,
- Py_ssize_t *slicelength)
+PySlice_Unpack(PyObject *_r,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
{
PySliceObject *r = (PySliceObject*)_r;
/* this is harder to get right than you might think */
- Py_ssize_t defstart, defstop;
-
if (r->step == Py_None) {
*step = 1;
}
*step = -PY_SSIZE_T_MAX;
}
- defstart = *step < 0 ? length-1 : 0;
- defstop = *step < 0 ? -1 : length;
-
if (r->start == Py_None) {
- *start = defstart;
+ *start = *step < 0 ? PY_SSIZE_T_MAX-1 : 0;;
}
else {
if (!_PyEval_SliceIndex(r->start, start)) return -1;
- if (*start < 0) *start += length;
- if (*start < 0) *start = (*step < 0) ? -1 : 0;
- if (*start >= length)
- *start = (*step < 0) ? length - 1 : length;
}
if (r->stop == Py_None) {
- *stop = defstop;
+ *stop = *step < 0 ? -PY_SSIZE_T_MAX : PY_SSIZE_T_MAX;
}
else {
if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
- if (*stop < 0) *stop += length;
- if (*stop < 0) *stop = (*step < 0) ? -1 : 0;
- if (*stop >= length)
- *stop = (*step < 0) ? length - 1 : length;
}
- if ((*step < 0 && *stop >= *start)
- || (*step > 0 && *start >= *stop)) {
- *slicelength = 0;
+ return 0;
+}
+
+Py_ssize_t
+PySlice_AdjustIndices(Py_ssize_t length,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t step)
+{
+ /* this is harder to get right than you might think */
+
+ assert(step != 0);
+ assert(step >= -PY_SSIZE_T_MAX);
+
+ if (*start < 0) {
+ *start += length;
+ if (*start < 0) {
+ *start = (step < 0) ? -1 : 0;
+ }
}
- else if (*step < 0) {
- *slicelength = (*stop-*start+1)/(*step)+1;
+ else if (*start >= length) {
+ *start = (step < 0) ? length - 1 : length;
+ }
+
+ if (*stop < 0) {
+ *stop += length;
+ if (*stop < 0) {
+ *stop = (step < 0) ? -1 : 0;
+ }
+ }
+ else if (*stop >= length) {
+ *stop = (step < 0) ? length - 1 : length;
+ }
+
+ if (step < 0) {
+ if (*stop < *start) {
+ return (*start - *stop - 1) / (-step) + 1;
+ }
}
else {
- *slicelength = (*stop-*start-1)/(*step)+1;
+ if (*start < *stop) {
+ return (*stop - *start - 1) / step + 1;
+ }
}
+ return 0;
+}
+
+#undef PySlice_GetIndicesEx
+int
+PySlice_GetIndicesEx(PyObject *_r, Py_ssize_t length,
+ Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step,
+ Py_ssize_t *slicelength)
+{
+ if (PySlice_Unpack(_r, start, stop, step) < 0)
+ return -1;
+ *slicelength = PySlice_AdjustIndices(length, start, stop, *step);
return 0;
}
return NULL;
}
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__ANDROID__)
/* Simplified UTF-8 decoder using surrogateescape error handler,
- used to decode the command line arguments on Mac OS X.
+ used to decode the command line arguments on Mac OS X and Android.
Return a pointer to a newly allocated wide character string (use
PyMem_RawFree() to free the memory), or NULL on memory allocation error. */
return unicode;
}
-#endif /* __APPLE__ */
+#endif /* __APPLE__ or __ANDROID__ */
/* Primary internal function which creates utf8 encoded bytes objects.
use_memcpy = 1;
#endif
for (i = 0; i < seqlen; i++) {
- const Py_ssize_t old_sz = sz;
+ size_t add_sz;
item = items[i];
if (!PyUnicode_Check(item)) {
PyErr_Format(PyExc_TypeError,
}
if (PyUnicode_READY(item) == -1)
goto onError;
- sz += PyUnicode_GET_LENGTH(item);
+ add_sz = PyUnicode_GET_LENGTH(item);
item_maxchar = PyUnicode_MAX_CHAR_VALUE(item);
maxchar = Py_MAX(maxchar, item_maxchar);
- if (i != 0)
- sz += seplen;
- if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
+ if (i != 0) {
+ add_sz += seplen;
+ }
+ if (add_sz > (size_t)(PY_SSIZE_T_MAX - sz)) {
PyErr_SetString(PyExc_OverflowError,
"join() result is too long for a Python string");
goto onError;
}
+ sz += add_sz;
if (use_memcpy && last_obj != NULL) {
if (PyUnicode_KIND(last_obj) != PyUnicode_KIND(item))
use_memcpy = 0;
u = unicode_empty;
goto done;
}
- if (new_size > (PY_SSIZE_T_MAX >> (rkind-1))) {
+ if (new_size > (PY_SSIZE_T_MAX / rkind)) {
PyErr_SetString(PyExc_OverflowError,
"replace string is too long");
goto error;
if (iobj == NULL) {
goto onError;
}
- v = iobj;
+ x = PyLong_AsLong(iobj);
Py_DECREF(iobj);
}
- /* Integer input truncated to a character */
- x = PyLong_AsLong(v);
+ else {
+ x = PyLong_AsLong(v);
+ }
if (x == -1 && PyErr_Occurred())
goto onError;
{
self->hash = -1;
self->wr_object = ob;
+ self->wr_prev = NULL;
+ self->wr_next = NULL;
Py_XINCREF(callback);
self->wr_callback = callback;
}
char *bitmap_bytes;
static const char *REGISTRY_SUFFIX_6432 =
-#ifdef MS_WIN64
+#ifdef _WIN64
"";
#else
"-32";
char *p = fgets(line, MAXPATHLEN + 1, sp_file);
if (!p)
break;
- if (*p == '\0' || *p == '#')
+ if (*p == '\0' || *p == '\r' || *p == '\n' || *p == '#')
continue;
while (*++p) {
if (*p == '\r' || *p == '\n') {
int err;
Py_BEGIN_ALLOW_THREADS
+ _Py_BEGIN_SUPPRESS_IPH
err = _locking(fd, mode, nbytes);
+ _Py_END_SUPPRESS_IPH
Py_END_ALLOW_THREADS
if (err != 0)
return PyErr_SetFromErrno(PyExc_IOError);
msvcrt_setmode_impl(PyObject *module, int fd, int flags)
/*[clinic end generated code: output=24a9be5ea07ccb9b input=76e7c01f6b137f75]*/
{
+ _Py_BEGIN_SUPPRESS_IPH
flags = _setmode(fd, flags);
+ _Py_END_SUPPRESS_IPH
if (flags == -1)
PyErr_SetFromErrno(PyExc_IOError);
{
int fd;
+ _Py_BEGIN_SUPPRESS_IPH
fd = _open_osfhandle(handle, flags);
+ _Py_END_SUPPRESS_IPH
if (fd == -1)
PyErr_SetFromErrno(PyExc_IOError);
msvcrt_putch_impl(PyObject *module, char char_value)
/*[clinic end generated code: output=92ec9b81012d8f60 input=ec078dd10cb054d6]*/
{
+ _Py_BEGIN_SUPPRESS_IPH
_putch(char_value);
+ _Py_END_SUPPRESS_IPH
Py_RETURN_NONE;
}
msvcrt_putwch_impl(PyObject *module, int unicode_char)
/*[clinic end generated code: output=a3bd1a8951d28eee input=996ccd0bbcbac4c3]*/
{
+ _Py_BEGIN_SUPPRESS_IPH
_putwch(unicode_char);
+ _Py_END_SUPPRESS_IPH
Py_RETURN_NONE;
}
msvcrt_ungetch_impl(PyObject *module, char char_value)
/*[clinic end generated code: output=c6942a0efa119000 input=22f07ee9001bbf0f]*/
{
- if (_ungetch(char_value) == EOF)
+ int res;
+
+ _Py_BEGIN_SUPPRESS_IPH
+ res = _ungetch(char_value);
+ _Py_END_SUPPRESS_IPH
+
+ if (res == EOF)
return PyErr_SetFromErrno(PyExc_IOError);
Py_RETURN_NONE;
}
msvcrt_ungetwch_impl(PyObject *module, int unicode_char)
/*[clinic end generated code: output=e63af05438b8ba3d input=83ec0492be04d564]*/
{
- if (_ungetwch(unicode_char) == WEOF)
+ int res;
+
+ _Py_BEGIN_SUPPRESS_IPH
+ res = _ungetwch(unicode_char);
+ _Py_END_SUPPRESS_IPH
+
+ if (res == WEOF)
return PyErr_SetFromErrno(PyExc_IOError);
Py_RETURN_NONE;
}
msvcrt_CrtSetReportFile_impl(PyObject *module, int type, int file)
/*[clinic end generated code: output=df291c7fe032eb68 input=bb8f721a604fcc45]*/
{
- return (long)_CrtSetReportFile(type, (_HFILE)file);
+ long res;
+
+ _Py_BEGIN_SUPPRESS_IPH
+ res = (long)_CrtSetReportFile(type, (_HFILE)file);
+ _Py_END_SUPPRESS_IPH
+
+ return res;
}
/*[clinic input]
{
int res;
+ _Py_BEGIN_SUPPRESS_IPH
res = _CrtSetReportMode(type, mode);
+ _Py_END_SUPPRESS_IPH
if (res == -1)
PyErr_SetFromErrno(PyExc_IOError);
return res;
msvcrt_set_error_mode_impl(PyObject *module, int mode)
/*[clinic end generated code: output=ac4a09040d8ac4e3 input=046fca59c0f20872]*/
{
- return _set_error_mode(mode);
+ long res;
+
+ _Py_BEGIN_SUPPRESS_IPH
+ res = _set_error_mode(mode);
+ _Py_END_SUPPRESS_IPH
+
+ return res;
}
#endif /* _DEBUG */
{
unsigned int res;
+ _Py_BEGIN_SUPPRESS_IPH
res = SetErrorMode(mode);
+ _Py_END_SUPPRESS_IPH
+
return PyLong_FromUnsignedLong(res);
}
PyCodec_IncrementalEncoder=python36.PyCodec_IncrementalEncoder
PyCodec_KnownEncoding=python36.PyCodec_KnownEncoding
PyCodec_LookupError=python36.PyCodec_LookupError
+ PyCodec_NameReplaceErrors=python36.PyCodec_NameReplaceErrors
PyCodec_Register=python36.PyCodec_Register
PyCodec_RegisterError=python36.PyCodec_RegisterError
PyCodec_ReplaceErrors=python36.PyCodec_ReplaceErrors
PyErr_Fetch=python36.PyErr_Fetch
PyErr_Format=python36.PyErr_Format
PyErr_FormatV=python36.PyErr_FormatV
+ PyErr_GetExcInfo=python36.PyErr_GetExcInfo
PyErr_GivenExceptionMatches=python36.PyErr_GivenExceptionMatches
PyErr_NewException=python36.PyErr_NewException
PyErr_NewExceptionWithDoc=python36.PyErr_NewExceptionWithDoc
PyErr_Print=python36.PyErr_Print
PyErr_PrintEx=python36.PyErr_PrintEx
PyErr_ProgramText=python36.PyErr_ProgramText
+ PyErr_ResourceWarning=python36.PyErr_ResourceWarning
PyErr_Restore=python36.PyErr_Restore
+ PyErr_SetExcFromWindowsErr=python36.PyErr_SetExcFromWindowsErr
+ PyErr_SetExcFromWindowsErrWithFilename=python36.PyErr_SetExcFromWindowsErrWithFilename
+ PyErr_SetExcFromWindowsErrWithFilenameObject=python36.PyErr_SetExcFromWindowsErrWithFilenameObject
+ PyErr_SetExcFromWindowsErrWithFilenameObjects=python36.PyErr_SetExcFromWindowsErrWithFilenameObjects
+ PyErr_SetExcInfo=python36.PyErr_SetExcInfo
PyErr_SetFromErrno=python36.PyErr_SetFromErrno
PyErr_SetFromErrnoWithFilename=python36.PyErr_SetFromErrnoWithFilename
PyErr_SetFromErrnoWithFilenameObject=python36.PyErr_SetFromErrnoWithFilenameObject
+ PyErr_SetFromErrnoWithFilenameObjects=python36.PyErr_SetFromErrnoWithFilenameObjects
+ PyErr_SetFromWindowsErr=python36.PyErr_SetFromWindowsErr
+ PyErr_SetFromWindowsErrWithFilename=python36.PyErr_SetFromWindowsErrWithFilename
+ PyErr_SetImportError=python36.PyErr_SetImportError
+ PyErr_SetImportErrorSubclass=python36.PyErr_SetImportErrorSubclass
PyErr_SetInterrupt=python36.PyErr_SetInterrupt
PyErr_SetNone=python36.PyErr_SetNone
PyErr_SetObject=python36.PyErr_SetObject
PyErr_SetString=python36.PyErr_SetString
PyErr_SyntaxLocation=python36.PyErr_SyntaxLocation
+ PyErr_SyntaxLocationEx=python36.PyErr_SyntaxLocationEx
PyErr_WarnEx=python36.PyErr_WarnEx
PyErr_WarnExplicit=python36.PyErr_WarnExplicit
PyErr_WarnFormat=python36.PyErr_WarnFormat
PyExc_AssertionError=python36.PyExc_AssertionError DATA
PyExc_AttributeError=python36.PyExc_AttributeError DATA
PyExc_BaseException=python36.PyExc_BaseException DATA
+ PyExc_BlockingIOError=python36.PyExc_BlockingIOError DATA
+ PyExc_BrokenPipeError=python36.PyExc_BrokenPipeError DATA
PyExc_BufferError=python36.PyExc_BufferError DATA
PyExc_BytesWarning=python36.PyExc_BytesWarning DATA
+ PyExc_ChildProcessError=python36.PyExc_ChildProcessError DATA
+ PyExc_ConnectionAbortedError=python36.PyExc_ConnectionAbortedError DATA
+ PyExc_ConnectionError=python36.PyExc_ConnectionError DATA
+ PyExc_ConnectionRefusedError=python36.PyExc_ConnectionRefusedError DATA
+ PyExc_ConnectionResetError=python36.PyExc_ConnectionResetError DATA
PyExc_DeprecationWarning=python36.PyExc_DeprecationWarning DATA
PyExc_EOFError=python36.PyExc_EOFError DATA
PyExc_EnvironmentError=python36.PyExc_EnvironmentError DATA
PyExc_Exception=python36.PyExc_Exception DATA
+ PyExc_FileExistsError=python36.PyExc_FileExistsError DATA
+ PyExc_FileNotFoundError=python36.PyExc_FileNotFoundError DATA
PyExc_FloatingPointError=python36.PyExc_FloatingPointError DATA
PyExc_FutureWarning=python36.PyExc_FutureWarning DATA
PyExc_GeneratorExit=python36.PyExc_GeneratorExit DATA
PyExc_ImportWarning=python36.PyExc_ImportWarning DATA
PyExc_IndentationError=python36.PyExc_IndentationError DATA
PyExc_IndexError=python36.PyExc_IndexError DATA
+ PyExc_InterruptedError=python36.PyExc_InterruptedError DATA
+ PyExc_IsADirectoryError=python36.PyExc_IsADirectoryError DATA
PyExc_KeyError=python36.PyExc_KeyError DATA
PyExc_KeyboardInterrupt=python36.PyExc_KeyboardInterrupt DATA
PyExc_LookupError=python36.PyExc_LookupError DATA
PyExc_MemoryError=python36.PyExc_MemoryError DATA
- PyExc_MemoryErrorInst=python36.PyExc_MemoryErrorInst DATA
+ PyExc_ModuleNotFoundError=python36.PyExc_ModuleNotFoundError DATA
PyExc_NameError=python36.PyExc_NameError DATA
+ PyExc_NotADirectoryError=python36.PyExc_NotADirectoryError DATA
PyExc_NotImplementedError=python36.PyExc_NotImplementedError DATA
PyExc_OSError=python36.PyExc_OSError DATA
PyExc_OverflowError=python36.PyExc_OverflowError DATA
PyExc_PendingDeprecationWarning=python36.PyExc_PendingDeprecationWarning DATA
+ PyExc_PermissionError=python36.PyExc_PermissionError DATA
+ PyExc_ProcessLookupError=python36.PyExc_ProcessLookupError DATA
+ PyExc_RecursionError=python36.PyExc_RecursionError DATA
PyExc_RecursionErrorInst=python36.PyExc_RecursionErrorInst DATA
PyExc_ReferenceError=python36.PyExc_ReferenceError DATA
+ PyExc_ResourceWarning=python36.PyExc_ResourceWarning DATA
PyExc_RuntimeError=python36.PyExc_RuntimeError DATA
PyExc_RuntimeWarning=python36.PyExc_RuntimeWarning DATA
+ PyExc_StopAsyncIteration=python36.PyExc_StopAsyncIteration DATA
PyExc_StopIteration=python36.PyExc_StopIteration DATA
PyExc_SyntaxError=python36.PyExc_SyntaxError DATA
PyExc_SyntaxWarning=python36.PyExc_SyntaxWarning DATA
PyExc_SystemError=python36.PyExc_SystemError DATA
PyExc_SystemExit=python36.PyExc_SystemExit DATA
PyExc_TabError=python36.PyExc_TabError DATA
+ PyExc_TimeoutError=python36.PyExc_TimeoutError DATA
PyExc_TypeError=python36.PyExc_TypeError DATA
PyExc_UnboundLocalError=python36.PyExc_UnboundLocalError DATA
PyExc_UnicodeDecodeError=python36.PyExc_UnicodeDecodeError DATA
PyExc_UserWarning=python36.PyExc_UserWarning DATA
PyExc_ValueError=python36.PyExc_ValueError DATA
PyExc_Warning=python36.PyExc_Warning DATA
+ PyExc_WindowsError=python36.PyExc_WindowsError DATA
PyExc_ZeroDivisionError=python36.PyExc_ZeroDivisionError DATA
PyException_GetCause=python36.PyException_GetCause
PyException_GetContext=python36.PyException_GetContext
PyGILState_Release=python36.PyGILState_Release
PyGetSetDescr_Type=python36.PyGetSetDescr_Type DATA
PyImport_AddModule=python36.PyImport_AddModule
+ PyImport_AddModuleObject=python36.PyImport_AddModuleObject
PyImport_AppendInittab=python36.PyImport_AppendInittab
PyImport_Cleanup=python36.PyImport_Cleanup
PyImport_ExecCodeModule=python36.PyImport_ExecCodeModule
PyImport_ExecCodeModuleEx=python36.PyImport_ExecCodeModuleEx
+ PyImport_ExecCodeModuleObject=python36.PyImport_ExecCodeModuleObject
PyImport_ExecCodeModuleWithPathnames=python36.PyImport_ExecCodeModuleWithPathnames
PyImport_GetImporter=python36.PyImport_GetImporter
PyImport_GetMagicNumber=python36.PyImport_GetMagicNumber
PyImport_GetModuleDict=python36.PyImport_GetModuleDict
PyImport_Import=python36.PyImport_Import
PyImport_ImportFrozenModule=python36.PyImport_ImportFrozenModule
+ PyImport_ImportFrozenModuleObject=python36.PyImport_ImportFrozenModuleObject
PyImport_ImportModule=python36.PyImport_ImportModule
PyImport_ImportModuleLevel=python36.PyImport_ImportModuleLevel
+ PyImport_ImportModuleLevelObject=python36.PyImport_ImportModuleLevelObject
PyImport_ImportModuleNoBlock=python36.PyImport_ImportModuleNoBlock
PyImport_ReloadModule=python36.PyImport_ReloadModule
PyInterpreterState_Clear=python36.PyInterpreterState_Clear
PyMapping_SetItemString=python36.PyMapping_SetItemString
PyMapping_Size=python36.PyMapping_Size
PyMapping_Values=python36.PyMapping_Values
+ PyMem_Calloc=python36.PyMem_Calloc
PyMem_Free=python36.PyMem_Free
PyMem_Malloc=python36.PyMem_Malloc
PyMem_Realloc=python36.PyMem_Realloc
PyMemberDescr_Type=python36.PyMemberDescr_Type DATA
+ PyMemoryView_FromMemory=python36.PyMemoryView_FromMemory
PyMemoryView_FromObject=python36.PyMemoryView_FromObject
PyMemoryView_GetContiguous=python36.PyMemoryView_GetContiguous
PyMemoryView_Type=python36.PyMemoryView_Type DATA
PyMethodDescr_Type=python36.PyMethodDescr_Type DATA
+ PyModuleDef_Init=python36.PyModuleDef_Init
+ PyModuleDef_Type=python36.PyModuleDef_Type DATA
+ PyModule_AddFunctions=python36.PyModule_AddFunctions
PyModule_AddIntConstant=python36.PyModule_AddIntConstant
PyModule_AddObject=python36.PyModule_AddObject
PyModule_AddStringConstant=python36.PyModule_AddStringConstant
PyModule_Create2=python36.PyModule_Create2
+ PyModule_ExecDef=python36.PyModule_ExecDef
+ PyModule_FromDefAndSpec2=python36.PyModule_FromDefAndSpec2
PyModule_GetDef=python36.PyModule_GetDef
PyModule_GetDict=python36.PyModule_GetDict
PyModule_GetFilename=python36.PyModule_GetFilename
PyModule_GetFilenameObject=python36.PyModule_GetFilenameObject
PyModule_GetName=python36.PyModule_GetName
+ PyModule_GetNameObject=python36.PyModule_GetNameObject
PyModule_GetState=python36.PyModule_GetState
PyModule_New=python36.PyModule_New
+ PyModule_NewObject=python36.PyModule_NewObject
+ PyModule_SetDocString=python36.PyModule_SetDocString
PyModule_Type=python36.PyModule_Type DATA
- PyModuleDef_Init=python36.PyModuleDef_Init
- PyModuleDef_Type=python36.PyModuleDef_Type DATA
PyNullImporter_Type=python36.PyNullImporter_Type DATA
PyNumber_Absolute=python36.PyNumber_Absolute
PyNumber_Add=python36.PyNumber_Add
PyNumber_InPlaceAnd=python36.PyNumber_InPlaceAnd
PyNumber_InPlaceFloorDivide=python36.PyNumber_InPlaceFloorDivide
PyNumber_InPlaceLshift=python36.PyNumber_InPlaceLshift
+ PyNumber_InPlaceMatrixMultiply=python36.PyNumber_InPlaceMatrixMultiply
PyNumber_InPlaceMultiply=python36.PyNumber_InPlaceMultiply
PyNumber_InPlaceOr=python36.PyNumber_InPlaceOr
PyNumber_InPlacePower=python36.PyNumber_InPlacePower
PyNumber_Invert=python36.PyNumber_Invert
PyNumber_Long=python36.PyNumber_Long
PyNumber_Lshift=python36.PyNumber_Lshift
+ PyNumber_MatrixMultiply=python36.PyNumber_MatrixMultiply
PyNumber_Multiply=python36.PyNumber_Multiply
PyNumber_Negative=python36.PyNumber_Negative
PyNumber_Or=python36.PyNumber_Or
PyNumber_ToBase=python36.PyNumber_ToBase
PyNumber_TrueDivide=python36.PyNumber_TrueDivide
PyNumber_Xor=python36.PyNumber_Xor
+ PyODictItems_Type=python36.PyODictItems_Type DATA
+ PyODictIter_Type=python36.PyODictIter_Type DATA
+ PyODictKeys_Type=python36.PyODictKeys_Type DATA
+ PyODictValues_Type=python36.PyODictValues_Type DATA
+ PyODict_DelItem=python36.PyODict_DelItem
+ PyODict_New=python36.PyODict_New
+ PyODict_SetItem=python36.PyODict_SetItem
+ PyODict_Type=python36.PyODict_Type DATA
PyOS_AfterFork=python36.PyOS_AfterFork
+ PyOS_CheckStack=python36.PyOS_CheckStack
+ PyOS_FSPath=python36.PyOS_FSPath
PyOS_InitInterrupts=python36.PyOS_InitInterrupts
PyOS_InputHook=python36.PyOS_InputHook DATA
PyOS_InterruptOccurred=python36.PyOS_InterruptOccurred
PyObject_CallMethod=python36.PyObject_CallMethod
PyObject_CallMethodObjArgs=python36.PyObject_CallMethodObjArgs
PyObject_CallObject=python36.PyObject_CallObject
+ PyObject_Calloc=python36.PyObject_Calloc
PyObject_CheckReadBuffer=python36.PyObject_CheckReadBuffer
PyObject_ClearWeakRefs=python36.PyObject_ClearWeakRefs
PyObject_DelItem=python36.PyObject_DelItem
PyObject_GC_UnTrack=python36.PyObject_GC_UnTrack
PyObject_GenericGetAttr=python36.PyObject_GenericGetAttr
PyObject_GenericSetAttr=python36.PyObject_GenericSetAttr
+ PyObject_GenericSetDict=python36.PyObject_GenericSetDict
PyObject_GetAttr=python36.PyObject_GetAttr
PyObject_GetAttrString=python36.PyObject_GetAttrString
PyObject_GetItem=python36.PyObject_GetItem
PyObject_SetItem=python36.PyObject_SetItem
PyObject_Size=python36.PyObject_Size
PyObject_Str=python36.PyObject_Str
- PyObject_Type=python36.PyObject_Type DATA
- PyODict_DelItem=python36.PyODict_DelItem
- PyODict_New=python36.PyODict_New
- PyODict_SetItem=python36.PyODict_SetItem
- PyODict_Type=python36.PyODict_Type DATA
- PyODictItems_Type=python36.PyODictItems_Type DATA
- PyODictIter_Type=python36.PyODictIter_Type DATA
- PyODictKeys_Type=python36.PyODictKeys_Type DATA
- PyODictValues_Type=python36.PyODictValues_Type DATA
+ PyObject_Type=python36.PyObject_Type
PyParser_SimpleParseFileFlags=python36.PyParser_SimpleParseFileFlags
PyParser_SimpleParseStringFlags=python36.PyParser_SimpleParseStringFlags
+ PyParser_SimpleParseStringFlagsFilename=python36.PyParser_SimpleParseStringFlagsFilename
PyProperty_Type=python36.PyProperty_Type DATA
PyRangeIter_Type=python36.PyRangeIter_Type DATA
PyRange_Type=python36.PyRange_Type DATA
PySet_Pop=python36.PySet_Pop
PySet_Size=python36.PySet_Size
PySet_Type=python36.PySet_Type DATA
+ PySlice_AdjustIndices=python36.PySlice_AdjustIndices
PySlice_GetIndices=python36.PySlice_GetIndices
PySlice_GetIndicesEx=python36.PySlice_GetIndicesEx
PySlice_New=python36.PySlice_New
PySlice_Type=python36.PySlice_Type DATA
+ PySlice_Unpack=python36.PySlice_Unpack
PySortWrapper_Type=python36.PySortWrapper_Type DATA
- PyState_FindModule=python36.PyState_FindModule
PyState_AddModule=python36.PyState_AddModule
+ PyState_FindModule=python36.PyState_FindModule
PyState_RemoveModule=python36.PyState_RemoveModule
PyStructSequence_GetItem=python36.PyStructSequence_GetItem
PyStructSequence_New=python36.PyStructSequence_New
PySuper_Type=python36.PySuper_Type DATA
PySys_AddWarnOption=python36.PySys_AddWarnOption
PySys_AddWarnOptionUnicode=python36.PySys_AddWarnOptionUnicode
+ PySys_AddXOption=python36.PySys_AddXOption
PySys_FormatStderr=python36.PySys_FormatStderr
PySys_FormatStdout=python36.PySys_FormatStdout
PySys_GetObject=python36.PySys_GetObject
+ PySys_GetXOptions=python36.PySys_GetXOptions
PySys_HasWarnOptions=python36.PySys_HasWarnOptions
PySys_ResetWarnOptions=python36.PySys_ResetWarnOptions
PySys_SetArgv=python36.PySys_SetArgv
PyUnicode_AsEncodedString=python36.PyUnicode_AsEncodedString
PyUnicode_AsEncodedUnicode=python36.PyUnicode_AsEncodedUnicode
PyUnicode_AsLatin1String=python36.PyUnicode_AsLatin1String
+ PyUnicode_AsMBCSString=python36.PyUnicode_AsMBCSString
PyUnicode_AsRawUnicodeEscapeString=python36.PyUnicode_AsRawUnicodeEscapeString
+ PyUnicode_AsUCS4=python36.PyUnicode_AsUCS4
+ PyUnicode_AsUCS4Copy=python36.PyUnicode_AsUCS4Copy
PyUnicode_AsUTF16String=python36.PyUnicode_AsUTF16String
PyUnicode_AsUTF32String=python36.PyUnicode_AsUTF32String
PyUnicode_AsUTF8String=python36.PyUnicode_AsUTF8String
PyUnicode_AsUnicodeEscapeString=python36.PyUnicode_AsUnicodeEscapeString
PyUnicode_AsWideChar=python36.PyUnicode_AsWideChar
- PyUnicode_ClearFreelist=python36.PyUnicode_ClearFreelist
+ PyUnicode_AsWideCharString=python36.PyUnicode_AsWideCharString
+ PyUnicode_BuildEncodingMap=python36.PyUnicode_BuildEncodingMap
+ PyUnicode_ClearFreeList=python36.PyUnicode_ClearFreeList
PyUnicode_Compare=python36.PyUnicode_Compare
+ PyUnicode_CompareWithASCIIString=python36.PyUnicode_CompareWithASCIIString
PyUnicode_Concat=python36.PyUnicode_Concat
PyUnicode_Contains=python36.PyUnicode_Contains
PyUnicode_Count=python36.PyUnicode_Count
PyUnicode_Decode=python36.PyUnicode_Decode
PyUnicode_DecodeASCII=python36.PyUnicode_DecodeASCII
PyUnicode_DecodeCharmap=python36.PyUnicode_DecodeCharmap
+ PyUnicode_DecodeCodePageStateful=python36.PyUnicode_DecodeCodePageStateful
PyUnicode_DecodeFSDefault=python36.PyUnicode_DecodeFSDefault
PyUnicode_DecodeFSDefaultAndSize=python36.PyUnicode_DecodeFSDefaultAndSize
PyUnicode_DecodeLatin1=python36.PyUnicode_DecodeLatin1
+ PyUnicode_DecodeLocale=python36.PyUnicode_DecodeLocale
+ PyUnicode_DecodeLocaleAndSize=python36.PyUnicode_DecodeLocaleAndSize
+ PyUnicode_DecodeMBCS=python36.PyUnicode_DecodeMBCS
+ PyUnicode_DecodeMBCSStateful=python36.PyUnicode_DecodeMBCSStateful
PyUnicode_DecodeRawUnicodeEscape=python36.PyUnicode_DecodeRawUnicodeEscape
PyUnicode_DecodeUTF16=python36.PyUnicode_DecodeUTF16
PyUnicode_DecodeUTF16Stateful=python36.PyUnicode_DecodeUTF16Stateful
PyUnicode_DecodeUTF32=python36.PyUnicode_DecodeUTF32
PyUnicode_DecodeUTF32Stateful=python36.PyUnicode_DecodeUTF32Stateful
+ PyUnicode_DecodeUTF7=python36.PyUnicode_DecodeUTF7
+ PyUnicode_DecodeUTF7Stateful=python36.PyUnicode_DecodeUTF7Stateful
PyUnicode_DecodeUTF8=python36.PyUnicode_DecodeUTF8
PyUnicode_DecodeUTF8Stateful=python36.PyUnicode_DecodeUTF8Stateful
PyUnicode_DecodeUnicodeEscape=python36.PyUnicode_DecodeUnicodeEscape
+ PyUnicode_EncodeCodePage=python36.PyUnicode_EncodeCodePage
+ PyUnicode_EncodeFSDefault=python36.PyUnicode_EncodeFSDefault
+ PyUnicode_EncodeLocale=python36.PyUnicode_EncodeLocale
PyUnicode_FSConverter=python36.PyUnicode_FSConverter
PyUnicode_FSDecoder=python36.PyUnicode_FSDecoder
PyUnicode_Find=python36.PyUnicode_Find
+ PyUnicode_FindChar=python36.PyUnicode_FindChar
PyUnicode_Format=python36.PyUnicode_Format
PyUnicode_FromEncodedObject=python36.PyUnicode_FromEncodedObject
PyUnicode_FromFormat=python36.PyUnicode_FromFormat
PyUnicode_FromStringAndSize=python36.PyUnicode_FromStringAndSize
PyUnicode_FromWideChar=python36.PyUnicode_FromWideChar
PyUnicode_GetDefaultEncoding=python36.PyUnicode_GetDefaultEncoding
+ PyUnicode_GetLength=python36.PyUnicode_GetLength
PyUnicode_GetSize=python36.PyUnicode_GetSize
+ PyUnicode_InternFromString=python36.PyUnicode_InternFromString
+ PyUnicode_InternImmortal=python36.PyUnicode_InternImmortal
+ PyUnicode_InternInPlace=python36.PyUnicode_InternInPlace
PyUnicode_IsIdentifier=python36.PyUnicode_IsIdentifier
PyUnicode_Join=python36.PyUnicode_Join
PyUnicode_Partition=python36.PyUnicode_Partition
PyUnicode_RPartition=python36.PyUnicode_RPartition
PyUnicode_RSplit=python36.PyUnicode_RSplit
+ PyUnicode_ReadChar=python36.PyUnicode_ReadChar
PyUnicode_Replace=python36.PyUnicode_Replace
PyUnicode_Resize=python36.PyUnicode_Resize
PyUnicode_RichCompare=python36.PyUnicode_RichCompare
- PyUnicode_SetDefaultEncoding=python36.PyUnicode_SetDefaultEncoding
PyUnicode_Split=python36.PyUnicode_Split
PyUnicode_Splitlines=python36.PyUnicode_Splitlines
+ PyUnicode_Substring=python36.PyUnicode_Substring
PyUnicode_Tailmatch=python36.PyUnicode_Tailmatch
PyUnicode_Translate=python36.PyUnicode_Translate
- PyUnicode_BuildEncodingMap=python36.PyUnicode_BuildEncodingMap
- PyUnicode_CompareWithASCIIString=python36.PyUnicode_CompareWithASCIIString
- PyUnicode_DecodeUTF7=python36.PyUnicode_DecodeUTF7
- PyUnicode_DecodeUTF7Stateful=python36.PyUnicode_DecodeUTF7Stateful
- PyUnicode_EncodeFSDefault=python36.PyUnicode_EncodeFSDefault
- PyUnicode_InternFromString=python36.PyUnicode_InternFromString
- PyUnicode_InternImmortal=python36.PyUnicode_InternImmortal
- PyUnicode_InternInPlace=python36.PyUnicode_InternInPlace
PyUnicode_Type=python36.PyUnicode_Type DATA
- PyWeakref_GetObject=python36.PyWeakref_GetObject DATA
+ PyUnicode_WriteChar=python36.PyUnicode_WriteChar
+ PyWeakref_GetObject=python36.PyWeakref_GetObject
PyWeakref_NewProxy=python36.PyWeakref_NewProxy
PyWeakref_NewRef=python36.PyWeakref_NewRef
PyWrapperDescr_Type=python36.PyWrapperDescr_Type DATA
Py_BuildValue=python36.Py_BuildValue
Py_CompileString=python36.Py_CompileString
Py_DecRef=python36.Py_DecRef
+ Py_DecodeLocale=python36.Py_DecodeLocale
+ Py_EncodeLocale=python36.Py_EncodeLocale
Py_EndInterpreter=python36.Py_EndInterpreter
Py_Exit=python36.Py_Exit
Py_FatalError=python36.Py_FatalError
+ Py_FileSystemDefaultEncodeErrors=python36.Py_FileSystemDefaultEncodeErrors DATA
Py_FileSystemDefaultEncoding=python36.Py_FileSystemDefaultEncoding DATA
Py_Finalize=python36.Py_Finalize
Py_FinalizeEx=python36.Py_FinalizeEx
Py_NewInterpreter=python36.Py_NewInterpreter
Py_ReprEnter=python36.Py_ReprEnter
Py_ReprLeave=python36.Py_ReprLeave
+ Py_SetPath=python36.Py_SetPath
Py_SetProgramName=python36.Py_SetProgramName
Py_SetPythonHome=python36.Py_SetPythonHome
Py_SetRecursionLimit=python36.Py_SetRecursionLimit
Py_SymtableString=python36.Py_SymtableString
Py_VaBuildValue=python36.Py_VaBuildValue
+ _PyArg_ParseTupleAndKeywords_SizeT=python36._PyArg_ParseTupleAndKeywords_SizeT
+ _PyArg_ParseTuple_SizeT=python36._PyArg_ParseTuple_SizeT
+ _PyArg_Parse_SizeT=python36._PyArg_Parse_SizeT
+ _PyArg_VaParseTupleAndKeywords_SizeT=python36._PyArg_VaParseTupleAndKeywords_SizeT
+ _PyArg_VaParse_SizeT=python36._PyArg_VaParse_SizeT
_PyErr_BadInternalCall=python36._PyErr_BadInternalCall
_PyObject_CallFunction_SizeT=python36._PyObject_CallFunction_SizeT
_PyObject_CallMethod_SizeT=python36._PyObject_CallMethod_SizeT
_PyTrash_delete_nesting=python36._PyTrash_delete_nesting DATA
_PyTrash_deposit_object=python36._PyTrash_deposit_object
_PyTrash_destroy_chain=python36._PyTrash_destroy_chain
+ _PyTrash_thread_deposit_object=python36._PyTrash_thread_deposit_object
+ _PyTrash_thread_destroy_chain=python36._PyTrash_thread_destroy_chain
_PyWeakref_CallableProxyType=python36._PyWeakref_CallableProxyType DATA
_PyWeakref_ProxyType=python36._PyWeakref_ProxyType DATA
_PyWeakref_RefType=python36._PyWeakref_RefType DATA
_Py_SwappedOp=python36._Py_SwappedOp DATA
_Py_TrueStruct=python36._Py_TrueStruct DATA
_Py_VaBuildValue_SizeT=python36._Py_VaBuildValue_SizeT
- _PyArg_Parse_SizeT=python36._PyArg_Parse_SizeT
- _PyArg_ParseTuple_SizeT=python36._PyArg_ParseTuple_SizeT
- _PyArg_ParseTupleAndKeywords_SizeT=python36._PyArg_ParseTupleAndKeywords_SizeT
- _PyArg_VaParse_SizeT=python36._PyArg_VaParse_SizeT
- _PyArg_VaParseTupleAndKeywords_SizeT=python36._PyArg_VaParseTupleAndKeywords_SizeT
- _Py_BuildValue_SizeT=python36._Py_BuildValue_SizeT
case REG_SZ:
case REG_EXPAND_SZ:
{
- /* the buffer may or may not have a trailing NULL */
+ /* REG_SZ should be a NUL terminated string, but only by
+ * convention. The buffer may have been saved without a NUL
+ * or with embedded NULs. To be consistent with reg.exe and
+ * regedit.exe, consume only up to the first NUL. */
wchar_t *data = (wchar_t *)retDataBuf;
- int len = retDataSize / 2;
- if (retDataSize && data[len-1] == '\0')
- retDataSize -= 2;
- if (retDataSize <= 0)
- data = L"";
- obData = PyUnicode_FromWideChar(data, retDataSize/2);
+ size_t len = wcsnlen(data, retDataSize / sizeof(wchar_t));
+ obData = PyUnicode_FromWideChar(data, len);
break;
}
case REG_MULTI_SZ:
</ProjectReference>
</ItemGroup>
<ItemGroup>
- <None Include="..\Lib\importlib\_bootstrap.py" />
+ <None Include="..\Lib\importlib\_bootstrap.py">
+ <IntFile>$(IntDir)importlib.g.h</IntFile>
+ <OutFile>$(PySourcePath)Python\importlib.h</OutFile>
+ </None>
+ <None Include="..\Lib\importlib\_bootstrap_external.py">
+ <IntFile>$(IntDir)importlib_external.g.h</IntFile>
+ <OutFile>$(PySourcePath)Python\importlib_external.h</OutFile>
+ </None>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
- <Target Name="RebuildImportLib" AfterTargets="AfterBuild" Condition="$(Configuration) == 'Debug' or $(Configuration) == 'Release'">
- <Exec Command='"$(TargetPath)" "$(PySourcePath)Lib\importlib\_bootstrap.py" "$(IntDir)importlib.g.h"' />
+ <Target Name="_RebuildImportLib">
+ <Exec Command='"$(TargetPath)" "%(None.FullPath)" "%(None.IntFile)"' />
<PropertyGroup>
- <_OldContent Condition="Exists('$(PySourcePath)Python\importlib.h')">$([System.IO.File]::ReadAllText('$(PySourcePath)Python\importlib.h').Replace(`
`, `
`))</_OldContent>
- <_NewContent Condition="Exists('$(IntDir)importlib.g.h')">$([System.IO.File]::ReadAllText('$(IntDir)importlib.g.h').Replace(`
`, `
`))</_NewContent>
+ <_OldContent Condition="Exists($(OutTargetPath))"></_OldContent>
+ <_NewContent Condition="Exists($(IntTargetPath))">$([System.IO.File]::ReadAllText($(IntTargetPath)).Replace(`
`, `
`))</_NewContent>
</PropertyGroup>
- <Copy SourceFiles="$(IntDir)importlib.g.h"
- DestinationFiles="$(PySourcePath)Python\importlib.h"
- Condition="Exists('$(IntDir)importlib.g.h') and '$(_OldContent)' != '$(_NewContent)'" />
+ <Copy SourceFiles="%(None.IntFile)"
+ DestinationFiles="%(None.OutFile)"
+ Condition="!Exists(%(None.OutFile)) or (Exists(%(None.IntFile)) and '$([System.IO.File]::ReadAllText(%(None.OutFile)).Replace(`
`, `
`))' != '$([System.IO.File]::ReadAllText(%(None.IntFile)).Replace(`
`, `
`))')">
+ <Output TaskParameter="CopiedFiles" ItemName="_Updated" />
+ </Copy>
- <Warning Text="importlib.h has been updated. You will need to rebuild pythoncore to see the changes."
- Condition="Exists('$(IntDir)importlib.g.h') and '$(_OldContent)' != '$(_NewContent)' and $(Configuration) == 'Debug'" />
- <Error Text="importlib.h has been updated. You will need to rebuild pythoncore to see the changes."
- Condition="Exists('$(IntDir)importlib.g.h') and '$(_OldContent)' != '$(_NewContent)' and $(Configuration) == 'Release'" />
+ <Warning Text="@(_Updated->'%(Filename)%(Extension)',', ') updated. You will need to rebuild pythoncore to see the changes."
+ Condition="'@(_Updated)' != '' and $(Configuration) == 'Debug'" />
+ <Error Text="@(_Updated->'%(Filename)%(Extension)',', ') updated. You will need to rebuild pythoncore to see the changes."
+ Condition="'@(_Updated)' != '' and $(Configuration) == 'Release'" />
+ </Target>
+ <Target Name="RebuildImportLib" AfterTargets="AfterBuild" Condition="$(Configuration) == 'Debug' or $(Configuration) == 'Release'"
+ DependsOnTargets="_RebuildImportLib">
</Target>
<Target Name="_CleanImportLib" BeforeTargets="CoreClean">
<ItemGroup>
<Clean Include="$(IntDir)importlib.g.h" />
+ <Clean Include="$(IntDir)importlib_external.g.h" />
</ItemGroup>
</Target>
</Project>
)\r
)\r
\r
-if not exist "%HG%" where hg > "%TEMP%\hg.loc" 2> nul && set /P HG= < "%TEMP%\hg.loc" & del "%TEMP%\hg.loc"\r
-if not exist "%HG%" echo Cannot find Mercurial on PATH && exit /B 1\r
+if not exist "%GIT%" where git > "%TEMP%\git.loc" 2> nul && set /P GIT= < "%TEMP%\git.loc" & del "%TEMP%\git.loc"\r
+if exist "%GIT%" set GITProperty=/p:GIT="%GIT%"\r
+if not exist "%GIT%" echo Cannot find Git on PATH & set GITProperty=\r
\r
rem Setup the environment\r
call "%dir%env.bat" %vs_platf% >nul\r
/p:Configuration=%conf% /p:Platform=%platf%^\r
/p:IncludeExternals=%IncludeExternals%^\r
/p:IncludeSSL=%IncludeSSL% /p:IncludeTkinter=%IncludeTkinter%^\r
- /p:UseTestMarker=%UseTestMarker%^\r
- /p:HG="%HG%"^\r
+ /p:UseTestMarker=%UseTestMarker% %GITProperty%^\r
%1 %2 %3 %4 %5 %6 %7 %8 %9\r
\r
@echo off\r
set libraries=\r
set libraries=%libraries% bzip2-1.0.6\r
if NOT "%IncludeSSL%"=="false" set libraries=%libraries% nasm-2.11.06\r
-if NOT "%IncludeSSL%"=="false" set libraries=%libraries% openssl-1.0.2j\r
+if NOT "%IncludeSSL%"=="false" set libraries=%libraries% openssl-1.0.2k\r
set libraries=%libraries% sqlite-3.14.2.0\r
if NOT "%IncludeTkinter%"=="false" set libraries=%libraries% tcl-core-8.6.6.0\r
if NOT "%IncludeTkinter%"=="false" set libraries=%libraries% tk-8.6.6.0\r
<BuildTarget>Build</BuildTarget>
<CleanTarget>Clean</CleanTarget>
<CleanAllTarget>CleanAll</CleanAllTarget>
- <BuildInParallel>true</BuildInParallel>
+ <BuildInParallel>false</BuildInParallel>
</Projects2>
</ItemDefinitionGroup>
<ItemGroup>
<Projects Include="pylauncher.vcxproj;pywlauncher.vcxproj" />
<!-- pyshellext.dll -->
<Projects Include="pyshellext.vcxproj" />
- <!-- _freeze_importlib -->
- <Projects Include="_freeze_importlib.vcxproj" />
<!-- Extension modules -->
<ExtensionModules Include="_asyncio;_ctypes;_decimal;_elementtree;_msi;_multiprocessing;_overlapped;pyexpat;select;unicodedata;winsound" />
<!-- Extension modules that require external sources -->
<BuildInParallel>false</BuildInParallel>
</Projects>
+ <!-- _freeze_importlib -->
+ <Projects2 Include="_freeze_importlib.vcxproj" />
<!-- python[w].exe -->
- <Projects2 Include="python.vcxproj;pythonw.vcxproj">
- <BuildInParallel>false</BuildInParallel>
- </Projects2>
+ <Projects2 Include="python.vcxproj;pythonw.vcxproj" />
</ItemGroup>
<Target Name="Build">
<sqlite3Dir>$(ExternalsDir)sqlite-3.14.2.0\</sqlite3Dir>
<bz2Dir>$(ExternalsDir)bzip2-1.0.6\</bz2Dir>
<lzmaDir>$(ExternalsDir)xz-5.2.2\</lzmaDir>
- <opensslDir>$(ExternalsDir)openssl-1.0.2j\</opensslDir>
+ <opensslDir>$(ExternalsDir)openssl-1.0.2k\</opensslDir>
<opensslIncludeDir>$(opensslDir)include32</opensslIncludeDir>
<opensslIncludeDir Condition="'$(ArchName)' == 'amd64'">$(opensslDir)include64</opensslIncludeDir>
<nasmDir>$(ExternalsDir)\nasm-2.11.06\</nasmDir>
</ImportGroup>
<Target Name="_GetBuildInfo" BeforeTargets="PrepareForBuild">
<PropertyGroup>
- <HG Condition="$(HG) == ''">hg</HG>
- <_HG>$(HG)</_HG>
- <_HG Condition="$(HG.Contains(` `))">"$(HG)"</_HG>
+ <GIT Condition="$(GIT) == ''">git</GIT>
+ <_GIT>$(GIT)</_GIT>
+ <_GIT Condition="$(GIT.Contains(` `))">"$(GIT)"</_GIT>
</PropertyGroup>
- <Message Text="Getting build info from $(_HG)" Importance="high" />
+ <Message Text="Getting build info from $(_GIT)" Importance="high" />
<MakeDir Directories="$(IntDir)" Condition="!Exists($(IntDir))" />
- <Exec Command="$(_HG) id -b > "$(IntDir)hgbranch.txt"" ContinueOnError="true" />
- <Exec Command="$(_HG) id -i > "$(IntDir)hgversion.txt"" ContinueOnError="true" />
- <Exec Command="$(_HG) id -t > "$(IntDir)hgtag.txt"" ContinueOnError="true" />
+ <Exec Command="$(_GIT) name-rev --name-only HEAD > "$(IntDir)gitbranch.txt"" ContinueOnError="true" />
+ <Exec Command="$(_GIT) rev-parse --short HEAD > "$(IntDir)gitversion.txt"" ContinueOnError="true" />
+ <Exec Command="$(_GIT) describe --all --always --dirty > "$(IntDir)gittag.txt"" ContinueOnError="true" />
<PropertyGroup>
- <HgBranch Condition="Exists('$(IntDir)hgbranch.txt')">$([System.IO.File]::ReadAllText('$(IntDir)hgbranch.txt').Trim())</HgBranch>
- <HgVersion Condition="Exists('$(IntDir)hgversion.txt')">$([System.IO.File]::ReadAllText('$(IntDir)hgversion.txt').Trim())</HgVersion>
- <HgTag Condition="Exists('$(IntDir)hgtag.txt')">$([System.IO.File]::ReadAllText('$(IntDir)hgtag.txt').Trim())</HgTag>
+ <GitBranch Condition="Exists('$(IntDir)gitbranch.txt')">$([System.IO.File]::ReadAllText('$(IntDir)gitbranch.txt').Trim())</GitBranch>
+ <GitVersion Condition="Exists('$(IntDir)gitversion.txt')">$([System.IO.File]::ReadAllText('$(IntDir)gitversion.txt').Trim())</GitVersion>
+ <GitTag Condition="Exists('$(IntDir)gittag.txt')">$([System.IO.File]::ReadAllText('$(IntDir)gittag.txt').Trim())</GitTag>
</PropertyGroup>
- <Message Text="Building $(HgTag):$(HgVersion) $(HgBranch)" Importance="high" />
+ <Message Text="Building $(GitTag):$(GitVersion) $(GitBranch)" Importance="high" />
<ItemGroup>
<ClCompile Include="..\Modules\getbuildinfo.c">
- <PreprocessorDefinitions>HGVERSION="$(HgVersion)";HGTAG="$(HgTag)";HGBRANCH="$(HgBranch)";%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <PreprocessorDefinitions>GITVERSION="$(GitVersion)";GITTAG="$(GitTag)";GITBRANCH="$(GitBranch)";%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
</ItemGroup>
</Target>
Homepage:\r
http://tukaani.org/xz/\r
_ssl\r
- Python wrapper for version 1.0.2j of the OpenSSL secure sockets\r
+ Python wrapper for version 1.0.2k of the OpenSSL secure sockets\r
library, which is built by ssl.vcxproj\r
Homepage:\r
http://www.openssl.org/\r
/* Identifier (most frequent token!) */
nonascii = 0;
if (is_potential_identifier_start(c)) {
- /* Process b"", r"", u"", br"" and rb"" */
+ /* Process the various legal combinations of b"", r"", u"", and f"". */
int saw_b = 0, saw_r = 0, saw_u = 0, saw_f = 0;
while (1) {
if (!(saw_b || saw_u || saw_f) && (c == 'b' || c == 'B'))
typedef struct {
PyObject *last_str;
ExprList expr_list;
+ int fmode;
} FstringParser;
#ifdef NDEBUG
FstringParser_Init(FstringParser *state)
{
state->last_str = NULL;
+ state->fmode = 0;
ExprList_Init(&state->expr_list);
FstringParser_check_invariants(state);
}
struct compiling *c, const node *n)
{
FstringParser_check_invariants(state);
+ state->fmode = 1;
/* Parse the f-string. */
while (1) {
/* If we're just a constant string with no expressions, return
that. */
- if(state->expr_list.size == 0) {
+ if (!state->fmode) {
+ assert(!state->expr_list.size);
if (!state->last_str) {
/* Create a zero length string. */
state->last_str = PyUnicode_FromStringAndSize(NULL, 0);
if (!seq)
goto error;
- /* If there's only one expression, return it. Otherwise, we need
- to join them together. */
- if (seq->size == 1)
- return seq->elements[0];
-
return JoinedStr(seq, LINENO(n), n->n_col_offset, c->c_arena);
error:
[end disabled clinic input]*/
PyDoc_STRVAR(builtin_sorted__doc__,
-"sorted($module, iterable, key=None, reverse=False)\n"
+"sorted($module, iterable, /, *, key=None, reverse=False)\n"
"--\n"
"\n"
"Return a new list containing all items from the iterable in ascending order.\n"
{
PyObject *newlist, *v, *seq, *keyfunc=NULL, **newargs;
PyObject *callable;
- static char *kwlist[] = {"iterable", "key", "reverse", 0};
+ static char *kwlist[] = {"", "key", "reverse", 0};
int reverse;
Py_ssize_t nargs;
return NULL;
}
+ assert(PyTuple_GET_SIZE(args) >= 1);
newargs = &PyTuple_GET_ITEM(args, 1);
nargs = PyTuple_GET_SIZE(args) - 1;
v = _PyObject_FastCallDict(callable, newargs, nargs, kwds);
TARGET(BINARY_MODULO) {
PyObject *divisor = POP();
PyObject *dividend = TOP();
- PyObject *res = PyUnicode_CheckExact(dividend) ?
- PyUnicode_Format(dividend, divisor) :
- PyNumber_Remainder(dividend, divisor);
+ PyObject *res;
+ if (PyUnicode_CheckExact(dividend) && (
+ !PyUnicode_Check(divisor) || PyUnicode_CheckExact(divisor))) {
+ // fast path; string formatting, but not if the RHS is a str subclass
+ // (see issue28598)
+ res = PyUnicode_Format(dividend, divisor);
+ } else {
+ res = PyNumber_Remainder(dividend, divisor);
+ }
Py_DECREF(divisor);
Py_DECREF(dividend);
SET_TOP(res);
awaitable = _PyCoro_GetAwaitableIter(iter);
if (awaitable == NULL) {
- SET_TOP(NULL);
- PyErr_Format(
+ _PyErr_FormatFromCause(
PyExc_TypeError,
"'async for' received an invalid object "
"from __aiter__: %.100s",
Py_TYPE(iter)->tp_name);
+ SET_TOP(NULL);
Py_DECREF(iter);
goto error;
} else {
awaitable = _PyCoro_GetAwaitableIter(next_iter);
if (awaitable == NULL) {
- PyErr_Format(
+ _PyErr_FormatFromCause(
PyExc_TypeError,
"'async for' received an invalid object "
"from __anext__: %.100s",
TARGET(IMPORT_STAR) {
PyObject *from = POP(), *locals;
int err;
- if (PyFrame_FastToLocalsWithError(f) < 0)
+ if (PyFrame_FastToLocalsWithError(f) < 0) {
+ Py_DECREF(from);
goto error;
+ }
locals = f->f_locals;
if (locals == NULL) {
PyErr_SetString(PyExc_SystemError,
"no locals found during 'import *'");
+ Py_DECREF(from);
goto error;
}
err = import_all_from(locals, from);
assert(!PyErr_Occurred());
#endif
- if (args == NULL) {
- return _PyObject_FastCallDict(func, NULL, 0, kwargs);
- }
-
- if (!PyTuple_Check(args)) {
+ if (args != NULL && !PyTuple_Check(args)) {
PyErr_SetString(PyExc_TypeError,
"argument list must be a tuple");
return NULL;
return NULL;
}
- return PyObject_Call(func, args, kwargs);
+ if (args == NULL) {
+ return _PyObject_FastCallDict(func, NULL, 0, kwargs);
+ }
+ else {
+ return PyObject_Call(func, args, kwargs);
+ }
}
const char *
case CALL_FUNCTION_KW:
return -oparg-1;
case CALL_FUNCTION_EX:
- return - ((oparg & 0x01) != 0) - ((oparg & 0x02) != 0);
+ return -1 - ((oparg & 0x01) != 0);
case MAKE_FUNCTION:
return -1 - ((oparg & 0x01) != 0) - ((oparg & 0x02) != 0) -
((oparg & 0x04) != 0) - ((oparg & 0x08) != 0);
compiler_joined_str(struct compiler *c, expr_ty e)
{
VISIT_SEQ(c, expr, e->v.JoinedStr.values);
- ADDOP_I(c, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values));
+ if (asdl_seq_LEN(e->v.JoinedStr.values) != 1)
+ ADDOP_I(c, BUILD_STRING, asdl_seq_LEN(e->v.JoinedStr.values));
return 1;
}
PyErr_Clear();
Py_DECREF(tmp);
}
+ tmp = NULL;
if (col_offset >= 0) {
tmp = PyLong_FromLong(col_offset);
if (tmp == NULL)
PyErr_Clear();
- else {
- if (_PyObject_SetAttrId(v, &PyId_offset, tmp))
- PyErr_Clear();
- Py_DECREF(tmp);
- }
}
+ if (_PyObject_SetAttrId(v, &PyId_offset, tmp ? tmp : Py_None))
+ PyErr_Clear();
+ Py_XDECREF(tmp);
if (filename != NULL) {
if (_PyObject_SetAttrId(v, &PyId_filename, filename))
PyErr_Clear();
Py_DECREF(tmp);
}
}
- if (_PyObject_SetAttrId(v, &PyId_offset, Py_None)) {
- PyErr_Clear();
- }
if (exc != PyExc_SyntaxError) {
if (!_PyObject_HasAttrId(v, &PyId_msg)) {
tmp = PyObject_Str(v);
}
fclose(fp);
if (i == lineno) {
- char *p = linebuf;
PyObject *res;
- while (*p == ' ' || *p == '\t' || *p == '\014')
- p++;
- res = PyUnicode_FromString(p);
+ res = PyUnicode_FromString(linebuf);
if (res == NULL)
PyErr_Clear();
return res;
#include <fcntl.h>
#endif /* HAVE_FCNTL_H */
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__ANDROID__)
extern wchar_t* _Py_DecodeUTF8_surrogateescape(const char *s, Py_ssize_t size);
#endif
wchar_t*
Py_DecodeLocale(const char* arg, size_t *size)
{
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__ANDROID__)
wchar_t *wstr;
wstr = _Py_DecodeUTF8_surrogateescape(arg, strlen(arg));
if (size != NULL) {
if (size != NULL)
*size = (size_t)-1;
return NULL;
-#endif /* __APPLE__ */
+#endif /* __APPLE__ or __ANDROID__ */
}
/* Encode a wide character string to the locale encoding with the
char*
Py_EncodeLocale(const wchar_t *text, size_t *error_pos)
{
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__ANDROID__)
Py_ssize_t len;
PyObject *unicode, *bytes = NULL;
char *cpath;
bytes = result;
}
return result;
-#endif /* __APPLE__ */
+#endif /* __APPLE__ or __ANDROID__ */
}
static const char cprt[] =
"\
-Copyright (c) 2001-2016 Python Software Foundation.\n\
+Copyright (c) 2001-2017 Python Software Foundation.\n\
All Rights Reserved.\n\
\n\
Copyright (c) 2000 BeOpen.com.\n\
111,118,101,100,197,0,0,0,115,2,0,0,0,0,8,114,
58,0,0,0,114,33,0,0,0,41,1,218,9,118,101,114,
98,111,115,105,116,121,99,1,0,0,0,1,0,0,0,3,
- 0,0,0,5,0,0,0,71,0,0,0,115,54,0,0,0,
+ 0,0,0,4,0,0,0,71,0,0,0,115,54,0,0,0,
116,0,106,1,106,2,124,1,107,5,114,50,124,0,106,3,
100,6,131,1,115,30,100,3,124,0,23,0,125,0,116,4,
124,0,106,5,124,2,142,0,116,0,106,6,100,4,141,2,
218,17,95,102,105,110,100,95,109,111,100,117,108,101,95,115,
104,105,109,157,1,0,0,115,10,0,0,0,0,10,14,1,
16,1,4,1,22,1,114,127,0,0,0,99,4,0,0,0,
- 0,0,0,0,11,0,0,0,22,0,0,0,67,0,0,0,
+ 0,0,0,0,11,0,0,0,19,0,0,0,67,0,0,0,
115,136,1,0,0,105,0,125,4,124,2,100,1,107,9,114,
22,124,2,124,4,100,2,60,0,110,4,100,3,125,2,124,
3,100,1,107,9,114,42,124,3,124,4,100,4,60,0,124,
111,111,116,115,116,114,97,112,32,109,111,100,117,108,101,46,
10,10,32,32,32,32,114,52,0,0,0,114,63,0,0,0,
218,8,98,117,105,108,116,105,110,115,114,140,0,0,0,90,
- 5,112,111,115,105,120,250,1,47,218,2,110,116,250,1,92,
+ 5,112,111,115,105,120,250,1,47,90,2,110,116,250,1,92,
99,1,0,0,0,0,0,0,0,2,0,0,0,3,0,0,
0,115,0,0,0,115,26,0,0,0,124,0,93,18,125,1,
116,0,124,1,131,1,100,0,107,2,86,0,1,0,113,2,
1,10,1,4,2,2,1,10,1,6,1,14,1,12,2,8,
1,12,1,12,1,18,3,2,1,14,1,16,2,10,1,12,
3,10,1,12,3,10,1,10,1,12,3,14,1,14,1,10,
- 1,10,1,10,1,114,32,1,0,0,99,1,0,0,0,0,
+ 1,10,1,10,1,114,31,1,0,0,99,1,0,0,0,0,
0,0,0,2,0,0,0,3,0,0,0,67,0,0,0,115,
- 72,0,0,0,116,0,124,0,131,1,1,0,116,1,131,0,
+ 50,0,0,0,116,0,124,0,131,1,1,0,116,1,131,0,
125,1,116,2,106,3,106,4,116,5,106,6,124,1,142,0,
- 103,1,131,1,1,0,116,7,106,8,100,1,107,2,114,56,
- 116,2,106,9,106,10,116,11,131,1,1,0,116,2,106,9,
- 106,10,116,12,131,1,1,0,100,2,83,0,41,3,122,41,
- 73,110,115,116,97,108,108,32,116,104,101,32,112,97,116,104,
- 45,98,97,115,101,100,32,105,109,112,111,114,116,32,99,111,
- 109,112,111,110,101,110,116,115,46,114,27,1,0,0,78,41,
- 13,114,32,1,0,0,114,159,0,0,0,114,8,0,0,0,
- 114,253,0,0,0,114,147,0,0,0,114,5,1,0,0,114,
- 18,1,0,0,114,3,0,0,0,114,109,0,0,0,218,9,
- 109,101,116,97,95,112,97,116,104,114,161,0,0,0,114,166,
- 0,0,0,114,248,0,0,0,41,2,114,31,1,0,0,90,
- 17,115,117,112,112,111,114,116,101,100,95,108,111,97,100,101,
- 114,115,114,4,0,0,0,114,4,0,0,0,114,6,0,0,
- 0,218,8,95,105,110,115,116,97,108,108,158,5,0,0,115,
- 12,0,0,0,0,2,8,1,6,1,20,1,10,1,12,1,
- 114,34,1,0,0,41,1,114,0,0,0,0,41,2,114,1,
- 0,0,0,114,2,0,0,0,41,1,114,49,0,0,0,41,
- 1,78,41,3,78,78,78,41,3,78,78,78,41,2,114,62,
- 0,0,0,114,62,0,0,0,41,1,78,41,1,78,41,58,
- 114,111,0,0,0,114,12,0,0,0,90,37,95,67,65,83,
- 69,95,73,78,83,69,78,83,73,84,73,86,69,95,80,76,
- 65,84,70,79,82,77,83,95,66,89,84,69,83,95,75,69,
- 89,114,11,0,0,0,114,13,0,0,0,114,19,0,0,0,
- 114,21,0,0,0,114,30,0,0,0,114,40,0,0,0,114,
- 41,0,0,0,114,45,0,0,0,114,46,0,0,0,114,48,
- 0,0,0,114,58,0,0,0,218,4,116,121,112,101,218,8,
- 95,95,99,111,100,101,95,95,114,142,0,0,0,114,17,0,
- 0,0,114,132,0,0,0,114,16,0,0,0,114,20,0,0,
- 0,90,17,95,82,65,87,95,77,65,71,73,67,95,78,85,
- 77,66,69,82,114,77,0,0,0,114,76,0,0,0,114,88,
- 0,0,0,114,78,0,0,0,90,23,68,69,66,85,71,95,
- 66,89,84,69,67,79,68,69,95,83,85,70,70,73,88,69,
- 83,90,27,79,80,84,73,77,73,90,69,68,95,66,89,84,
- 69,67,79,68,69,95,83,85,70,70,73,88,69,83,114,83,
- 0,0,0,114,89,0,0,0,114,95,0,0,0,114,99,0,
- 0,0,114,101,0,0,0,114,120,0,0,0,114,127,0,0,
- 0,114,139,0,0,0,114,145,0,0,0,114,148,0,0,0,
- 114,153,0,0,0,218,6,111,98,106,101,99,116,114,160,0,
- 0,0,114,165,0,0,0,114,166,0,0,0,114,181,0,0,
- 0,114,191,0,0,0,114,207,0,0,0,114,215,0,0,0,
- 114,220,0,0,0,114,226,0,0,0,114,221,0,0,0,114,
- 227,0,0,0,114,246,0,0,0,114,248,0,0,0,114,5,
- 1,0,0,114,23,1,0,0,114,159,0,0,0,114,32,1,
- 0,0,114,34,1,0,0,114,4,0,0,0,114,4,0,0,
- 0,114,4,0,0,0,114,6,0,0,0,218,8,60,109,111,
- 100,117,108,101,62,8,0,0,0,115,108,0,0,0,4,16,
- 4,1,4,1,2,1,6,3,8,17,8,5,8,5,8,6,
- 8,12,8,10,8,9,8,5,8,7,10,22,10,123,16,1,
- 12,2,4,1,4,2,6,2,6,2,8,2,16,45,8,34,
- 8,19,8,12,8,12,8,28,8,17,10,55,10,12,10,10,
- 8,14,6,3,4,1,14,67,14,64,14,29,16,110,14,41,
- 18,45,18,16,4,3,18,53,14,60,14,42,14,127,0,5,
- 14,127,0,22,10,23,8,11,8,68,
+ 103,1,131,1,1,0,116,2,106,7,106,8,116,9,131,1,
+ 1,0,100,1,83,0,41,2,122,41,73,110,115,116,97,108,
+ 108,32,116,104,101,32,112,97,116,104,45,98,97,115,101,100,
+ 32,105,109,112,111,114,116,32,99,111,109,112,111,110,101,110,
+ 116,115,46,78,41,10,114,31,1,0,0,114,159,0,0,0,
+ 114,8,0,0,0,114,253,0,0,0,114,147,0,0,0,114,
+ 5,1,0,0,114,18,1,0,0,218,9,109,101,116,97,95,
+ 112,97,116,104,114,161,0,0,0,114,248,0,0,0,41,2,
+ 114,30,1,0,0,90,17,115,117,112,112,111,114,116,101,100,
+ 95,108,111,97,100,101,114,115,114,4,0,0,0,114,4,0,
+ 0,0,114,6,0,0,0,218,8,95,105,110,115,116,97,108,
+ 108,158,5,0,0,115,8,0,0,0,0,2,8,1,6,1,
+ 20,1,114,33,1,0,0,41,1,114,0,0,0,0,41,2,
+ 114,1,0,0,0,114,2,0,0,0,41,1,114,49,0,0,
+ 0,41,1,78,41,3,78,78,78,41,3,78,78,78,41,2,
+ 114,62,0,0,0,114,62,0,0,0,41,1,78,41,1,78,
+ 41,58,114,111,0,0,0,114,12,0,0,0,90,37,95,67,
+ 65,83,69,95,73,78,83,69,78,83,73,84,73,86,69,95,
+ 80,76,65,84,70,79,82,77,83,95,66,89,84,69,83,95,
+ 75,69,89,114,11,0,0,0,114,13,0,0,0,114,19,0,
+ 0,0,114,21,0,0,0,114,30,0,0,0,114,40,0,0,
+ 0,114,41,0,0,0,114,45,0,0,0,114,46,0,0,0,
+ 114,48,0,0,0,114,58,0,0,0,218,4,116,121,112,101,
+ 218,8,95,95,99,111,100,101,95,95,114,142,0,0,0,114,
+ 17,0,0,0,114,132,0,0,0,114,16,0,0,0,114,20,
+ 0,0,0,90,17,95,82,65,87,95,77,65,71,73,67,95,
+ 78,85,77,66,69,82,114,77,0,0,0,114,76,0,0,0,
+ 114,88,0,0,0,114,78,0,0,0,90,23,68,69,66,85,
+ 71,95,66,89,84,69,67,79,68,69,95,83,85,70,70,73,
+ 88,69,83,90,27,79,80,84,73,77,73,90,69,68,95,66,
+ 89,84,69,67,79,68,69,95,83,85,70,70,73,88,69,83,
+ 114,83,0,0,0,114,89,0,0,0,114,95,0,0,0,114,
+ 99,0,0,0,114,101,0,0,0,114,120,0,0,0,114,127,
+ 0,0,0,114,139,0,0,0,114,145,0,0,0,114,148,0,
+ 0,0,114,153,0,0,0,218,6,111,98,106,101,99,116,114,
+ 160,0,0,0,114,165,0,0,0,114,166,0,0,0,114,181,
+ 0,0,0,114,191,0,0,0,114,207,0,0,0,114,215,0,
+ 0,0,114,220,0,0,0,114,226,0,0,0,114,221,0,0,
+ 0,114,227,0,0,0,114,246,0,0,0,114,248,0,0,0,
+ 114,5,1,0,0,114,23,1,0,0,114,159,0,0,0,114,
+ 31,1,0,0,114,33,1,0,0,114,4,0,0,0,114,4,
+ 0,0,0,114,4,0,0,0,114,6,0,0,0,218,8,60,
+ 109,111,100,117,108,101,62,8,0,0,0,115,108,0,0,0,
+ 4,16,4,1,4,1,2,1,6,3,8,17,8,5,8,5,
+ 8,6,8,12,8,10,8,9,8,5,8,7,10,22,10,123,
+ 16,1,12,2,4,1,4,2,6,2,6,2,8,2,16,45,
+ 8,34,8,19,8,12,8,12,8,28,8,17,10,55,10,12,
+ 10,10,8,14,6,3,4,1,14,67,14,64,14,29,16,110,
+ 14,41,18,45,18,16,4,3,18,53,14,60,14,42,14,127,
+ 0,5,14,127,0,22,10,23,8,11,8,68,
};
offset -= (int)(nl+1-text);
text = nl+1;
}
- while (*text == ' ' || *text == '\t') {
+ while (*text == ' ' || *text == '\t' || *text == '\f') {
text++;
offset--;
}
# ifdef HAVE_LINUX_RANDOM_H
# include <linux/random.h>
# endif
-# if defined(HAVE_GETRANDOM) || defined(HAVE_GETENTROPY)
+# if defined(HAVE_SYS_RANDOM_H) && (defined(HAVE_GETRANDOM) || defined(HAVE_GETENTROPY))
# include <sys/random.h>
# endif
# if !defined(HAVE_GETRANDOM) && defined(HAVE_GETRANDOM_SYSCALL)
return 0;
}
-/* Issue #25003: Don't use getentropy() on Solaris (available since
- * Solaris 11.3), it is blocking whereas os.urandom() should not block. */
-#elif defined(HAVE_GETENTROPY) && !defined(sun)
-#define PY_GETENTROPY 1
-
-/* Fill buffer with size pseudo-random bytes generated by getentropy().
- Return 0 on success, or raise an exception and return -1 on error.
-
- If raise is zero, don't raise an exception on error. */
-static int
-py_getentropy(char *buffer, Py_ssize_t size, int raise)
-{
- while (size > 0) {
- Py_ssize_t len = Py_MIN(size, 256);
- int res;
-
- if (raise) {
- Py_BEGIN_ALLOW_THREADS
- res = getentropy(buffer, len);
- Py_END_ALLOW_THREADS
- }
- else {
- res = getentropy(buffer, len);
- }
-
- if (res < 0) {
- if (raise) {
- PyErr_SetFromErrno(PyExc_OSError);
- }
- return -1;
- }
-
- buffer += len;
- size -= len;
- }
- return 0;
-}
-
-#else
+#else /* !MS_WINDOWS */
#if defined(HAVE_GETRANDOM) || defined(HAVE_GETRANDOM_SYSCALL)
#define PY_GETRANDOM 1
-/* Call getrandom()
+/* Call getrandom() to get random bytes:
+
- Return 1 on success
- - Return 0 if getrandom() syscall is not available (failed with ENOSYS or
- EPERM) or if getrandom(GRND_NONBLOCK) failed with EAGAIN (system urandom
- not initialized yet) and raise=0.
+ - Return 0 if getrandom() is not available (failed with ENOSYS or EPERM),
+ or if getrandom(GRND_NONBLOCK) failed with EAGAIN (system urandom not
+ initialized yet) and raise=0.
- Raise an exception (if raise is non-zero) and return -1 on error:
- getrandom() failed with EINTR and the Python signal handler raised an
- exception, or getrandom() failed with a different error. */
+ if getrandom() failed with EINTR, raise is non-zero and the Python signal
+ handler raised an exception, or if getrandom() failed with a different
+ error.
+
+ getrandom() is retried if it failed with EINTR: interrupted by a signal. */
static int
py_getrandom(void *buffer, Py_ssize_t size, int blocking, int raise)
{
while (0 < size) {
#ifdef sun
/* Issue #26735: On Solaris, getrandom() is limited to returning up
- to 1024 bytes */
+ to 1024 bytes. Call it multiple times if more bytes are
+ requested. */
n = Py_MIN(size, 1024);
#else
n = Py_MIN(size, LONG_MAX);
#endif
if (n < 0) {
- /* ENOSYS: getrandom() syscall not supported by the kernel (but
- * maybe supported by the host which built Python). EPERM:
- * getrandom() syscall blocked by SECCOMP or something else. */
+ /* ENOSYS: the syscall is not supported by the kernel.
+ EPERM: the syscall is blocked by a security policy (ex: SECCOMP)
+ or something else. */
if (errno == ENOSYS || errno == EPERM) {
getrandom_works = 0;
return 0;
}
/* getrandom(GRND_NONBLOCK) fails with EAGAIN if the system urandom
- is not initialiazed yet. For _PyRandom_Init(), we ignore their
+ is not initialiazed yet. For _PyRandom_Init(), we ignore the
error and fall back on reading /dev/urandom which never blocks,
- even if the system urandom is not initialized yet. */
+ even if the system urandom is not initialized yet:
+ see the PEP 524. */
if (errno == EAGAIN && !raise && !blocking) {
return 0;
}
}
return 1;
}
-#endif
+
+#elif defined(HAVE_GETENTROPY)
+#define PY_GETENTROPY 1
+
+/* Fill buffer with size pseudo-random bytes generated by getentropy():
+
+ - Return 1 on success
+ - Return 0 if getentropy() syscall is not available (failed with ENOSYS or
+ EPERM).
+ - Raise an exception (if raise is non-zero) and return -1 on error:
+ if getentropy() failed with EINTR, raise is non-zero and the Python signal
+ handler raised an exception, or if getentropy() failed with a different
+ error.
+
+ getentropy() is retried if it failed with EINTR: interrupted by a signal. */
+static int
+py_getentropy(char *buffer, Py_ssize_t size, int raise)
+{
+ /* Is getentropy() supported by the running kernel? Set to 0 if
+ getentropy() failed with ENOSYS or EPERM. */
+ static int getentropy_works = 1;
+
+ if (!getentropy_works) {
+ return 0;
+ }
+
+ while (size > 0) {
+ /* getentropy() is limited to returning up to 256 bytes. Call it
+ multiple times if more bytes are requested. */
+ Py_ssize_t len = Py_MIN(size, 256);
+ int res;
+
+ if (raise) {
+ Py_BEGIN_ALLOW_THREADS
+ res = getentropy(buffer, len);
+ Py_END_ALLOW_THREADS
+ }
+ else {
+ res = getentropy(buffer, len);
+ }
+
+ if (res < 0) {
+ /* ENOSYS: the syscall is not supported by the running kernel.
+ EPERM: the syscall is blocked by a security policy (ex: SECCOMP)
+ or something else. */
+ if (errno == ENOSYS || errno == EPERM) {
+ getentropy_works = 0;
+ return 0;
+ }
+
+ if (errno == EINTR) {
+ if (raise) {
+ if (PyErr_CheckSignals()) {
+ return -1;
+ }
+ }
+
+ /* retry getentropy() if it was interrupted by a signal */
+ continue;
+ }
+
+ if (raise) {
+ PyErr_SetFromErrno(PyExc_OSError);
+ }
+ return -1;
+ }
+
+ buffer += len;
+ size -= len;
+ }
+ return 1;
+}
+#endif /* defined(HAVE_GETENTROPY) && !defined(sun) */
+
static struct {
int fd;
ino_t st_ino;
} urandom_cache = { -1 };
+/* Read random bytes from the /dev/urandom device:
+
+ - Return 0 on success
+ - Raise an exception (if raise is non-zero) and return -1 on error
+
+ Possible causes of errors:
+
+ - open() failed with ENOENT, ENXIO, ENODEV, EACCES: the /dev/urandom device
+ was not found. For example, it was removed manually or not exposed in a
+ chroot or container.
+ - open() failed with a different error
+ - fstat() failed
+ - read() failed or returned 0
-/* Read 'size' random bytes from py_getrandom(). Fall back on reading from
- /dev/urandom if getrandom() is not available.
+ read() is retried if it failed with EINTR: interrupted by a signal.
- Return 0 on success. Raise an exception (if raise is non-zero) and return -1
- on error. */
+ The file descriptor of the device is kept open between calls to avoid using
+ many file descriptors when run in parallel from multiple threads:
+ see the issue #18756.
+
+ st_dev and st_ino fields of the file descriptor (from fstat()) are cached to
+ check if the file descriptor was replaced by a different file (which is
+ likely a bug in the application): see the issue #21207.
+
+ If the file descriptor was closed or replaced, open a new file descriptor
+ but don't close the old file descriptor: it probably points to something
+ important for some third-party code. */
static int
-dev_urandom(char *buffer, Py_ssize_t size, int blocking, int raise)
+dev_urandom(char *buffer, Py_ssize_t size, int raise)
{
int fd;
Py_ssize_t n;
-#ifdef PY_GETRANDOM
- int res;
-#endif
-
- assert(size > 0);
-
-#ifdef PY_GETRANDOM
- res = py_getrandom(buffer, size, blocking, raise);
- if (res < 0) {
- return -1;
- }
- if (res == 1) {
- return 0;
- }
- /* getrandom() failed with ENOSYS or EPERM,
- fall back on reading /dev/urandom */
-#endif
-
if (raise) {
struct _Py_stat_struct st;
fd = _Py_open("/dev/urandom", O_RDONLY);
if (fd < 0) {
if (errno == ENOENT || errno == ENXIO ||
- errno == ENODEV || errno == EACCES)
+ errno == ENODEV || errno == EACCES) {
PyErr_SetString(PyExc_NotImplementedError,
"/dev/urandom (or equivalent) not found");
+ }
/* otherwise, keep the OSError exception raised by _Py_open() */
return -1;
}
urandom_cache.fd = -1;
}
}
+#endif /* !MS_WINDOWS */
-#endif
/* Fill buffer with pseudo-random bytes generated by a linear congruent
generator (LCG):
}
}
-/* If raise is zero:
- - Don't raise exceptions on error
- - Don't call PyErr_CheckSignals() on EINTR (retry directly the interrupted
- syscall)
- - Don't release the GIL to call syscalls. */
+/* Read random bytes:
+
+ - Return 0 on success
+ - Raise an exception (if raise is non-zero) and return -1 on error
+
+ Used sources of entropy ordered by preference, preferred source first:
+
+ - CryptGenRandom() on Windows
+ - getrandom() function (ex: Linux and Solaris): call py_getrandom()
+ - getentropy() function (ex: OpenBSD): call py_getentropy()
+ - /dev/urandom device
+
+ Read from the /dev/urandom device if getrandom() or getentropy() function
+ is not available or does not work.
+
+ Prefer getrandom() over getentropy() because getrandom() supports blocking
+ and non-blocking mode: see the PEP 524. Python requires non-blocking RNG at
+ startup to initialize its hash secret, but os.urandom() must block until the
+ system urandom is initialized (at least on Linux 3.17 and newer).
+
+ Prefer getrandom() and getentropy() over reading directly /dev/urandom
+ because these functions don't need file descriptors and so avoid ENFILE or
+ EMFILE errors (too many open files): see the issue #18756.
+
+ Only the getrandom() function supports non-blocking mode.
+
+ Only use RNG running in the kernel. They are more secure because it is
+ harder to get the internal state of a RNG running in the kernel land than a
+ RNG running in the user land. The kernel has a direct access to the hardware
+ and has access to hardware RNG, they are used as entropy sources.
+
+ Note: the OpenSSL RAND_pseudo_bytes() function does not automatically reseed
+ its RNG on fork(), two child processes (with the same pid) generate the same
+ random numbers: see issue #18747. Kernel RNGs don't have this issue,
+ they have access to good quality entropy sources.
+
+ If raise is zero:
+
+ - Don't raise an exception on error
+ - Don't call the Python signal handler (don't call PyErr_CheckSignals()) if
+ a function fails with EINTR: retry directly the interrupted function
+ - Don't release the GIL to call functions.
+*/
static int
pyurandom(void *buffer, Py_ssize_t size, int blocking, int raise)
{
+#if defined(PY_GETRANDOM) || defined(PY_GETENTROPY)
+ int res;
+#endif
+
if (size < 0) {
if (raise) {
PyErr_Format(PyExc_ValueError,
#ifdef MS_WINDOWS
return win32_urandom((unsigned char *)buffer, size, raise);
-#elif defined(PY_GETENTROPY)
- return py_getentropy(buffer, size, raise);
#else
- return dev_urandom(buffer, size, blocking, raise);
+
+#if defined(PY_GETRANDOM) || defined(PY_GETENTROPY)
+#ifdef PY_GETRANDOM
+ res = py_getrandom(buffer, size, blocking, raise);
+#else
+ res = py_getentropy(buffer, size, raise);
+#endif
+ if (res < 0) {
+ return -1;
+ }
+ if (res == 1) {
+ return 0;
+ }
+ /* getrandom() or getentropy() function is not available: failed with
+ ENOSYS or EPERM. Fall back on reading from /dev/urandom. */
+#endif
+
+ return dev_urandom(buffer, size, raise);
#endif
}
CryptReleaseContext(hCryptProv, 0);
hCryptProv = 0;
}
-#elif defined(PY_GETENTROPY)
- /* nothing to clean */
#else
dev_urandom_close();
#endif
PyUnicode_FromString(Py_GetVersion()));
SET_SYS_FROM_STRING("hexversion",
PyLong_FromLong(PY_VERSION_HEX));
- SET_SYS_FROM_STRING("_mercurial",
- Py_BuildValue("(szz)", "CPython", _Py_hgidentifier(),
- _Py_hgversion()));
+ SET_SYS_FROM_STRING("_git",
+ Py_BuildValue("(szz)", "CPython", _Py_gitidentifier(),
+ _Py_gitversion()));
SET_SYS_FROM_STRING("dont_write_bytecode",
PyBool_FromLong(Py_DontWriteBytecodeFlag));
SET_SYS_FROM_STRING("api_version",
+++ /dev/null
-This is Python version 3.6.0
-============================
-
-Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
-2012, 2013, 2014, 2015, 2016 Python Software Foundation. All rights reserved.
-
-Python 3.x is a new version of the language, which is incompatible with the
-2.x line of releases. The language is mostly the same, but many details,
-especially how built-in objects like dictionaries and strings work,
-have changed considerably, and a lot of deprecated features have finally
-been removed.
-
-
-Build Instructions
-------------------
-
-On Unix, Linux, BSD, OSX, and Cygwin:
-
- ./configure
- make
- make test
- sudo make install
-
-This will install Python as python3.
-
-You can pass many options to the configure script; run "./configure --help" to
-find out more. On OSX and Cygwin, the executable is called python.exe;
-elsewhere it's just python.
-
-On Mac OS X, if you have configured Python with --enable-framework, you should
-use "make frameworkinstall" to do the installation. Note that this installs the
-Python executable in a place that is not normally on your PATH, you may want to
-set up a symlink in /usr/local/bin.
-
-On Windows, see PCbuild/readme.txt.
-
-If you wish, you can create a subdirectory and invoke configure from there.
-For example:
-
- mkdir debug
- cd debug
- ../configure --with-pydebug
- make
- make test
-
-(This will fail if you *also* built at the top-level directory.
-You should do a "make clean" at the toplevel first.)
-
-To get an optimized build of Python, "configure --enable-optimizations" before
-you run make. This sets the default make targets up to enable Profile Guided
-Optimization (PGO) and may be used to auto-enable Link Time Optimization (LTO)
-on some platforms. For more details, see the sections bellow.
-
-
-Profile Guided Optimization
----------------------------
-
-PGO takes advantage of recent versions of the GCC or Clang compilers.
-If ran, "make profile-opt" will do several steps.
-
-First, the entire Python directory is cleaned of temporary files that
-may have resulted in a previous compilation.
-
-Then, an instrumented version of the interpreter is built, using suitable
-compiler flags for each flavour. Note that this is just an intermediary
-step and the binary resulted after this step is not good for real life
-workloads, as it has profiling instructions embedded inside.
-
-After this instrumented version of the interpreter is built, the Makefile
-will automatically run a training workload. This is necessary in order to
-profile the interpreter execution. Note also that any output, both stdout
-and stderr, that may appear at this step is suppressed.
-
-Finally, the last step is to rebuild the interpreter, using the information
-collected in the previous one. The end result will be a Python binary
-that is optimized and suitable for distribution or production installation.
-
-
-Link Time Optimization
-----------------------
-
-Enabled via configure's --with-lto flag. LTO takes advantages of recent
-compiler toolchains ability to optimize across the otherwise arbitrary .o file
-boundary when building final executables or shared libraries for additional
-performance gains.
-
-
-What's New
-----------
-
-We have a comprehensive overview of the changes in the "What's New in
-Python 3.6" document, found at
-
- https://docs.python.org/3.6/whatsnew/3.6.html
-
-For a more detailed change log, read Misc/NEWS (though this file, too,
-is incomplete, and also doesn't list anything merged in from the 2.7
-release under development).
-
-If you want to install multiple versions of Python see the section below
-entitled "Installing multiple versions".
-
-
-Documentation
--------------
-
-Documentation for Python 3.6 is online, updated daily:
-
- https://docs.python.org/3.6/
-
-It can also be downloaded in many formats for faster access. The documentation
-is downloadable in HTML, PDF, and reStructuredText formats; the latter version
-is primarily for documentation authors, translators, and people with special
-formatting requirements.
-
-If you would like to contribute to the development of Python, relevant
-documentation is available at:
-
- https://docs.python.org/devguide/
-
-For information about building Python's documentation, refer to Doc/README.txt.
-
-
-Converting From Python 2.x to 3.x
----------------------------------
-
-Python starting with 2.6 contains features to help locating code that needs to
-be changed, such as optional warnings when deprecated features are used, and
-backported versions of certain key Python 3.x features.
-
-A source-to-source translation tool, "2to3", can take care of the mundane task
-of converting large amounts of source code. It is not a complete solution but
-is complemented by the deprecation warnings in 2.6. See
-https://docs.python.org/3.6/library/2to3.html for more information.
-
-
-Testing
--------
-
-To test the interpreter, type "make test" in the top-level directory.
-The test set produces some output. You can generally ignore the messages
-about skipped tests due to optional features which can't be imported.
-If a message is printed about a failed test or a traceback or core dump
-is produced, something is wrong.
-
-By default, tests are prevented from overusing resources like disk space and
-memory. To enable these tests, run "make testall".
-
-IMPORTANT: If the tests fail and you decide to mail a bug report, *don't*
-include the output of "make test". It is useless. Run the failing test
-manually, as follows:
-
- ./python -m test -v test_whatever
-
-(substituting the top of the source tree for '.' if you built in a different
-directory). This runs the test in verbose mode.
-
-
-Installing multiple versions
-----------------------------
-
-On Unix and Mac systems if you intend to install multiple versions of Python
-using the same installation prefix (--prefix argument to the configure script)
-you must take care that your primary python executable is not overwritten by the
-installation of a different version. All files and directories installed using
-"make altinstall" contain the major and minor version and can thus live
-side-by-side. "make install" also creates ${prefix}/bin/python3 which refers to
-${prefix}/bin/pythonX.Y. If you intend to install multiple versions using the
-same prefix you must decide which version (if any) is your "primary" version.
-Install that version using "make install". Install all other versions using
-"make altinstall".
-
-For example, if you want to install Python 2.7, 3.5, and 3.6 with 3.6 being the
-primary version, you would execute "make install" in your 3.6 build directory
-and "make altinstall" in the others.
-
-
-Issue Tracker and Mailing List
-------------------------------
-
-We're soliciting bug reports about all aspects of the language. Fixes are also
-welcome, preferably in unified diff format. Please use the issue tracker:
-
- https://bugs.python.org/
-
-If you're not sure whether you're dealing with a bug or a feature, use the
-mailing list:
-
- python-dev@python.org
-
-To subscribe to the list, use the mailman form:
-
- https://mail.python.org/mailman/listinfo/python-dev/
-
-
-Proposals for enhancement
--------------------------
-
-If you have a proposal to change Python, you may want to send an email to the
-comp.lang.python or python-ideas mailing lists for initial feedback. A Python
-Enhancement Proposal (PEP) may be submitted if your idea gains ground. All
-current PEPs, as well as guidelines for submitting a new PEP, are listed at
-https://www.python.org/dev/peps/.
-
-
-Release Schedule
-----------------
-
-See PEP 494 for release details: https://www.python.org/dev/peps/pep-0494/
-
-
-Copyright and License Information
----------------------------------
-
-Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
-2012, 2013, 2014, 2015, 2016 Python Software Foundation. All rights reserved.
-
-Copyright (c) 2000 BeOpen.com. All rights reserved.
-
-Copyright (c) 1995-2001 Corporation for National Research Initiatives. All
-rights reserved.
-
-Copyright (c) 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
-
-See the file "LICENSE" for information on the history of this software,
-terms & conditions for usage, and a DISCLAIMER OF ALL WARRANTIES.
-
-This Python distribution contains *no* GNU General Public License (GPL) code,
-so it may be used in proprietary projects. There are interfaces to some GNU
-code but these are entirely optional.
-
-All trademarks referenced herein are property of their respective holders.
-
--- /dev/null
+This is Python version 3.6.1
+============================
+
+.. image:: https://travis-ci.org/python/cpython.svg?branch=3.6
+ :alt: CPython build status on Travis CI
+ :target: https://travis-ci.org/python/cpython
+
+.. image:: https://codecov.io/gh/python/cpython/branch/3.6/graph/badge.svg
+ :alt: CPython code coverage on Codecov
+ :target: https://codecov.io/gh/python/cpython
+
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
+2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation. All rights
+reserved.
+
+See the end of this file for further copyright and license information.
+
+General Information
+-------------------
+
+- Website: https://www.python.org
+- Source code: https://github.com/python/cpython
+- Issue tracker: https://bugs.python.org
+- Documentation: https://docs.python.org
+- Developer's Guide: https://docs.python.org/devguide/
+
+Contributing to CPython
+-----------------------
+
+For more complete instructions on contributing to CPython development,
+see the `Developer Guide`_.
+
+.. _Developer Guide: https://docs.python.org/devguide/
+
+Using Python
+------------
+
+Installable Python kits, and information about using Python, are available at
+`python.org`_.
+
+.. _python.org: https://www.python.org/
+
+
+Build Instructions
+------------------
+
+On Unix, Linux, BSD, macOS, and Cygwin::
+
+ ./configure
+ make
+ make test
+ sudo make install
+
+This will install Python as python3.
+
+You can pass many options to the configure script; run ``./configure --help``
+to find out more. On macOS and Cygwin, the executable is called ``python.exe``;
+elsewhere it's just ``python``.
+
+On macOS, if you have configured Python with ``--enable-framework``, you
+should use ``make frameworkinstall`` to do the installation. Note that this
+installs the Python executable in a place that is not normally on your PATH,
+you may want to set up a symlink in ``/usr/local/bin``.
+
+On Windows, see `PCbuild/readme.txt
+<https://github.com/python/cpython/blob/3.6/PCbuild/readme.txt>`_.
+
+If you wish, you can create a subdirectory and invoke configure from there.
+For example::
+
+ mkdir debug
+ cd debug
+ ../configure --with-pydebug
+ make
+ make test
+
+(This will fail if you *also* built at the top-level directory. You should do
+a ``make clean`` at the toplevel first.)
+
+To get an optimized build of Python, ``configure --enable-optimizations``
+before you run ``make``. This sets the default make targets up to enable
+Profile Guided Optimization (PGO) and may be used to auto-enable Link Time
+Optimization (LTO) on some platforms. For more details, see the sections
+below.
+
+
+Profile Guided Optimization
+---------------------------
+
+PGO takes advantage of recent versions of the GCC or Clang compilers. If ran,
+``make profile-opt`` will do several steps.
+
+First, the entire Python directory is cleaned of temporary files that may have
+resulted in a previous compilation.
+
+Then, an instrumented version of the interpreter is built, using suitable
+compiler flags for each flavour. Note that this is just an intermediary step
+and the binary resulted after this step is not good for real life workloads, as
+it has profiling instructions embedded inside.
+
+After this instrumented version of the interpreter is built, the Makefile will
+automatically run a training workload. This is necessary in order to profile
+the interpreter execution. Note also that any output, both stdout and stderr,
+that may appear at this step is suppressed.
+
+Finally, the last step is to rebuild the interpreter, using the information
+collected in the previous one. The end result will be a Python binary that is
+optimized and suitable for distribution or production installation.
+
+
+Link Time Optimization
+----------------------
+
+Enabled via configure's ``--with-lto`` flag. LTO takes advantage of the
+ability of recent compiler toolchains to optimize across the otherwise
+arbitrary ``.o`` file boundary when building final executables or shared
+libraries for additional performance gains.
+
+
+What's New
+----------
+
+We have a comprehensive overview of the changes in the `What's New in Python
+3.6 <https://docs.python.org/3.6/whatsnew/3.6.html>`_ document. For a more
+detailed change log, read `Misc/NEWS
+<https://github.com/python/cpython/blob/3.6/Misc/NEWS>`_, but a full
+accounting of changes can only be gleaned from the `commit history
+<https://github.com/python/cpython/commits/3.6>`_.
+
+If you want to install multiple versions of Python see the section below
+entitled "Installing multiple versions".
+
+
+Documentation
+-------------
+
+`Documentation for Python 3.6 <https://docs.python.org/3.6/>`_ is online,
+updated daily.
+
+It can also be downloaded in many formats for faster access. The documentation
+is downloadable in HTML, PDF, and reStructuredText formats; the latter version
+is primarily for documentation authors, translators, and people with special
+formatting requirements.
+
+For information about building Python's documentation, refer to `Doc/README.rst
+<https://github.com/python/cpython/blob/3.6/Doc/README.rst>`_.
+
+
+Converting From Python 2.x to 3.x
+---------------------------------
+
+Significant backward incompatible changes were made for the release of Python
+3.0, which may cause programs written for Python 2 to fail when run with Python
+3. For more information about porting your code from Python 2 to Python 3, see
+the `Porting HOWTO <https://docs.python.org/3/howto/pyporting.html>`_.
+
+
+Testing
+-------
+
+To test the interpreter, type ``make test`` in the top-level directory. The
+test set produces some output. You can generally ignore the messages about
+skipped tests due to optional features which can't be imported. If a message
+is printed about a failed test or a traceback or core dump is produced,
+something is wrong.
+
+By default, tests are prevented from overusing resources like disk space and
+memory. To enable these tests, run ``make testall``.
+
+If any tests fail, you can re-run the failing test(s) in verbose mode::
+
+ make test TESTOPTS="-v test_that_failed"
+
+If the failure persists and appears to be a problem with Python rather than
+your environment, you can `file a bug report <https://bugs.python.org>`_ and
+include relevant output from that command to show the issue.
+
+
+Installing multiple versions
+----------------------------
+
+On Unix and Mac systems if you intend to install multiple versions of Python
+using the same installation prefix (``--prefix`` argument to the configure
+script) you must take care that your primary python executable is not
+overwritten by the installation of a different version. All files and
+directories installed using ``make altinstall`` contain the major and minor
+version and can thus live side-by-side. ``make install`` also creates
+``${prefix}/bin/python3`` which refers to ``${prefix}/bin/pythonX.Y``. If you
+intend to install multiple versions using the same prefix you must decide which
+version (if any) is your "primary" version. Install that version using ``make
+install``. Install all other versions using ``make altinstall``.
+
+For example, if you want to install Python 2.7, 3.5, and 3.6 with 3.6 being the
+primary version, you would execute ``make install`` in your 3.6 build directory
+and ``make altinstall`` in the others.
+
+
+Issue Tracker and Mailing List
+------------------------------
+
+Bug reports are welcome! You can use the `issue tracker
+<https://bugs.python.org>`_ to report bugs, and/or submit pull requests `on
+GitHub <https://github.com/python/cpython>`_.
+
+You can also follow development discussion on the `python-dev mailing list
+<https://mail.python.org/mailman/listinfo/python-dev/>`_.
+
+
+Proposals for enhancement
+-------------------------
+
+If you have a proposal to change Python, you may want to send an email to the
+comp.lang.python or `python-ideas`_ mailing lists for initial feedback. A
+Python Enhancement Proposal (PEP) may be submitted if your idea gains ground.
+All current PEPs, as well as guidelines for submitting a new PEP, are listed at
+`python.org/dev/peps/ <https://www.python.org/dev/peps/>`_.
+
+.. _python-ideas: https://mail.python.org/mailman/listinfo/python-ideas/
+
+
+Release Schedule
+----------------
+
+See :pep:`494` for Python 3.6 release details.
+
+
+Copyright and License Information
+---------------------------------
+
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
+2012, 2013, 2014, 2015, 2016 Python Software Foundation. All rights reserved.
+
+Copyright (c) 2000 BeOpen.com. All rights reserved.
+
+Copyright (c) 1995-2001 Corporation for National Research Initiatives. All
+rights reserved.
+
+Copyright (c) 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
+
+See the file "LICENSE" for information on the history of this software, terms &
+conditions for usage, and a DISCLAIMER OF ALL WARRANTIES.
+
+This Python distribution contains *no* GNU General Public License (GPL) code,
+so it may be used in proprietary projects. There are interfaces to some GNU
+code but these are entirely optional.
+
+All trademarks referenced herein are property of their respective holders.
discovery.
-(*) A generic benchmark suite is maintained separately at http://hg.python.org/benchmarks/
+(*) A generic benchmark suite is maintained separately at https://github.com/python/performance
def get_selected_python_frame(cls):
'''Try to obtain the Frame for the python-related code in the selected
frame, or None'''
- frame = cls.get_selected_frame()
+ try:
+ frame = cls.get_selected_frame()
+ except gdb.error:
+ # No frame: Python didn't start yet
+ return None
while frame:
if frame.is_python_frame():
def move_in_stack(move_up):
'''Move up or down the stack (for the py-up/py-down command)'''
frame = Frame.get_selected_python_frame()
+ if not frame:
+ print('Unable to locate python frame')
+ return
+
while frame:
if move_up:
iter_frame = frame.older()
def invoke(self, args, from_tty):
frame = Frame.get_selected_python_frame()
+ if not frame:
+ print('Unable to locate python frame')
+ return
+
while frame:
if frame.is_python_frame():
frame.print_summary()
def invoke(self, args, from_tty):
- sys.stdout.write('Traceback (most recent call first):\n')
frame = Frame.get_selected_python_frame()
+ if not frame:
+ print('Unable to locate python frame')
+ return
+
+ sys.stdout.write('Traceback (most recent call first):\n')
while frame:
if frame.is_python_frame():
frame.print_traceback()
It should not be used as an overall benchmark of import performance, but rather
an easy way to measure impact of possible code changes. For a real-world
benchmark of import, use the normal_startup benchmark from
-hg.python.org/benchmarks.
+https://github.com/python/performance
\r
if not defined BUILDX86 if not defined BUILDX64 (set BUILDX86=1) && (set BUILDX64=1)\r
\r
-if not exist "%HG%" where hg > "%TEMP%\hg.loc" 2> nul && set /P HG= < "%TEMP%\hg.loc" & del "%TEMP%\hg.loc"\r
-if not exist "%HG%" echo Cannot find Mercurial on PATH && exit /B 1\r
+if not exist "%GIT%" where git > "%TEMP%\git.loc" 2> nul && set /P GIT= < "%TEMP%\git.loc" & del "%TEMP%\git.loc"\r
+if not exist "%GIT%" echo Cannot find Git on PATH && exit /B 1\r
\r
call "%D%get_externals.bat"\r
\r
<Component Id="NEWS.txt" Directory="InstallDirectory" Guid="*">
<File Name="NEWS.txt" Source="!(bindpath.src)Misc\NEWS" KeyPath="yes" />
</Component>
- <Component Id="README.txt" Directory="InstallDirectory" Guid="*">
- <File Name="README.txt" Source="!(bindpath.src)README" KeyPath="yes" />
- </Component>
</ComponentGroup>
</Fragment>
<CleanCommand>rmdir /q/s "$(IntermediateOutputPath)\zip_$(ArchName)"</CleanCommand>
<Arguments>"$(PythonExe)" "$(MSBuildThisFileDirectory)\make_zip.py"</Arguments>
<Arguments>$(Arguments) -e -o "$(TargetPath)" -t "$(IntermediateOutputPath)\zip_$(ArchName)" -a $(ArchName)</Arguments>
- <Environment>set DOC_FILENAME=python$(PythonVersion).chm
-set VCREDIST_PATH=$(VS140COMNTOOLS)\..\..\VC\redist\$(Platform)\Microsoft.VC140.CRT</Environment>
+ <Environment>set DOC_FILENAME=python$(PythonVersion).chm</Environment>
+ <Environment Condition="Exists($(CRTRedist))">$(Environment)%0D%0Aset VCREDIST_PATH=$(CRTRedist)\$(Platform)</Environment>
</PropertyGroup>
<Target Name="_Build">
- <Exec Command="setlocal
-$(Environment)
-$(CleanCommand)
-$(Arguments)" />
+ <Exec Command="setlocal%0D%0A$(Environment)%0D%0A$(CleanCommand)%0D%0A$(Arguments)" />
</Target>
<Target Name="AfterBuild" />
EXCLUDE_FROM_LIBRARY = {
'__pycache__',
- 'ensurepip',
'idlelib',
'pydoc_data',
'site-packages',
'tkinter',
'turtledemo',
+}
+
+EXCLUDE_FROM_EMBEDDABLE_LIBRARY = {
+ 'ensurepip',
'venv',
}
suffix = p.suffix.lower()
return suffix not in {'.pyc', '.pyo', '.exe'}
+def include_in_embeddable_lib(p):
+ if p.is_dir() and p.name.lower() in EXCLUDE_FROM_EMBEDDABLE_LIBRARY:
+ return False
+
+ return include_in_lib(p)
+
def include_in_libs(p):
if not is_not_debug(p):
return False
('/', 'PCBuild/$arch', 'python*.exe', is_not_debug),
('/', 'PCBuild/$arch', '*.pyd', is_not_debug),
('/', 'PCBuild/$arch', '*.dll', is_not_debug),
- ('{}.zip'.format(BASE_NAME), 'Lib', '**/*', include_in_lib),
+ ('{}.zip'.format(BASE_NAME), 'Lib', '**/*', include_in_embeddable_lib),
]
if os.getenv('DOC_FILENAME'):
set TARGET=\r
set DRYRUN=false\r
set NOGPG=\r
+set PURGE_OPTION=/p:Purge=true\r
+set NOTEST=\r
\r
:CheckOpts\r
if "%1" EQU "-h" goto Help\r
if "%1" EQU "-t" (set TARGET=%~2) && shift && shift && goto CheckOpts\r
if "%1" EQU "--target" (set TARGET=%~2) && shift && shift && goto CheckOpts\r
if "%1" EQU "--dry-run" (set DRYRUN=true) && shift && goto CheckOpts\r
-if "%1" EQU "--no-gpg" (set NOGPG=true) && shift && goto CheckOpts\r
+if "%1" EQU "--skip-gpg" (set NOGPG=true) && shift && goto CheckOpts\r
+if "%1" EQU "--skip-purge" (set PURGE_OPTION=) && shift && godo CheckOpts\r
+if "%1" EQU "--skip-test" (set NOTEST=true) && shift && godo CheckOpts\r
+if "%1" EQU "-T" (set NOTEST=true) && shift && godo CheckOpts\r
+if "%1" NEQ "" echo Unexpected argument "%1" & exit /B 1\r
\r
if not defined PLINK where plink > "%TEMP%\plink.loc" 2> nul && set /P PLINK= < "%TEMP%\plink.loc" & del "%TEMP%\plink.loc"\r
if not defined PLINK where /R "%ProgramFiles(x86)%\PuTTY" plink > "%TEMP%\plink.loc" 2> nul && set /P PLINK= < "%TEMP%\plink.loc" & del "%TEMP%\plink.loc"\r
\r
if defined NOGPG (\r
set GPG=\r
- echo Skipping GPG signature generation because of --no-gpg\r
+ echo Skipping GPG signature generation because of --skip-gpg\r
) else (\r
if not defined GPG where gpg2 > "%TEMP%\gpg.loc" 2> nul && set /P GPG= < "%TEMP%\gpg.loc" & del "%TEMP%\gpg.loc"\r
if not defined GPG where /R "%PCBUILD%..\externals\windows-installer" gpg2 > "%TEMP%\gpg.loc" 2> nul && set /P GPG= < "%TEMP%\gpg.loc" & del "%TEMP%\gpg.loc"\r
\r
call "%PCBUILD%env.bat" > nul 2> nul\r
pushd "%D%"\r
-msbuild /v:m /nologo uploadrelease.proj /t:Upload /p:Platform=x86\r
-msbuild /v:m /nologo uploadrelease.proj /t:Upload /p:Platform=x64 /p:IncludeDoc=false\r
+msbuild /v:m /nologo uploadrelease.proj /t:Upload /p:Platform=x86 %PURGE_OPTION%\r
+msbuild /v:m /nologo uploadrelease.proj /t:Upload /p:Platform=x64 /p:IncludeDoc=false %PURGE_OPTION%\r
+if not defined NOTEST (\r
+ msbuild /v:m /nologo uploadrelease.proj /t:Test /p:Platform=x86\r
+ msbuild /v:m /nologo uploadrelease.proj /t:Test /p:Platform=x64\r
+)\r
msbuild /v:m /nologo uploadrelease.proj /t:ShowHashes /p:Platform=x86\r
msbuild /v:m /nologo uploadrelease.proj /t:ShowHashes /p:Platform=x64 /p:IncludeDoc=false\r
popd\r
:Help\r
echo uploadrelease.bat --host HOST --user USERNAME [--target TARGET] [--dry-run] [-h]\r
echo.\r
-echo --host (-o) Specify the upload host (required)\r
-echo --user (-u) Specify the user on the host (required)\r
-echo --target (-t) Specify the target directory on the host\r
-echo --dry-run Display commands and filenames without executing them\r
-echo -h Display this help information\r
+echo --host (-o) Specify the upload host (required)\r
+echo --user (-u) Specify the user on the host (required)\r
+echo --target (-t) Specify the target directory on the host\r
+echo --dry-run Display commands and filenames without executing them\r
+echo --skip-gpg Does not generate GPG signatures before uploading\r
+echo --skip-purge Does not perform CDN purge after uploading\r
+echo --skip-test (-T) Does not perform post-upload tests\r
+echo -h Display this help information\r
echo.\r
<DownloadUrlBase Condition="'$(DownloadUrlBase)' == ''">$(TARGET)</DownloadUrlBase>
<DownloadUrlBase Condition="'$(DownloadUrlBase)' == ''">/srv/www.python.org/ftp/python</DownloadUrlBase>
<IncludeDoc Condition="'$(IncludeDoc)' == ''">true</IncludeDoc>
+ <BuildForRelease Condition="'$(BuildForRelease)' == ''">true</BuildForRelease>
<DryRun Condition="'$(DryRun)' == ''">false</DryRun>
+ <Purge Condition="'$(Purge)' == ''">false</Purge>
</PropertyGroup>
<Import Project="msi.props" />
echo." />
</Target>
- <Target Name="Upload" DependsOnTargets="_ValidateProperties;_RunGpg;_PrintNames;_Upload" />
+ <Target Name="_Purge" Condition="$(Purge) and !$(DryRun)">
+ <Error Condition="!Exists('$(PythonExe)')" Text="No Python executable available at $(PythonExe)" />
+ <Exec Command=""$(PythonExe)" purge.py $(PythonVersion)" />
+ </Target>
+
+ <Target Name="_TestLayout">
+ <ItemGroup>
+ <WebInstaller Include="$(OutputPath)\*-webinstall.exe" />
+ <WebInstaller>
+ <SourceDir>$(TEMP)\%(Filename)_source</SourceDir>
+ <SourceExe>$(TEMP)\%(Filename)_source\%(Filename)%(Extension)</SourceExe>
+ <LayoutDir>$(TEMP)\%(Filename)_layout</LayoutDir>
+ <LogDir>$(OutputPath)\%(Filename)_layoutlog</LogDir>
+ <LogFile>$(OutputPath)\%(Filename)_layoutlog\%(Filename).log</LogFile>
+ </WebInstaller>
+ </ItemGroup>
+ <RemoveDir Directories="%(WebInstaller.SourceDir)" Condition="Exists('%(WebInstaller.SourceDir)')" />
+ <RemoveDir Directories="%(WebInstaller.LayoutDir)" Condition="Exists('%(WebInstaller.LayoutDir)')" />
+ <RemoveDir Directories="%(WebInstaller.LogDir)" Condition="Exists('%(WebInstaller.LogDir)')" />
+ <MakeDir Directories="%(WebInstaller.SourceDir)" />
+ <Copy SourceFiles="@(WebInstaller)" DestinationFiles="%(WebInstaller.SourceExe)" />
+ <Exec Command="start "Install test" /wait "%(WebInstaller.SourceExe)" /layout "%(WebInstaller.LayoutDir)" /passive /log "%(WebInstaller.LogFile)""
+ IgnoreExitCode="false" />
+ <RemoveDir Directories="%(WebInstaller.LayoutDir)" />
+ <RemoveDir Directories="%(WebInstaller.SourceDir)" />
+ <RemoveDir Directories="%(WebInstaller.LogDir)" />
+ <Message Text="Successfully downloaded %(WebInstaller.Filename)%(WebInstaller.Extension) layout" Importance="high" />
+ </Target>
+
+ <Target Name="Upload" DependsOnTargets="_ValidateProperties;_RunGpg;_PrintNames;_Upload;_Purge" />
+ <Target Name="Test" DependsOnTargets="_TestLayout" />
<Target Name="ShowHashes">
<ItemGroup>
<NugetArguments>$(NugetArguments) -Version "$(NuspecVersion)"</NugetArguments>
<NugetArguments>$(NugetArguments) -NoPackageAnalysis -NonInteractive</NugetArguments>
- <Environment>setlocal
-set DOC_FILENAME=python$(PythonVersion).chm
-set VCREDIST_PATH=$(VS140COMNTOOLS)\..\..\VC\redist\$(Platform)\Microsoft.VC140.CRT</Environment>
+ <Environment>set DOC_FILENAME=python$(PythonVersion).chm</Environment>
+ <Environment Condition="Exists($(CRTRedist))">$(Environment)%0D%0Aset VCREDIST_PATH=$(CRTRedist)\$(Platform)</Environment>
</PropertyGroup>
<Target Name="_NugetMissing" BeforeTargets="_Build" Condition="!Exists($(Nuget))">
<Target Name="_Build">
<Exec Command="$(CleanCommand)" />
- <Exec Command="$(Environment)
-$(PythonArguments)" />
+ <Exec Command="setlocal%0D%0A$(Environment)%0D%0A$(PythonArguments)" />
<Exec Command="$(PipArguments)" />
<Exec Command="$(PackageArguments)" Condition="$(PackageArguments) != ''" />
<Exec Command="$(NugetArguments)" />
build_vendor
build_cpu
build
-HAS_HG
-HGBRANCH
-HGTAG
-HGVERSION
+HAS_GIT
+GITBRANCH
+GITTAG
+GITVERSION
BASECPPFLAGS
target_alias
host_alias
-if test -e $srcdir/.hg/dirstate
+if test -e $srcdir/.git/HEAD
then
-# Extract the first word of "hg", so it can be a program name with args.
-set dummy hg; ac_word=$2
+# Extract the first word of "git", so it can be a program name with args.
+set dummy git; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_HAS_HG+:} false; then :
+if ${ac_cv_prog_HAS_GIT+:} false; then :
$as_echo_n "(cached) " >&6
else
- if test -n "$HAS_HG"; then
- ac_cv_prog_HAS_HG="$HAS_HG" # Let the user override the test.
+ if test -n "$HAS_GIT"; then
+ ac_cv_prog_HAS_GIT="$HAS_GIT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
- ac_cv_prog_HAS_HG="found"
+ ac_cv_prog_HAS_GIT="found"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
IFS=$as_save_IFS
- test -z "$ac_cv_prog_HAS_HG" && ac_cv_prog_HAS_HG="not-found"
+ test -z "$ac_cv_prog_HAS_GIT" && ac_cv_prog_HAS_GIT="not-found"
fi
fi
-HAS_HG=$ac_cv_prog_HAS_HG
-if test -n "$HAS_HG"; then
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAS_HG" >&5
-$as_echo "$HAS_HG" >&6; }
+HAS_GIT=$ac_cv_prog_HAS_GIT
+if test -n "$HAS_GIT"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAS_GIT" >&5
+$as_echo "$HAS_GIT" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
-HAS_HG=no-repository
+HAS_GIT=no-repository
fi
-if test $HAS_HG = found
+if test $HAS_GIT = found
then
- HGVERSION="hg id -i \$(srcdir)"
- HGTAG="hg id -t \$(srcdir)"
- HGBRANCH="hg id -b \$(srcdir)"
+ GITVERSION="git -C \$(srcdir) rev-parse --short HEAD"
+ GITTAG="git -C \$(srcdir) describe --all --always --dirty"
+ GITBRANCH="git -C \$(srcdir) name-rev --name-only HEAD"
else
- HGVERSION=""
- HGTAG=""
- HGBRANCH=""
+ GITVERSION=""
+ GITTAG=""
+ GITBRANCH=""
fi
# a lot of different things including 'define_xopen_source'
# in the case statement below.
case "$host" in
+ *-*-linux-android*)
+ ac_sys_system=Linux-android
+ ;;
*-*-linux*)
ac_sys_system=Linux
;;
#undef sparc
#undef unix
#if defined(__ANDROID__)
-# if defined(__x86_64__) && defined(__LP64__)
- x86_64-linux-android
-# elif defined(__i386__)
- i686-linux-android
-# elif defined(__aarch64__) && defined(__AARCH64EL__)
-# if defined(__ILP32__)
- aarch64_ilp32-linux-android
-# else
- aarch64-linux-android
-# endif
-# elif defined(__ARM_EABI__) && defined(__ARMEL__)
- arm-linux-androideabi
-# elif defined(__mips_hard_float) && defined(_MIPSEL)
-# if _MIPS_SIM == _ABIO32
- mipsel-linux-android
-# elif _MIPS_SIM == _ABI64
- mips64el-linux-android
-# else
-# error unknown platform triplet
-# endif
-# else
-# error unknown platform triplet
-# endif
+ # Android is not a multiarch system.
#elif defined(__linux__)
# if defined(__x86_64__) && defined(__LP64__)
x86_64-linux-gnu
cat >> conftest.c <<EOF
#ifdef __ANDROID__
#include <android/api-level.h>
-__ANDROID_API__
+android_api = __ANDROID_API__
+arm_arch = __ARM_ARCH
#else
#error not Android
#endif
EOF
if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then
- ANDROID_API_LEVEL=`grep -v '^#' conftest.out | grep -v '^ *$'`
+ ANDROID_API_LEVEL=`sed -n -e '/__ANDROID_API__/d' -e 's/^android_api = //p' conftest.out`
+ _arm_arch=`sed -n -e '/__ARM_ARCH/d' -e 's/^arm_arch = //p' conftest.out`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ANDROID_API_LEVEL" >&5
$as_echo "$ANDROID_API_LEVEL" >&6; }
#define ANDROID_API_LEVEL $ANDROID_API_LEVEL
_ACEOF
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the Android arm ABI" >&5
+$as_echo_n "checking for the Android arm ABI... " >&6; }
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_arm_arch" >&5
+$as_echo "$_arm_arch" >&6; }
+ if test "$_arm_arch" = 7; then
+ BASECFLAGS="${BASECFLAGS} -mfloat-abi=softfp -mfpu=vfpv3-d16"
+ LDFLAGS="${LDFLAGS} -march=armv7-a -Wl,--fix-cortex-a8"
+ fi
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: not Android" >&5
$as_echo "not Android" >&6; }
poll.h sys/devpoll.h sys/epoll.h sys/poll.h \
sys/audioio.h sys/xattr.h sys/bsdtty.h sys/event.h sys/file.h sys/ioctl.h \
sys/kern_control.h sys/loadavg.h sys/lock.h sys/mkdev.h sys/modem.h \
-sys/param.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \
+sys/param.h sys/random.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \
sys/stat.h sys/syscall.h sys/sys_domain.h sys/termio.h sys/time.h \
sys/times.h sys/types.h sys/uio.h sys/un.h sys/utsname.h sys/wait.h pty.h \
libutil.h sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
then CCSHARED="-fPIC";
else CCSHARED="+z";
fi;;
+ Linux-android*) ;;
Linux*|GNU*) CCSHARED="-fPIC";;
BSD/OS*/4*) CCSHARED="-fpic";;
FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
LINKFORSHARED="-Wl,-E -Wl,+s";;
# LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
+ Linux-android*) LINKFORSHARED="-pie -Xlinker -export-dynamic";;
Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
# -u libsys_s pulls in all symbols in libsys
Darwin/*)
futimens futimes gai_strerror getentropy \
getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \
getpriority getresuid getresgid getpwent getspnam getspent getsid getwd \
- if_nameindex \
- initgroups kill killpg lchmod lchown lockf linkat lstat lutimes mmap \
+ initgroups kill killpg lchmod lchown linkat lstat lutimes mmap \
memrchr mbrtowc mkdirat mkfifo \
mkfifoat mknod mknodat mktime mremap nice openat pathconf pause pipe2 plock poll \
posix_fallocate posix_fadvise pread \
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
+# On Android API level 24 with android-ndk-r13, if_nameindex() is available,
+# but the if_nameindex structure is not defined.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for if_nameindex" >&5
+$as_echo_n "checking for if_nameindex... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+#include <stdio.h>
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#ifdef HAVE_NET_IF_H
+# include <net/if.h>
+#endif
+
+int
+main ()
+{
+struct if_nameindex *ni = if_nameindex(); int x = ni[0].if_index;
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+$as_echo "#define HAVE_IF_NAMEINDEX 1" >>confdefs.h
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+
+# Issue #28762: lockf() is available on Android API level 24, but the F_LOCK
+# macro is not defined in android-ndk-r13.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for lockf" >&5
+$as_echo_n "checking for lockf... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#include <unistd.h>
+int
+main ()
+{
+lockf(0, F_LOCK, 0);
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+$as_echo "#define HAVE_LOCKF 1" >>confdefs.h
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+
# On OSF/1 V5.1, getaddrinfo is available, but a define
# for [no]getaddrinfo in netdb.h.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for getaddrinfo" >&5
# first curses header check
ac_save_cppflags="$CPPFLAGS"
-CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
+if test "$cross_compiling" = no; then
+ CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
+fi
for ac_header in curses.h ncurses.h
do :
BASECPPFLAGS=""
fi
-AC_SUBST(HGVERSION)
-AC_SUBST(HGTAG)
-AC_SUBST(HGBRANCH)
+AC_SUBST(GITVERSION)
+AC_SUBST(GITTAG)
+AC_SUBST(GITBRANCH)
-if test -e $srcdir/.hg/dirstate
+if test -e $srcdir/.git/HEAD
then
-AC_CHECK_PROG(HAS_HG, hg, found, not-found)
+AC_CHECK_PROG(HAS_GIT, git, found, not-found)
else
-HAS_HG=no-repository
+HAS_GIT=no-repository
fi
-if test $HAS_HG = found
+if test $HAS_GIT = found
then
- HGVERSION="hg id -i \$(srcdir)"
- HGTAG="hg id -t \$(srcdir)"
- HGBRANCH="hg id -b \$(srcdir)"
+ GITVERSION="git -C \$(srcdir) rev-parse --short HEAD"
+ GITTAG="git -C \$(srcdir) describe --all --always --dirty"
+ GITBRANCH="git -C \$(srcdir) name-rev --name-only HEAD"
else
- HGVERSION=""
- HGTAG=""
- HGBRANCH=""
+ GITVERSION=""
+ GITTAG=""
+ GITBRANCH=""
fi
AC_CONFIG_SRCDIR([Include/object.h])
# a lot of different things including 'define_xopen_source'
# in the case statement below.
case "$host" in
+ *-*-linux-android*)
+ ac_sys_system=Linux-android
+ ;;
*-*-linux*)
ac_sys_system=Linux
;;
#undef sparc
#undef unix
#if defined(__ANDROID__)
-# if defined(__x86_64__) && defined(__LP64__)
- x86_64-linux-android
-# elif defined(__i386__)
- i686-linux-android
-# elif defined(__aarch64__) && defined(__AARCH64EL__)
-# if defined(__ILP32__)
- aarch64_ilp32-linux-android
-# else
- aarch64-linux-android
-# endif
-# elif defined(__ARM_EABI__) && defined(__ARMEL__)
- arm-linux-androideabi
-# elif defined(__mips_hard_float) && defined(_MIPSEL)
-# if _MIPS_SIM == _ABIO32
- mipsel-linux-android
-# elif _MIPS_SIM == _ABI64
- mips64el-linux-android
-# else
-# error unknown platform triplet
-# endif
-# else
-# error unknown platform triplet
-# endif
+ # Android is not a multiarch system.
#elif defined(__linux__)
# if defined(__x86_64__) && defined(__LP64__)
x86_64-linux-gnu
cat >> conftest.c <<EOF
#ifdef __ANDROID__
#include <android/api-level.h>
-__ANDROID_API__
+android_api = __ANDROID_API__
+arm_arch = __ARM_ARCH
#else
#error not Android
#endif
EOF
if $CPP $CPPFLAGS conftest.c >conftest.out 2>/dev/null; then
- ANDROID_API_LEVEL=`grep -v '^#' conftest.out | grep -v '^ *$'`
+ ANDROID_API_LEVEL=`sed -n -e '/__ANDROID_API__/d' -e 's/^android_api = //p' conftest.out`
+ _arm_arch=`sed -n -e '/__ARM_ARCH/d' -e 's/^arm_arch = //p' conftest.out`
AC_MSG_RESULT([$ANDROID_API_LEVEL])
AC_DEFINE_UNQUOTED(ANDROID_API_LEVEL, $ANDROID_API_LEVEL, [The Android API level.])
+
+ AC_MSG_CHECKING([for the Android arm ABI])
+ AC_MSG_RESULT([$_arm_arch])
+ if test "$_arm_arch" = 7; then
+ BASECFLAGS="${BASECFLAGS} -mfloat-abi=softfp -mfpu=vfpv3-d16"
+ LDFLAGS="${LDFLAGS} -march=armv7-a -Wl,--fix-cortex-a8"
+ fi
else
AC_MSG_RESULT([not Android])
fi
poll.h sys/devpoll.h sys/epoll.h sys/poll.h \
sys/audioio.h sys/xattr.h sys/bsdtty.h sys/event.h sys/file.h sys/ioctl.h \
sys/kern_control.h sys/loadavg.h sys/lock.h sys/mkdev.h sys/modem.h \
-sys/param.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \
+sys/param.h sys/random.h sys/select.h sys/sendfile.h sys/socket.h sys/statvfs.h \
sys/stat.h sys/syscall.h sys/sys_domain.h sys/termio.h sys/time.h \
sys/times.h sys/types.h sys/uio.h sys/un.h sys/utsname.h sys/wait.h pty.h \
libutil.h sys/resource.h netpacket/packet.h sysexits.h bluetooth.h \
then CCSHARED="-fPIC";
else CCSHARED="+z";
fi;;
+ Linux-android*) ;;
Linux*|GNU*) CCSHARED="-fPIC";;
BSD/OS*/4*) CCSHARED="-fpic";;
FreeBSD*|NetBSD*|OpenBSD*|DragonFly*) CCSHARED="-fPIC";;
LINKFORSHARED="-Wl,-E -Wl,+s";;
# LINKFORSHARED="-Wl,-E -Wl,+s -Wl,+b\$(BINLIBDEST)/lib-dynload";;
BSD/OS/4*) LINKFORSHARED="-Xlinker -export-dynamic";;
+ Linux-android*) LINKFORSHARED="-pie -Xlinker -export-dynamic";;
Linux*|GNU*) LINKFORSHARED="-Xlinker -export-dynamic";;
# -u libsys_s pulls in all symbols in libsys
Darwin/*)
futimens futimes gai_strerror getentropy \
getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \
getpriority getresuid getresgid getpwent getspnam getspent getsid getwd \
- if_nameindex \
- initgroups kill killpg lchmod lchown lockf linkat lstat lutimes mmap \
+ initgroups kill killpg lchmod lchown linkat lstat lutimes mmap \
memrchr mbrtowc mkdirat mkfifo \
mkfifoat mknod mknodat mktime mremap nice openat pathconf pause pipe2 plock poll \
posix_fallocate posix_fadvise pread \
AC_MSG_RESULT(no)
])
+# On Android API level 24 with android-ndk-r13, if_nameindex() is available,
+# but the if_nameindex structure is not defined.
+AC_MSG_CHECKING(for if_nameindex)
+AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+#include <stdio.h>
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#ifdef HAVE_NET_IF_H
+# include <net/if.h>
+#endif
+]], [[struct if_nameindex *ni = if_nameindex(); int x = ni[0].if_index;]])],
+ [AC_DEFINE(HAVE_IF_NAMEINDEX, 1, Define to 1 if you have the 'if_nameindex' function.)
+ AC_MSG_RESULT(yes)],
+ [AC_MSG_RESULT(no)
+])
+
+# Issue #28762: lockf() is available on Android API level 24, but the F_LOCK
+# macro is not defined in android-ndk-r13.
+AC_MSG_CHECKING(for lockf)
+AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h> ]],[[lockf(0, F_LOCK, 0);]])],
+ [AC_DEFINE(HAVE_LOCKF, 1, Define to 1 if you have the 'lockf' function and the F_LOCK macro.)
+ AC_MSG_RESULT(yes)],
+ [AC_MSG_RESULT(no)
+])
+
# On OSF/1 V5.1, getaddrinfo is available, but a define
# for [no]getaddrinfo in netdb.h.
AC_MSG_CHECKING(for getaddrinfo)
# first curses header check
ac_save_cppflags="$CPPFLAGS"
-CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
+if test "$cross_compiling" = no; then
+ CPPFLAGS="$CPPFLAGS -I/usr/include/ncursesw"
+fi
AC_CHECK_HEADERS(curses.h ncurses.h)
/* Define to 1 if you have the <ieeefp.h> header file. */
#undef HAVE_IEEEFP_H
-/* Define to 1 if you have the `if_nameindex' function. */
+/* Define to 1 if you have the 'if_nameindex' function. */
#undef HAVE_IF_NAMEINDEX
/* Define if you have the 'inet_aton' function. */
/* Define to 1 if you have the <linux/tipc.h> header file. */
#undef HAVE_LINUX_TIPC_H
-/* Define to 1 if you have the `lockf' function. */
+/* Define to 1 if you have the 'lockf' function and the F_LOCK macro. */
#undef HAVE_LOCKF
/* Define to 1 if you have the `log1p' function. */
/* Define to 1 if you have the <sys/poll.h> header file. */
#undef HAVE_SYS_POLL_H
+/* Define to 1 if you have the <sys/random.h> header file. */
+#undef HAVE_SYS_RANDOM_H
+
/* Define to 1 if you have the <sys/resource.h> header file. */
#undef HAVE_SYS_RESOURCE_H
for directory in reversed(options.dirs):
add_dir_to_list(dir_list, directory)
- if os.path.normpath(sys.base_prefix) != '/usr' \
- and not sysconfig.get_config_var('PYTHONFRAMEWORK'):
+ if (not cross_compiling and
+ os.path.normpath(sys.base_prefix) != '/usr' and
+ not sysconfig.get_config_var('PYTHONFRAMEWORK')):
# OSX note: Don't add LIBDIR and INCLUDEDIR to building a framework
# (PYTHONFRAMEWORK is set) to avoid # linking problems when
# building a framework with different architectures than
panel_library = 'panel'
if curses_library == 'ncursesw':
curses_defines.append(('HAVE_NCURSESW', '1'))
- curses_includes.append('/usr/include/ncursesw')
+ if not cross_compiling:
+ curses_includes.append('/usr/include/ncursesw')
# Bug 1464056: If _curses.so links with ncursesw,
# _curses_panel.so must link with panelw.
panel_library = 'panelw'
## ext = Extension('xx', ['xxmodule.c'])
## self.extensions.append(ext)
- if 'd' not in sys.abiflags:
+ if 'd' not in sysconfig.get_config_var('ABIFLAGS'):
ext = Extension('xxlimited', ['xxlimited.c'],
define_macros=[('Py_LIMITED_API', '0x03050000')])
self.extensions.append(ext)
'Modules',
'_decimal',
'libmpdec'))]
- libraries = []
+ libraries = self.detect_math_libs()
sources = [
'_decimal/_decimal.c',
'_decimal/libmpdec/basearith.c',
projects / platform / upstream / python3.git / commitdiff