{"action":"created","issue":{"url":"https://api.github.com/repos/melvin15may/ssdedupe/issues/41","repository_url":"https://api.github.com/repos/melvin15may/ssdedupe","labels_url":"https://api.github.com/repos/melvin15may/ssdedupe/issues/41/labels{/name}","comments_url":"https://api.github.com/repos/melvin15may/ssdedupe/issues/41/comments","events_url":"https://api.github.com/repos/melvin15may/ssdedupe/issues/41/events","html_url":"https://github.com/melvin15may/ssdedupe/pull/41","id":308615110,"number":41,"title":"Scheduled weekly dependency update for week 12","user":{"login":"pyup-bot","id":16239342,"avatar_url":"https://avatars0.githubusercontent.com/u/16239342?v=4","gravatar_id":"","url":"https://api.github.com/users/pyup-bot","html_url":"https://github.com/pyup-bot","followers_url":"https://api.github.com/users/pyup-bot/followers","following_url":"https://api.github.com/users/pyup-bot/following{/other_user}","gists_url":"https://api.github.com/users/pyup-bot/gists{/gist_id}","starred_url":"https://api.github.com/users/pyup-bot/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/pyup-bot/subscriptions","organizations_url":"https://api.github.com/users/pyup-bot/orgs","repos_url":"https://api.github.com/users/pyup-bot/repos","events_url":"https://api.github.com/users/pyup-bot/events{/privacy}","received_events_url":"https://api.github.com/users/pyup-bot/received_events","type":"User","site_admin":false},"labels":[],"state":"open","locked":false,"assignee":null,"assignees":[],"milestone":null,"comments":0,"created_at":"2018-03-26T15:13:33Z","updated_at":"2018-04-02T15:12:37Z","closed_at":null,"author_association":"COLLABORATOR","pull_request":{"url":"https://api.github.com/repos/melvin15may/ssdedupe/pulls/41","html_url":"https://github.com/melvin15may/ssdedupe/pull/41","diff_url":"https://github.com/melvin15may/ssdedupe/pull/41.diff","patch_url":"https://github.com/melvin15may/ssdedupe/pull/41.patch"},"body":"\n\n\n\n\n### Update [numpy](https://pypi.python.org/pypi/numpy) from **1.13.1** to **1.14.2**.\n\n\n<details>\n  <summary>Changelog</summary>\n  \n  \n   ### 1.14.1\n   ```\n   ==========================\n\nThis is a bugfix release for some problems reported following the 1.14.0 release. The major\nproblems fixed are the following.\n\n* Problems with the new array printing, particularly the printing of complex\n  values, Please report any additional problems that may turn up.\n* Problems with ``np.einsum`` due to the new ``optimized=True`` default. Some\n  fixes for optimization have been applied and ``optimize=False`` is now the\n  default.\n* The sort order in ``np.unique`` when ``axis=&lt;some-number&gt;`` will now always\n  be lexicographic in the subarray elements. In previous NumPy versions there\n  was an optimization that could result in sorting the subarrays as unsigned\n  byte strings.\n* The change in 1.14.0 that multi-field indexing of structured arrays returns a\n  view instead of a copy has been reverted but remains on track for NumPy 1.15.\n  Affected users should read the 1.14.1 Numpy User Guide section\n  &quot;basics/structured arrays/accessing multiple fields&quot; for advice on how to\n  manage this transition.\n\nThe Python versions supported in this release are 2.7 and 3.4 - 3.6. The Python\n3.6 wheels available from PIP are built with Python 3.6.2 and should be\ncompatible with all previous versions of Python 3.6. The source releases were\ncythonized with Cython 0.26.1, which is known to **not** support the upcoming\nPython 3.7 release.  People who wish to run Python 3.7 should check out the\nNumPy repo and try building with the, as yet, unreleased master branch of\nCython.\n\nContributors\n============\n\nA total of 14 people contributed to this release.  People with a &quot;+&quot; by their\nnames contributed a patch for the first time.\n\n* Allan Haldane\n* Charles Harris\n* Daniel Smith\n* Dennis Weyland +\n* Eric Larson\n* Eric Wieser\n* Jarrod Millman\n* Kenichi Maehashi +\n* Marten van Kerkwijk\n* Mathieu Lamarre\n* Sebastian Berg\n* Simon Conseil\n* Simon Gibbons\n* xoviat\n\nPull requests merged\n====================\n\nA total of 36 pull requests were merged for this release.\n\n* `10339 &lt;https://github.com/numpy/numpy/pull/10339&gt;`__: BUG: restrict the __config__ modifications to win32\n* `10368 &lt;https://github.com/numpy/numpy/pull/10368&gt;`__: MAINT: Adjust type promotion in linalg.norm\n* `10375 &lt;https://github.com/numpy/numpy/pull/10375&gt;`__: BUG: add missing paren and remove quotes from repr of fieldless...\n* `10395 &lt;https://github.com/numpy/numpy/pull/10395&gt;`__: MAINT: Update download URL in setup.py.\n* `10396 &lt;https://github.com/numpy/numpy/pull/10396&gt;`__: BUG: fix einsum issue with unicode input and py2\n* `10397 &lt;https://github.com/numpy/numpy/pull/10397&gt;`__: BUG: fix error message not formatted in einsum\n* `10398 &lt;https://github.com/numpy/numpy/pull/10398&gt;`__: DOC: add documentation about how to handle new array printing\n* `10403 &lt;https://github.com/numpy/numpy/pull/10403&gt;`__: BUG: Set einsum optimize parameter default to `False`.\n* `10424 &lt;https://github.com/numpy/numpy/pull/10424&gt;`__: ENH: Fix repr of np.record objects to match np.void types 10412\n* `10425 &lt;https://github.com/numpy/numpy/pull/10425&gt;`__: MAINT: Update zesty to artful for i386 testing\n* `10431 &lt;https://github.com/numpy/numpy/pull/10431&gt;`__: REL: Add 1.14.1 release notes template\n* `10435 &lt;https://github.com/numpy/numpy/pull/10435&gt;`__: MAINT: Use ValueError for duplicate field names in lookup (backport)\n* `10534 &lt;https://github.com/numpy/numpy/pull/10534&gt;`__: BUG: Provide a better error message for out-of-order fields\n* `10536 &lt;https://github.com/numpy/numpy/pull/10536&gt;`__: BUG: Resize bytes_ columns in genfromtxt (backport of 10401)\n* `10537 &lt;https://github.com/numpy/numpy/pull/10537&gt;`__: BUG: multifield-indexing adds padding bytes: revert for 1.14.1\n* `10539 &lt;https://github.com/numpy/numpy/pull/10539&gt;`__: BUG: fix np.save issue with python 2.7.5\n* `10540 &lt;https://github.com/numpy/numpy/pull/10540&gt;`__: BUG: Add missing DECREF in Py2 int() cast\n* `10541 &lt;https://github.com/numpy/numpy/pull/10541&gt;`__: TST: Add circleci document testing to maintenance/1.14.x\n* `10542 &lt;https://github.com/numpy/numpy/pull/10542&gt;`__: BUG: complex repr has extra spaces, missing + (1.14 backport)\n* `10550 &lt;https://github.com/numpy/numpy/pull/10550&gt;`__: BUG: Set missing exception after malloc\n* `10557 &lt;https://github.com/numpy/numpy/pull/10557&gt;`__: BUG: In numpy.i, clear CARRAY flag if wrapped buffer is not C_CONTIGUOUS.\n* `10558 &lt;https://github.com/numpy/numpy/pull/10558&gt;`__: DEP: Issue FutureWarning when malformed records detected.\n* `10559 &lt;https://github.com/numpy/numpy/pull/10559&gt;`__: BUG: Fix einsum optimize logic for singleton dimensions\n* `10560 &lt;https://github.com/numpy/numpy/pull/10560&gt;`__: BUG: Fix calling ufuncs with a positional output argument.\n* `10561 &lt;https://github.com/numpy/numpy/pull/10561&gt;`__: BUG: Fix various Big-Endian test failures (ppc64)\n* `10562 &lt;https://github.com/numpy/numpy/pull/10562&gt;`__: BUG: Make dtype.descr error for out-of-order fields.\n* `10563 &lt;https://github.com/numpy/numpy/pull/10563&gt;`__: BUG: arrays not being flattened in `union1d`\n* `10607 &lt;https://github.com/numpy/numpy/pull/10607&gt;`__: MAINT: Update sphinxext submodule hash.\n* `10608 &lt;https://github.com/numpy/numpy/pull/10608&gt;`__: BUG: Revert sort optimization in np.unique.\n* `10609 &lt;https://github.com/numpy/numpy/pull/10609&gt;`__: BUG: infinite recursion in str of 0d subclasses\n* `10610 &lt;https://github.com/numpy/numpy/pull/10610&gt;`__: BUG: Align type definition with generated lapack\n* `10612 &lt;https://github.com/numpy/numpy/pull/10612&gt;`__: BUG/ENH: Improve output for structured non-void types\n* `10622 &lt;https://github.com/numpy/numpy/pull/10622&gt;`__: BUG: deallocate recursive closure in arrayprint.py (1.14 backport)\n* `10624 &lt;https://github.com/numpy/numpy/pull/10624&gt;`__: BUG: Correctly identify comma separated dtype strings\n* `10629 &lt;https://github.com/numpy/numpy/pull/10629&gt;`__: BUG: deallocate recursive closure in arrayprint.py (backport...\n* `10630 &lt;https://github.com/numpy/numpy/pull/10630&gt;`__: REL: Prepare for 1.14.1 release.\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.14.0\n   ```\n   ==========================\n\nNumpy 1.14.0 is the result of seven months of work and contains a large number\nof bug fixes and new features, along with several changes with potential\ncompatibility issues. The major change that users will notice are the\nstylistic changes in the way numpy arrays and scalars are printed, a change\nthat will affect doctests. See below for details on how to preserve the\nold style printing when needed.\n\nA major decision affecting future development concerns the schedule for\ndropping Python 2.7 support in the runup to 2020. The decision has been made to\nsupport 2.7 for all releases made in 2018, with the last release being\ndesignated a long term release with support for bug fixes extending through\n2019. In 2019 support for 2.7 will be dropped in all new releases. More details\ncan be found in the relevant NEP_.\n\nThis release supports Python 2.7 and 3.4 - 3.6.\n\n.. _NEP: https://github.com/numpy/numpy/blob/master/doc/neps/dropping-python2.7-proposal.rst\n\n\nHighlights\n==========\n\n* The `np.einsum` function uses BLAS when possible\n\n* ``genfromtxt``, ``loadtxt``, ``fromregex`` and ``savetxt`` can now handle\n  files with arbitrary Python supported encoding.\n\n* Major improvements to printing of NumPy arrays and scalars.\n\n\nNew functions\n=============\n\n* ``parametrize``: decorator added to numpy.testing\n\n* ``chebinterpolate``: Interpolate function at Chebyshev points.\n\n* ``format_float_positional`` and ``format_float_scientific`` : format\n  floating-point scalars unambiguously with control of rounding and padding.\n\n* ``PyArray_ResolveWritebackIfCopy`` and ``PyArray_SetWritebackIfCopyBase``,\n  new C-API functions useful in achieving PyPy compatibity.\n\n\nDeprecations\n============\n\n* Using ``np.bool_`` objects in place of integers is deprecated.  Previously\n  ``operator.index(np.bool_)`` was legal and allowed constructs such as\n  ``[1, 2, 3][np.True_]``. That was misleading, as it behaved differently from\n  ``np.array([1, 2, 3])[np.True_]``.\n\n* Truth testing of an empty array is deprecated. To check if an array is not\n  empty, use ``array.size &gt; 0``.\n\n* Calling ``np.bincount`` with ``minlength=None`` is deprecated.\n  ``minlength=0`` should be used instead.\n\n* Calling ``np.fromstring`` with the default value of the ``sep`` argument is\n  deprecated.  When that argument is not provided, a broken version of\n  ``np.frombuffer`` is used that silently accepts unicode strings and -- after\n  encoding them as either utf-8 (python 3) or the default encoding\n  (python 2) -- treats them as binary data. If reading binary data is\n  desired, ``np.frombuffer`` should be used directly.\n\n* The ``style`` option of array2string is deprecated in non-legacy printing mode.\n\n* ``PyArray_SetUpdateIfCopyBase`` has been deprecated. For NumPy versions &gt;= 1.14\n  use ``PyArray_SetWritebackIfCopyBase`` instead, see `C API changes` below for\n  more details.\n\n\n\n* The use of ``UPDATEIFCOPY`` arrays is deprecated, see  `C API changes` below\n  for details.  We will not be dropping support for those arrays, but they are\n  not compatible with PyPy.\n\n\nFuture Changes\n==============\n\n* ``np.issubdtype`` will stop downcasting dtype-like arguments.\n  It might be expected that ``issubdtype(np.float32, &#39;float64&#39;)`` and\n  ``issubdtype(np.float32, np.float64)`` mean the same thing - however, there\n  was an undocumented special case that translated the former into\n  ``issubdtype(np.float32, np.floating)``, giving the surprising result of True.\n\n  This translation now gives a warning that explains what translation is\n  occurring.  In the future, the translation will be disabled, and the first\n  example will be made equivalent to the second.\n\n* ``np.linalg.lstsq`` default for ``rcond`` will be changed.  The ``rcond``\n  parameter to ``np.linalg.lstsq`` will change its default to machine precision\n  times the largest of the input array dimensions. A FutureWarning is issued\n  when ``rcond`` is not passed explicitly.\n\n* ``a.flat.__array__()`` will return a writeable copy of ``a`` when ``a`` is\n  non-contiguous.  Previously it returned an UPDATEIFCOPY array when ``a`` was\n  writeable. Currently it returns a non-writeable copy. See gh-7054 for a\n  discussion of the issue.\n\n* Unstructured void array&#39;s ``.item`` method will return a bytes object. In the\n  future, calling ``.item()`` on arrays or scalars of ``np.void`` datatype will\n  return a ``bytes`` object instead of a buffer or int array, the same as\n  returned by ``bytes(void_scalar)``. This may affect code which assumed the\n  return value was mutable, which will no longer be the case. A\n  ``FutureWarning`` is now issued when this would occur.\n\n\nCompatibility notes\n===================\n\nThe mask of a masked array view is also a view rather than a copy\n-----------------------------------------------------------------\nThere was a FutureWarning about this change in NumPy 1.11.x. In short, it is\nnow the case that, when changing a view of a masked array, changes to the mask\nare propagated to the original. That was not previously the case. This change\naffects slices in particular. Note that this does not yet work properly if the\nmask of the original array is ``nomask`` and the mask of the view is changed.\nSee gh-5580 for an extended discussion. The original behavior of having a copy\nof the mask can be obtained by calling the ``unshare_mask`` method of the view.\n\n``np.ma.masked`` is no longer writeable\n---------------------------------------\nAttempts to mutate the ``masked`` constant now error, as the underlying arrays\nare marked readonly. In the past, it was possible to get away with::\n\n     emulating a function that sometimes returns np.ma.masked\n    val = random.choice([np.ma.masked, 10])\n    var_arr = np.asarray(val)\n    val_arr += 1   now errors, previously changed np.ma.masked.data\n\n``np.ma`` functions producing ``fill_value``s have changed\n----------------------------------------------------------\nPreviously, ``np.ma.default_fill_value`` would return a 0d array, but\n``np.ma.minimum_fill_value`` and ``np.ma.maximum_fill_value`` would return a\ntuple of the fields. Instead, all three methods return a structured ``np.void``\nobject, which is what you would already find in the ``.fill_value`` attribute.\n\nAdditionally, the dtype guessing now matches that of ``np.array`` - so when\npassing a python scalar ``x``, ``maximum_fill_value(x)`` is always the same as\n``maximum_fill_value(np.array(x))``. Previously ``x = long(1)`` on Python 2\nviolated this assumption.\n\n``a.flat.__array__()`` returns non-writeable arrays when ``a`` is non-contiguous\n--------------------------------------------------------------------------------\nThe intent is that the UPDATEIFCOPY array previously returned when ``a`` was\nnon-contiguous will be replaced by a writeable copy in the future. This\ntemporary measure is aimed to notify folks who expect the underlying array be\nmodified in this situation that that will no longer be the case. The most\nlikely places for this to be noticed is when expressions of the form\n``np.asarray(a.flat)`` are used, or when ``a.flat`` is passed as the out\nparameter to a ufunc.\n\n``np.tensordot`` now returns zero array when contracting over 0-length dimension\n--------------------------------------------------------------------------------\nPreviously ``np.tensordot`` raised a ValueError when contracting over 0-length\ndimension. Now it returns a zero array, which is consistent with the behaviour\nof ``np.dot`` and ``np.einsum``.\n\n``numpy.testing`` reorganized\n-----------------------------\nThis is not expected to cause problems, but possibly something has been left\nout. If you experience an unexpected import problem using ``numpy.testing``\nlet us know.\n\n``np.asfarray`` no longer accepts non-dtypes through the ``dtype`` argument\n---------------------------------------------------------------------------\nThis previously would accept ``dtype=some_array``, with the implied semantics\nof ``dtype=some_array.dtype``. This was undocumented, unique across the numpy\nfunctions, and if used would likely correspond to a typo.\n\n1D ``np.linalg.norm`` preserves float input types, even for arbitrary orders\n----------------------------------------------------------------------------\nPreviously, this would promote to ``float64`` when arbitrary orders were\npassed, despite not doing so under the simple cases::\n\n    &gt;&gt;&gt; f32 = np.float32([[1, 2]])\n    &gt;&gt;&gt; np.linalg.norm(f32, 2.0, axis=-1).dtype\n    dtype(&#39;float32&#39;)\n    &gt;&gt;&gt; np.linalg.norm(f32, 2.0001, axis=-1).dtype\n    dtype(&#39;float64&#39;)   numpy 1.13\n    dtype(&#39;float32&#39;)   numpy 1.14\n\nThis change affects only ``float32`` and ``float16`` arrays.\n\n``count_nonzero(arr, axis=())`` now counts over no axes, not all axes\n---------------------------------------------------------------------\nElsewhere, ``axis==()`` is always understood as &quot;no axes&quot;, but\n`count_nonzero` had a special case to treat this as &quot;all axes&quot;. This was\ninconsistent and surprising. The correct way to count over all axes has always\nbeen to pass ``axis == None``.\n\n``__init__.py`` files added to test directories\n-----------------------------------------------\nThis is for pytest compatibility in the case of duplicate test file names in\nthe different directories. As a result, ``run_module_suite`` no longer works,\ni.e., ``python &lt;path-to-test-file&gt;`` results in an error.\n\n``.astype(bool)`` on unstructured void arrays now calls ``bool`` on each element\n--------------------------------------------------------------------------------\nOn Python 2, ``void_array.astype(bool)`` would always return an array of\n``True``, unless the dtype is ``V0``. On Python 3, this operation would usually\ncrash. Going forwards, `astype` matches the behavior of ``bool(np.void)``,\nconsidering a buffer of all zeros as false, and anything else as true.\nChecks for ``V0`` can still be done with ``arr.dtype.itemsize == 0``.\n\n``MaskedArray.squeeze`` never returns ``np.ma.masked``\n------------------------------------------------------\n``np.squeeze`` is documented as returning a view, but the masked variant would\nsometimes return ``masked``, which is not a view. This has been fixed, so that\nthe result is always a view on the original masked array.\nThis breaks any code that used ``masked_arr.squeeze() is np.ma.masked``, but\nfixes code that writes to the result of `.squeeze()`.\n\nRenamed first parameter of ``can_cast`` from ``from`` to ``from_``\n------------------------------------------------------------------\nThe previous parameter name ``from`` is a reserved keyword in Python, which made\nit difficult to pass the argument by name. This has been fixed by renaming\nthe parameter to ``from_``.\n\n``isnat`` raises ``TypeError`` when passed wrong type\n------------------------------------------------------\nThe ufunc ``isnat`` used to raise a ``ValueError`` when it was not passed\nvariables of type ``datetime`` or ``timedelta``. This has been changed to\nraising a ``TypeError``.\n\n``dtype.__getitem__`` raises ``TypeError`` when passed wrong type\n-----------------------------------------------------------------\nWhen indexed with a float, the dtype object used to raise ``ValueError``.\n\nUser-defined types now need to implement ``__str__`` and ``__repr__``\n---------------------------------------------------------------------\nPreviously, user-defined types could fall back to a default implementation of\n``__str__`` and ``__repr__`` implemented in numpy, but this has now been\nremoved. Now user-defined types will fall back to the python default\n``object.__str__`` and ``object.__repr__``.\n\nMany changes to array printing, disableable with the new &quot;legacy&quot; printing mode\n-------------------------------------------------------------------------------\nThe ``str`` and ``repr`` of ndarrays and numpy scalars have been changed in\na variety of ways. These changes are likely to break downstream user&#39;s\ndoctests.\n\nThese new behaviors can be disabled to mostly reproduce numpy 1.13 behavior by\nenabling the new 1.13 &quot;legacy&quot; printing mode. This is enabled by calling\n``np.set_printoptions(legacy=&quot;1.13&quot;)``, or using the new ``legacy`` argument to\n``np.array2string``, as ``np.array2string(arr, legacy=&#39;1.13&#39;)``.\n\nIn summary, the major changes are:\n\n* For floating-point types:\n\n  * The ``repr`` of float arrays often omits a space previously printed\n    in the sign position. See the new ``sign`` option to ``np.set_printoptions``.\n  * Floating-point arrays and scalars use a new algorithm for decimal\n    representations, giving the shortest unique representation. This will\n    usually shorten ``float16`` fractional output, and sometimes ``float32`` and\n    ``float128`` output. ``float64`` should be unaffected.  See the new\n    ``floatmode`` option to ``np.set_printoptions``.\n  * Float arrays printed in scientific notation no longer use fixed-precision,\n    and now instead show the shortest unique representation.\n  * The ``str`` of floating-point scalars is no longer truncated in python2.\n\n* For other data types:\n\n  * Non-finite complex scalars print like ``nanj`` instead of ``nan*j``.\n  * ``NaT`` values in datetime arrays are now properly aligned.\n  * Arrays and scalars of ``np.void`` datatype are now printed using hex\n    notation.\n\n* For line-wrapping:\n\n  * The &quot;dtype&quot; part of ndarray reprs will now be printed on the next line\n    if there isn&#39;t space on the last line of array output.\n  * The ``linewidth`` format option is now always respected.\n    The `repr` or `str` of an array will never exceed this, unless a single\n    element is too wide.\n  * The last line of an array string will never have more elements than earlier\n    lines.\n  * An extra space is no longer inserted on the first line if the elements are\n    too wide.\n\n* For summarization (the use of ``...`` to shorten long arrays):\n\n  * A trailing comma is no longer inserted for ``str``.\n    Previously, ``str(np.arange(1001))`` gave\n    ``&#39;[   0    1    2 ...,  998  999 1000]&#39;``, which has an extra comma.\n  * For arrays of 2-D and beyond, when ``...`` is printed on its own line in\n    order to summarize any but the last axis, newlines are now appended to that\n    line to match its leading newlines and a trailing space character is\n    removed.\n\n* ``MaskedArray`` arrays now separate printed elements with commas, always\n  print the dtype, and correctly wrap the elements of long arrays to multiple\n  lines. If there is more than 1 dimension, the array attributes are now\n  printed in a new &quot;left-justified&quot; printing style.\n* ``recarray`` arrays no longer print a trailing space before their dtype, and\n  wrap to the right number of columns.\n* 0d arrays no longer have their own idiosyncratic implementations of ``str``\n  and ``repr``. The ``style`` argument to ``np.array2string`` is deprecated.\n* Arrays of ``bool`` datatype will omit the datatype in the ``repr``.\n* User-defined ``dtypes`` (subclasses of ``np.generic``) now need to\n  implement ``__str__`` and ``__repr__``.\n\nSome of these changes are described in more detail below. If you need to retain\nthe previous behavior for doctests or other reasons, you may want to do\nsomething like::\n\n     FIXME: We need the str/repr formatting used in Numpy &lt; 1.14.\n    try:\n        np.set_printoptions(legacy=&#39;1.13&#39;)\n    except TypeError:\n        pass\n\n\nC API changes\n=============\n\nPyPy compatible alternative to ``UPDATEIFCOPY`` arrays\n------------------------------------------------------\n``UPDATEIFCOPY`` arrays are contiguous copies of existing arrays, possibly with\ndifferent dimensions, whose contents are copied back to the original array when\ntheir refcount goes to zero and they are deallocated. Because PyPy does not use\nrefcounts, they do not function correctly with PyPy. NumPy is in the process of\neliminating their use internally and two new C-API functions,\n\n* ``PyArray_SetWritebackIfCopyBase``\n* ``PyArray_ResolveWritebackIfCopy``,\n\nhave been added together with a complimentary flag,\n``NPY_ARRAY_WRITEBACKIFCOPY``. Using the new functionality also requires that\nsome flags be changed when new arrays are created, to wit:\n``NPY_ARRAY_INOUT_ARRAY`` should be replaced by ``NPY_ARRAY_INOUT_ARRAY2`` and\n``NPY_ARRAY_INOUT_FARRAY`` should be replaced by ``NPY_ARRAY_INOUT_FARRAY2``.\nArrays created with these new flags will then have the ``WRITEBACKIFCOPY``\nsemantics.\n\nIf PyPy compatibility is not a concern, these new functions can be ignored,\nalthough there will be a ``DeprecationWarning``. If you do wish to pursue PyPy\ncompatibility, more information on these functions and their use may be found\nin the c-api_ documentation and the example in how-to-extend_.\n\n.. _c-api: https://github.com/numpy/numpy/blob/master/doc/source/reference/c-api.array.rst\n.. _how-to-extend: https://github.com/numpy/numpy/blob/master/doc/source/user/c-info.how-to-extend.rst\n\n\nNew Features\n============\n\nEncoding argument for text IO functions\n---------------------------------------\n``genfromtxt``, ``loadtxt``, ``fromregex`` and ``savetxt`` can now handle files\nwith arbitrary encoding supported by Python via the encoding argument.\nFor backward compatibility the argument defaults to the special ``bytes`` value\nwhich continues to treat text as raw byte values and continues to pass latin1\nencoded bytes to custom converters.\nUsing any other value (including ``None`` for system default) will switch the\nfunctions to real text IO so one receives unicode strings instead of bytes in\nthe resulting arrays.\n\nExternal ``nose`` plugins are usable by ``numpy.testing.Tester``\n----------------------------------------------------------------\n``numpy.testing.Tester`` is now aware of ``nose`` plugins that are outside the\n``nose`` built-in ones.  This allows using, for example, ``nose-timer`` like\nso:  ``np.test(extra_argv=[&#39;--with-timer&#39;, &#39;--timer-top-n&#39;, &#39;20&#39;])`` to\nobtain the runtime of the 20 slowest tests.  An extra keyword ``timer`` was\nalso added to ``Tester.test``, so ``np.test(timer=20)`` will also report the 20\nslowest tests.\n\n``parametrize`` decorator added to ``numpy.testing``\n----------------------------------------------------\nA basic ``parametrize`` decorator is now available in ``numpy.testing``. It is\nintended to allow rewriting yield based tests that have been deprecated in\npytest so as to facilitate the transition to pytest in the future. The nose\ntesting framework has not been supported for several years and looks like\nabandonware.\n\nThe new ``parametrize`` decorator does not have the full functionality of the\none in pytest. It doesn&#39;t work for classes, doesn&#39;t support nesting, and does\nnot substitute variable names. Even so, it should be adequate to rewrite the\nNumPy tests.\n\n``chebinterpolate`` function added to ``numpy.polynomial.chebyshev``\n--------------------------------------------------------------------\nThe new ``chebinterpolate`` function interpolates a given function at the\nChebyshev points of the first kind. A new ``Chebyshev.interpolate`` class\nmethod adds support for interpolation over arbitrary intervals using the scaled\nand shifted Chebyshev points of the first kind.\n\nSupport for reading lzma compressed text files in Python 3\n----------------------------------------------------------\nWith Python versions containing the ``lzma`` module the text IO functions can\nnow transparently read from files with ``xz`` or ``lzma`` extension.\n\n``sign`` option added to ``np.setprintoptions`` and ``np.array2string``\n-----------------------------------------------------------------------\nThis option controls printing of the sign of floating-point types, and may be\none of the characters &#39;-&#39;, &#39;+&#39; or &#39; &#39;. With &#39;+&#39; numpy always prints the sign of\npositive values, with &#39; &#39; it always prints a space (whitespace character) in\nthe sign position of positive values, and with &#39;-&#39; it will omit the sign\ncharacter for positive values. The new default is &#39;-&#39;.\n\nThis new default changes the float output relative to numpy 1.13. The old\nbehavior can be obtained in 1.13 &quot;legacy&quot; printing mode, see compatibility\nnotes above.\n\n``hermitian`` option added to``np.linalg.matrix_rank``\n------------------------------------------------------\nThe new ``hermitian`` option allows choosing between standard SVD based matrix\nrank calculation and the more efficient eigenvalue based method for\nsymmetric/hermitian matrices.\n\n``threshold`` and ``edgeitems`` options added to ``np.array2string``\n--------------------------------------------------------------------\nThese options could previously be controlled using ``np.set_printoptions``, but\nnow can be changed on a per-call basis as arguments to ``np.array2string``.\n\n``concatenate`` and ``stack`` gained an ``out`` argument\n--------------------------------------------------------\nA preallocated buffer of the desired dtype can now be used for the output of\nthese functions.\n\nSupport for PGI flang compiler on Windows\n-----------------------------------------\nThe PGI flang compiler is a Fortran front end for LLVM released by NVIDIA under\nthe Apache 2 license. It can be invoked by ::\n\n    python setup.py config --compiler=clang --fcompiler=flang install\n\nThere is little experience with this new compiler, so any feedback from people\nusing it will be appreciated.\n\n\nImprovements\n============\n\nNumerator degrees of freedom in ``random.noncentral_f`` need only be positive.\n------------------------------------------------------------------------------\nPrior to NumPy 1.14.0, the numerator degrees of freedom needed to be &gt; 1, but\nthe distribution is valid for values &gt; 0, which is the new requirement.\n\nThe GIL is released for all ``np.einsum`` variations\n----------------------------------------------------\nSome specific loop structures which have an accelerated loop version\ndid not release the GIL prior to NumPy 1.14.0.  This oversight has been\nfixed.\n\nThe `np.einsum` function will use BLAS when possible and optimize by default\n----------------------------------------------------------------------------\nThe ``np.einsum`` function will now call ``np.tensordot`` when appropriate.\nBecause ``np.tensordot`` uses BLAS when possible, that will speed up execution.\nBy default, ``np.einsum`` will also attempt optimization as the overhead is\nsmall relative to the potential improvement in speed.\n\n``f2py`` now handles arrays of dimension 0\n------------------------------------------\n``f2py`` now allows for the allocation of arrays of dimension 0. This allows\nfor more consistent handling of corner cases downstream.\n\n``numpy.distutils`` supports using MSVC and mingw64-gfortran together\n---------------------------------------------------------------------\nNumpy distutils now supports using Mingw64 gfortran and MSVC compilers\ntogether. This enables the production of Python extension modules on Windows\ncontaining Fortran code while retaining compatibility with the\nbinaries distributed by Python.org. Not all use cases are supported,\nbut most common ways to wrap Fortran for Python are functional.\n\nCompilation in this mode is usually enabled automatically, and can be\nselected via the ``--fcompiler`` and ``--compiler`` options to\n``setup.py``. Moreover, linking Fortran codes to static OpenBLAS is\nsupported; by default a gfortran compatible static archive\n``openblas.a`` is looked for.\n\n``np.linalg.pinv`` now works on stacked matrices\n------------------------------------------------\nPreviously it was limited to a single 2d array.\n\n``numpy.save`` aligns data to 64 bytes instead of 16\n----------------------------------------------------\nSaving NumPy arrays in the ``npy`` format with ``numpy.save`` inserts\npadding before the array data to align it at 64 bytes.  Previously\nthis was only 16 bytes (and sometimes less due to a bug in the code\nfor version 2).  Now the alignment is 64 bytes, which matches the\nwidest SIMD instruction set commonly available, and is also the most\ncommon cache line size.  This makes ``npy`` files easier to use in\nprograms which open them with ``mmap``, especially on Linux where an\n``mmap`` offset must be a multiple of the page size.\n\nNPZ files now can be written without using temporary files\n----------------------------------------------------------\nIn Python 3.6+ ``numpy.savez`` and ``numpy.savez_compressed`` now write\ndirectly to a ZIP file, without creating intermediate temporary files.\n\nBetter support for empty structured and string types\n----------------------------------------------------\nStructured types can contain zero fields, and string dtypes can contain zero\ncharacters. Zero-length strings still cannot be created directly, and must be\nconstructed through structured dtypes::\n\n    str0 = np.empty(10, np.dtype([(&#39;v&#39;, str, N)]))[&#39;v&#39;]\n    void0 = np.empty(10, np.void)\n\nIt was always possible to work with these, but the following operations are\nnow supported for these arrays:\n\n * `arr.sort()`\n * `arr.view(bytes)`\n * `arr.resize(...)`\n * `pickle.dumps(arr)`\n\nSupport for ``decimal.Decimal`` in ``np.lib.financial``\n-------------------------------------------------------\nUnless otherwise stated all functions within the ``financial`` package now\nsupport using the ``decimal.Decimal`` built-in type.\n\nFloat printing now uses &quot;dragon4&quot; algorithm for shortest decimal representation\n-------------------------------------------------------------------------------\nThe ``str`` and ``repr`` of floating-point values (16, 32, 64 and 128 bit) are\nnow printed to give the shortest decimal representation which uniquely\nidentifies the value from others of the same type. Previously this was only\ntrue for ``float64`` values. The remaining float types will now often be shorter\nthan in numpy 1.13. Arrays printed in scientific notation now also use the\nshortest scientific representation, instead of fixed precision as before.\n\n Additionally, the `str` of float scalars scalars will no longer be truncated\n in python2, unlike python2 `float`s.  `np.double` scalars now have a ``str``\n and ``repr`` identical to that of a python3 float.\n\nNew functions ``np.format_float_scientific`` and ``np.format_float_positional``\nare provided to generate these decimal representations.\n\nA new option ``floatmode`` has been added to ``np.set_printoptions`` and\n``np.array2string``, which gives control over uniqueness and rounding of\nprinted elements in an array. The new default is ``floatmode=&#39;maxprec&#39;`` with\n``precision=8``, which will print at most 8 fractional digits, or fewer if an\nelement can be uniquely represented with fewer. A useful new mode is\n``floatmode=&quot;unique&quot;``, which will output enough digits to specify the array\nelements uniquely.\n\nNumpy complex-floating-scalars with values like ``inf*j`` or ``nan*j`` now\nprint as ``infj`` and ``nanj``, like the pure-python ``complex`` type.\n\nThe ``FloatFormat`` and ``LongFloatFormat`` classes are deprecated and should\nboth be replaced by ``FloatingFormat``. Similarly ``ComplexFormat`` and\n``LongComplexFormat`` should be replaced by ``ComplexFloatingFormat``.\n\n``void`` datatype elements are now printed in hex notation\n----------------------------------------------------------\nA hex representation compatible with the python ``bytes`` type is now printed\nfor unstructured ``np.void`` elements, e.g., ``V4`` datatype. Previously, in\npython2 the raw void data of the element was printed to stdout, or in python3\nthe integer byte values were shown.\n\nprinting style for ``void`` datatypes is now independently customizable\n-----------------------------------------------------------------------\nThe printing style of ``np.void`` arrays is now independently customizable\nusing the ``formatter`` argument to ``np.set_printoptions``, using the\n``&#39;void&#39;`` key, instead of the catch-all ``numpystr`` key as before.\n\nReduced memory usage of ``np.loadtxt``\n--------------------------------------\n``np.loadtxt`` now reads files in chunks instead of all at once which decreases\nits memory usage significantly for large files.\n\n\nChanges\n=======\n\nMultiple-field indexing/assignment of structured arrays\n-------------------------------------------------------\nThe indexing and assignment of structured arrays with multiple fields has\nchanged in a number of ways, as warned about in previous releases.\n\nFirst, indexing a structured array with multiple fields, e.g.,\n``arr[[&#39;f1&#39;, &#39;f3&#39;]]``, returns a view into the original array instead of a\ncopy. The returned view will have extra padding bytes corresponding to\nintervening fields in the original array, unlike the copy in 1.13, which will\naffect code such as ``arr[[&#39;f1&#39;, &#39;f3&#39;]].view(newdtype)``.\n\nSecond, assignment between structured arrays will now occur &quot;by position&quot;\ninstead of &quot;by field name&quot;. The Nth field of the destination will be set to the\nNth field of the source regardless of field name, unlike in numpy versions 1.6\nto 1.13 in which fields in the destination array were set to the\nidentically-named field in the source array or to 0 if the source did not have\na field.\n\nCorrespondingly, the order of fields in a structured dtypes now matters when\ncomputing dtype equality. For example, with the dtypes ::\n\n    x = dtype({&#39;names&#39;: [&#39;A&#39;, &#39;B&#39;], &#39;formats&#39;: [&#39;i4&#39;, &#39;f4&#39;], &#39;offsets&#39;: [0, 4]})\n    y = dtype({&#39;names&#39;: [&#39;B&#39;, &#39;A&#39;], &#39;formats&#39;: [&#39;f4&#39;, &#39;i4&#39;], &#39;offsets&#39;: [4, 0]})\n\nthe expression ``x == y`` will now return ``False``, unlike before.\nThis makes dictionary based dtype specifications like\n``dtype({&#39;a&#39;: (&#39;i4&#39;, 0), &#39;b&#39;: (&#39;f4&#39;, 4)})`` dangerous in python &lt; 3.6\nsince dict key order is not preserved in those versions.\n\nAssignment from a structured array to a boolean array now raises a ValueError,\nunlike in 1.13, where it always set the destination elements to ``True``.\n\nAssignment from structured array with more than one field to a non-structured\narray now raises a ValueError. In 1.13 this copied just the first field of the\nsource to the destination.\n\nUsing field &quot;titles&quot; in multiple-field indexing is now disallowed, as is\nrepeating a field name in a multiple-field index.\n\nThe documentation for structured arrays in the user guide has been\nsignificantly updated to reflect these changes.\n\nInteger and Void scalars are now unaffected by ``np.set_string_function``\n-------------------------------------------------------------------------\nPreviously, unlike most other numpy scalars, the ``str`` and ``repr`` of\ninteger and void scalars could be controlled by ``np.set_string_function``.\nThis is no longer possible.\n\n0d array printing changed, ``style`` arg of array2string deprecated\n-------------------------------------------------------------------\nPreviously the ``str`` and ``repr`` of 0d arrays had idiosyncratic\nimplementations which returned ``str(a.item())`` and ``&#39;array(&#39; +\nrepr(a.item()) + &#39;)&#39;`` respectively for 0d array ``a``, unlike both numpy\nscalars and higher dimension ndarrays.\n\nNow, the ``str`` of a 0d array acts like a numpy scalar using ``str(a[()])``\nand the ``repr`` acts like higher dimension arrays using ``formatter(a[()])``,\nwhere  ``formatter``  can be specified using ``np.set_printoptions``. The\n``style`` argument of ``np.array2string`` is deprecated.\n\nThis new behavior is disabled in 1.13 legacy printing mode, see compatibility\nnotes above.\n\nSeeding ``RandomState`` using an array requires a 1-d array\n-----------------------------------------------------------\n``RandomState`` previously would accept empty arrays or arrays with 2 or more\ndimensions, which resulted in either a failure to seed (empty arrays) or for\nsome of the passed values to be ignored when setting the seed.\n\n``MaskedArray`` objects show a more useful ``repr``\n---------------------------------------------------\nThe ``repr`` of a ``MaskedArray`` is now closer to the python code that would\nproduce it, with arrays now being shown with commas and dtypes. Like the other\nformatting changes, this can be disabled with the 1.13 legacy printing mode in\norder to help transition doctests.\n\nThe ``repr`` of ``np.polynomial`` classes is more explicit\n----------------------------------------------------------\nIt now shows the domain and window parameters as keyword arguments to make\nthem more clear::\n\n    &gt;&gt;&gt; np.polynomial.Polynomial(range(4))\n    Polynomial([0.,  1.,  2.,  3.], domain=[-1,  1], window=[-1,  1])\n\n\n==========================\n   ```\n   \n  \n  \n   ### 1.13.3\n   ```\n   ==========================\n\nThis is a bugfix release for some problems found since 1.13.1. The most\nimportant fixes are for CVE-2017-12852 and temporary elision. Users of earlier\nversions of 1.13 should upgrade.\n\nThe Python versions supported are 2.7 and 3.4 - 3.6. The Python 3.6 wheels\navailable from PIP are built with Python 3.6.2 and should be compatible with\nall previous versions of Python 3.6. It was cythonized with Cython 0.26.1,\nwhich should be free of the bugs found in 0.27 while also being compatible with\nPython 3.7-dev. The Windows wheels were built with OpenBlas instead ATLAS,\nwhich should improve the performance of the linear algebra functions.\n\nThe NumPy 1.13.3 release is a re-release of 1.13.2, which suffered from a\nbug in Cython 0.27.0.\n\nContributors\n============\n\nA total of 12 people contributed to this release.  People with a &quot;+&quot; by their\nnames contributed a patch for the first time.\n\n* Allan Haldane\n* Brandon Carter\n* Charles Harris\n* Eric Wieser\n* Iryna Shcherbina +\n* James Bourbeau +\n* Jonathan Helmus\n* Julian Taylor\n* Matti Picus\n* Michael Lamparski +\n* Michael Seifert\n* Ralf Gommers\n\nPull requests merged\n====================\n\nA total of 22 pull requests were merged for this release.\n\n* 9390 BUG: Return the poly1d coefficients array directly\n* 9555 BUG: Fix regression in 1.13.x in distutils.mingw32ccompiler.\n* 9556 BUG: Fix true_divide when dtype=np.float64 specified.\n* 9557 DOC: Fix some rst markup in numpy/doc/basics.py.\n* 9558 BLD: Remove -xhost flag from IntelFCompiler.\n* 9559 DOC: Removes broken docstring example (source code, png, pdf)...\n* 9580 BUG: Add hypot and cabs functions to WIN32 blacklist.\n* 9732 BUG: Make scalar function elision check if temp is writeable.\n* 9736 BUG: Various fixes to np.gradient\n* 9742 BUG: Fix np.pad for CVE-2017-12852\n* 9744 BUG: Check for exception in sort functions, add tests\n* 9745 DOC: Add whitespace after &quot;versionadded::&quot; directive so it actually...\n* 9746 BUG: Memory leak in np.dot of size 0\n* 9747 BUG: Adjust gfortran version search regex\n* 9757 BUG: Cython 0.27 breaks NumPy on Python 3.\n* 9764 BUG: Ensure `_npy_scaled_cexp{,f,l}` is defined when needed.\n* 9765 BUG: PyArray_CountNonzero does not check for exceptions\n* 9766 BUG: Fixes histogram monotonicity check for unsigned bin values\n* 9767 BUG: Ensure consistent result dtype of count_nonzero\n* 9771 BUG: MAINT: Fix mtrand for Cython 0.27.\n* 9772 DOC: Create the 1.13.2 release notes.\n* 9794 DOC: Create 1.13.3 release notes.\n\n\n==========================\n   ```\n   \n  \n</details>\n\n\n \n\n<details>\n  <summary>Links</summary>\n  \n  - PyPI: https://pypi.python.org/pypi/numpy\n  - Changelog: https://pyup.io/changelogs/numpy/\n  - Homepage: http://www.numpy.org\n</details>\n\n\n\n\n\n### Update [pandas](https://pypi.python.org/pypi/pandas) from **0.20.3** to **0.22.0**.\n\n\n<details>\n  <summary>Changelog</summary>\n  \n  \n   ### 0.22.0\n   ```\n   ---------------------------\n\nThis is a major release from 0.21.1 and includes a single, API-breaking change.\nWe recommend that all users upgrade to this version after carefully reading the\nrelease note (singular!).\n\n.. _whatsnew_0220.api_breaking:\n\nBackwards incompatible API changes\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nPandas 0.22.0 changes the handling of empty and all-*NA* sums and products. The\nsummary is that\n\n* The sum of an empty or all-*NA* ``Series`` is now ``0``\n* The product of an empty or all-*NA* ``Series`` is now ``1``\n* We&#39;ve added a ``min_count`` parameter to ``.sum()`` and ``.prod()`` controlling\n  the minimum number of valid values for the result to be valid. If fewer than\n  ``min_count`` non-*NA* values are present, the result is *NA*. The default is\n  ``0``. To return ``NaN``, the 0.21 behavior, use ``min_count=1``.\n\nSome background: In pandas 0.21, we fixed a long-standing inconsistency\nin the return value of all-*NA* series depending on whether or not bottleneck\nwas installed. See :ref:`whatsnew_0210.api_breaking.bottleneck`. At the same\ntime, we changed the sum and prod of an empty ``Series`` to also be ``NaN``.\n\nBased on feedback, we&#39;ve partially reverted those changes.\n\nArithmetic Operations\n^^^^^^^^^^^^^^^^^^^^^\n\nThe default sum for empty or all-*NA* ``Series`` is now ``0``.\n\n*pandas 0.21.x*\n\n.. code-block:: ipython\n\n   In [1]: pd.Series([]).sum()\n   Out[1]: nan\n\n   In [2]: pd.Series([np.nan]).sum()\n   Out[2]: nan\n\n*pandas 0.22.0*\n\n.. ipython:: python\n\n   pd.Series([]).sum()\n   pd.Series([np.nan]).sum()\n\nThe default behavior is the same as pandas 0.20.3 with bottleneck installed. It\nalso matches the behavior of NumPy&#39;s ``np.nansum`` on empty and all-*NA* arrays.\n\nTo have the sum of an empty series return ``NaN`` (the default behavior of\npandas 0.20.3 without bottleneck, or pandas 0.21.x), use the ``min_count``\nkeyword.\n\n.. ipython:: python\n\n   pd.Series([]).sum(min_count=1)\n\nThanks to the ``skipna`` parameter, the ``.sum`` on an all-*NA*\nseries is conceptually the same as the ``.sum`` of an empty one with\n``skipna=True`` (the default).\n\n.. ipython:: python\n\n   pd.Series([np.nan]).sum(min_count=1)   skipna=True by default\n\nThe ``min_count`` parameter refers to the minimum number of *non-null* values\nrequired for a non-NA sum or product.\n\n:meth:`Series.prod` has been updated to behave the same as :meth:`Series.sum`,\nreturning ``1`` instead.\n\n.. ipython:: python\n\n   pd.Series([]).prod()\n   pd.Series([np.nan]).prod()\n   pd.Series([]).prod(min_count=1)\n\nThese changes affect :meth:`DataFrame.sum` and :meth:`DataFrame.prod` as well.\nFinally, a few less obvious places in pandas are affected by this change.\n\nGrouping by a Categorical\n^^^^^^^^^^^^^^^^^^^^^^^^^\n\nGrouping by a ``Categorical`` and summing now returns ``0`` instead of\n``NaN`` for categories with no observations. The product now returns ``1``\ninstead of ``NaN``.\n\n*pandas 0.21.x*\n\n.. code-block:: ipython\n\n   In [8]: grouper = pd.Categorical([&#39;a&#39;, &#39;a&#39;], categories=[&#39;a&#39;, &#39;b&#39;])\n\n   In [9]: pd.Series([1, 2]).groupby(grouper).sum()\n   Out[9]:\n   a    3.0\n   b    NaN\n   dtype: float64\n\n*pandas 0.22*\n\n.. ipython:: python\n\n   grouper = pd.Categorical([&#39;a&#39;, &#39;a&#39;], categories=[&#39;a&#39;, &#39;b&#39;])\n   pd.Series([1, 2]).groupby(grouper).sum()\n\nTo restore the 0.21 behavior of returning ``NaN`` for unobserved groups,\nuse ``min_count&gt;=1``.\n\n.. ipython:: python\n\n   pd.Series([1, 2]).groupby(grouper).sum(min_count=1)\n\nResample\n^^^^^^^^\n\nThe sum and product of all-*NA* bins has changed from ``NaN`` to ``0`` for\nsum and ``1`` for product.\n\n*pandas 0.21.x*\n\n.. code-block:: ipython\n\n   In [11]: s = pd.Series([1, 1, np.nan, np.nan],\n      ...:                index=pd.date_range(&#39;2017&#39;, periods=4))\n      ...:  s\n   Out[11]:\n   2017-01-01    1.0\n   2017-01-02    1.0\n   2017-01-03    NaN\n   2017-01-04    NaN\n   Freq: D, dtype: float64\n\n   In [12]: s.resample(&#39;2d&#39;).sum()\n   Out[12]:\n   2017-01-01    2.0\n   2017-01-03    NaN\n   Freq: 2D, dtype: float64\n\n*pandas 0.22.0*\n\n.. ipython:: python\n\n   s = pd.Series([1, 1, np.nan, np.nan],\n                 index=pd.date_range(&#39;2017&#39;, periods=4))\n   s.resample(&#39;2d&#39;).sum()\n\nTo restore the 0.21 behavior of returning ``NaN``, use ``min_count&gt;=1``.\n\n.. ipython:: python\n\n   s.resample(&#39;2d&#39;).sum(min_count=1)\n\nIn particular, upsampling and taking the sum or product is affected, as\nupsampling introduces missing values even if the original series was\nentirely valid.\n\n*pandas 0.21.x*\n\n.. code-block:: ipython\n\n   In [14]: idx = pd.DatetimeIndex([&#39;2017-01-01&#39;, &#39;2017-01-02&#39;])\n\n   In [15]: pd.Series([1, 2], index=idx).resample(&#39;12H&#39;).sum()\n   Out[15]:\n   2017-01-01 00:00:00    1.0\n   2017-01-01 12:00:00    NaN\n   2017-01-02 00:00:00    2.0\n   Freq: 12H, dtype: float64\n\n*pandas 0.22.0*\n\n.. ipython:: python\n\n   idx = pd.DatetimeIndex([&#39;2017-01-01&#39;, &#39;2017-01-02&#39;])\n   pd.Series([1, 2], index=idx).resample(&quot;12H&quot;).sum()\n\nOnce again, the ``min_count`` keyword is available to restore the 0.21 behavior.\n\n.. ipython:: python\n\n   pd.Series([1, 2], index=idx).resample(&quot;12H&quot;).sum(min_count=1)\n\nRolling and Expanding\n^^^^^^^^^^^^^^^^^^^^^\n\nRolling and expanding already have a ``min_periods`` keyword that behaves\nsimilar to ``min_count``. The only case that changes is when doing a rolling\nor expanding sum with ``min_periods=0``. Previously this returned ``NaN``,\nwhen fewer than ``min_periods`` non-*NA* values were in the window. Now it\nreturns ``0``.\n\n*pandas 0.21.1*\n\n.. code-block:: ipython\n\n   In [17]: s = pd.Series([np.nan, np.nan])\n\n   In [18]: s.rolling(2, min_periods=0).sum()\n   Out[18]:\n   0   NaN\n   1   NaN\n   dtype: float64\n\n*pandas 0.22.0*\n\n.. ipython:: python\n\n   s = pd.Series([np.nan, np.nan])\n   s.rolling(2, min_periods=0).sum()\n\nThe default behavior of ``min_periods=None``, implying that ``min_periods``\nequals the window size, is unchanged.\n\nCompatibility\n~~~~~~~~~~~~~\n\nIf you maintain a library that should work across pandas versions, it\nmay be easiest to exclude pandas 0.21 from your requirements. Otherwise, all your\n``sum()`` calls would need to check if the ``Series`` is empty before summing.\n\nWith setuptools, in your ``setup.py`` use::\n\n    install_requires=[&#39;pandas!=0.21.*&#39;, ...]\n\nWith conda, use\n\n.. code-block:: yaml\n\n    requirements:\n      run:\n        - pandas !=0.21.0,!=0.21.1\n\nNote that the inconsistency in the return value for all-*NA* series is still\nthere for pandas 0.20.3 and earlier. Avoiding pandas 0.21 will only help with\nthe empty case.\n\n\n.. _whatsnew_0211:\n   ```\n   \n  \n  \n   ### 0.21.1\n   ```\n   ---------------------------\n\nThis is a minor bug-fix release in the 0.21.x series and includes some small regression fixes,\nbug fixes and performance improvements.\nWe recommend that all users upgrade to this version.\n\nHighlights include:\n\n- Temporarily restore matplotlib datetime plotting functionality. This should\n  resolve issues for users who implicitly relied on pandas to plot datetimes\n  with matplotlib. See :ref:`here &lt;whatsnew_0211.converters&gt;`.\n- Improvements to the Parquet IO functions introduced in 0.21.0. See\n  :ref:`here &lt;whatsnew_0211.enhancements.parquet&gt;`.\n\n\n.. contents:: What&#39;s new in v0.21.1\n    :local:\n    :backlinks: none\n\n\n.. _whatsnew_0211.converters:\n\nRestore Matplotlib datetime Converter Registration\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nPandas implements some matplotlib converters for nicely formatting the axis\nlabels on plots with ``datetime`` or ``Period`` values. Prior to pandas 0.21.0,\nthese were implicitly registered with matplotlib, as a side effect of ``import\npandas``.\n\nIn pandas 0.21.0, we required users to explicitly register the\nconverter. This caused problems for some users who relied on those converters\nbeing present for regular ``matplotlib.pyplot`` plotting methods, so we&#39;re\ntemporarily reverting that change; pandas 0.21.1 again registers the converters on\nimport, just like before 0.21.0.\n\nWe&#39;ve added a new option to control the converters:\n``pd.options.plotting.matplotlib.register_converters``. By default, they are\nregistered. Toggling this to ``False`` removes pandas&#39; formatters and restore\nany converters we overwrote when registering them (:issue:`18301`).\n\nWe&#39;re working with the matplotlib developers to make this easier. We&#39;re trying\nto balance user convenience (automatically registering the converters) with\nimport performance and best practices (importing pandas shouldn&#39;t have the side\neffect of overwriting any custom converters you&#39;ve already set). In the future\nwe hope to have most of the datetime formatting functionality in matplotlib,\nwith just the pandas-specific converters in pandas. We&#39;ll then gracefully\ndeprecate the automatic registration of converters in favor of users explicitly\nregistering them when they want them.\n\n.. _whatsnew_0211.enhancements:\n\nNew features\n~~~~~~~~~~~~\n\n.. _whatsnew_0211.enhancements.parquet:\n\nImprovements to the Parquet IO functionality\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n- :func:`DataFrame.to_parquet` will now write non-default indexes when the\n  underlying engine supports it. The indexes will be preserved when reading\n  back in with :func:`read_parquet` (:issue:`18581`).\n- :func:`read_parquet` now allows to specify the columns to read from a parquet file (:issue:`18154`)\n- :func:`read_parquet` now allows to specify kwargs which are passed to the respective engine (:issue:`18216`)\n\n.. _whatsnew_0211.enhancements.other:\n\nOther Enhancements\n^^^^^^^^^^^^^^^^^^\n\n- :meth:`Timestamp.timestamp` is now available in Python 2.7. (:issue:`17329`)\n- :class:`Grouper` and :class:`TimeGrouper` now have a friendly repr output (:issue:`18203`).\n\n.. _whatsnew_0211.deprecations:\n\nDeprecations\n~~~~~~~~~~~~\n\n- ``pandas.tseries.register`` has been renamed to\n  :func:`pandas.plotting.register_matplotlib_converters`` (:issue:`18301`)\n\n.. _whatsnew_0211.performance:\n\nPerformance Improvements\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n- Improved performance of plotting large series/dataframes (:issue:`18236`).\n\n.. _whatsnew_0211.bug_fixes:\n\nBug Fixes\n~~~~~~~~~\n\nConversion\n^^^^^^^^^^\n\n- Bug in :class:`TimedeltaIndex` subtraction could incorrectly overflow when ``NaT`` is present (:issue:`17791`)\n- Bug in :class:`DatetimeIndex` subtracting datetimelike from DatetimeIndex could fail to overflow (:issue:`18020`)\n- Bug in :meth:`IntervalIndex.copy` when copying and ``IntervalIndex`` with non-default ``closed`` (:issue:`18339`)\n- Bug in :func:`DataFrame.to_dict` where columns of datetime that are tz-aware were not converted to required arrays when used with ``orient=&#39;records&#39;``, raising``TypeError` (:issue:`18372`)\n- Bug in :class:`DateTimeIndex` and :meth:`date_range` where mismatching tz-aware ``start`` and ``end`` timezones would not raise an err if ``end.tzinfo`` is None (:issue:`18431`)\n- Bug in :meth:`Series.fillna` which raised when passed a long integer on Python 2 (:issue:`18159`).\n\nIndexing\n^^^^^^^^\n\n- Bug in a boolean comparison of a ``datetime.datetime`` and a ``datetime64[ns]`` dtype Series (:issue:`17965`)\n- Bug where a ``MultiIndex`` with more than a million records was not raising ``AttributeError`` when trying to access a missing attribute (:issue:`18165`)\n- Bug in :class:`IntervalIndex` constructor when a list of intervals is passed with non-default ``closed`` (:issue:`18334`)\n- Bug in ``Index.putmask`` when an invalid mask passed (:issue:`18368`)\n- Bug in masked assignment of a ``timedelta64[ns]`` dtype ``Series``, incorrectly coerced to float (:issue:`18493`)\n\nI/O\n^^^\n\n- Bug in class:`~pandas.io.stata.StataReader` not converting date/time columns with display formatting addressed (:issue:`17990`). Previously columns with display formatting were normally left as ordinal numbers and not converted to datetime objects.\n- Bug in :func:`read_csv` when reading a compressed UTF-16 encoded file (:issue:`18071`)\n- Bug in :func:`read_csv` for handling null values in index columns when specifying ``na_filter=False`` (:issue:`5239`)\n- Bug in :func:`read_csv` when reading numeric category fields with high cardinality (:issue:`18186`)\n- Bug in :meth:`DataFrame.to_csv` when the table had ``MultiIndex`` columns, and a list of strings was passed in for ``header`` (:issue:`5539`)\n- Bug in parsing integer datetime-like columns with specified format in ``read_sql`` (:issue:`17855`).\n- Bug in :meth:`DataFrame.to_msgpack` when serializing data of the ``numpy.bool_`` datatype (:issue:`18390`)\n- Bug in :func:`read_json` not decoding when reading line deliminted JSON from S3 (:issue:`17200`)\n- Bug in :func:`pandas.io.json.json_normalize` to avoid modification of ``meta`` (:issue:`18610`)\n- Bug in :func:`to_latex` where repeated multi-index values were not printed even though a higher level index differed from the previous row (:issue:`14484`)\n- Bug when reading NaN-only categorical columns in :class:`HDFStore` (:issue:`18413`)\n- Bug in :meth:`DataFrame.to_latex` with ``longtable=True`` where a latex multicolumn always spanned over three columns (:issue:`17959`)\n\nPlotting\n^^^^^^^^\n\n- Bug in ``DataFrame.plot()`` and ``Series.plot()`` with :class:`DatetimeIndex` where a figure generated by them is not pickleable in Python 3 (:issue:`18439`)\n\nGroupby/Resample/Rolling\n^^^^^^^^^^^^^^^^^^^^^^^^\n\n- Bug in ``DataFrame.resample(...).apply(...)`` when there is a callable that returns different columns (:issue:`15169`)\n- Bug in ``DataFrame.resample(...)`` when there is a time change (DST) and resampling frequecy is 12h or higher (:issue:`15549`)\n- Bug in ``pd.DataFrameGroupBy.count()`` when counting over a datetimelike column (:issue:`13393`)\n- Bug in ``rolling.var`` where calculation is inaccurate with a zero-valued array (:issue:`18430`)\n\nReshaping\n^^^^^^^^^\n\n- Error message in ``pd.merge_asof()`` for key datatype mismatch now includes datatype of left and right key (:issue:`18068`)\n- Bug in ``pd.concat`` when empty and non-empty DataFrames or Series are concatenated (:issue:`18178` :issue:`18187`)\n- Bug in ``DataFrame.filter(...)`` when :class:`unicode` is passed as a condition in Python 2 (:issue:`13101`)\n- Bug when merging empty DataFrames when ``np.seterr(divide=&#39;raise&#39;)`` is set (:issue:`17776`)\n\nNumeric\n^^^^^^^\n\n- Bug in ``pd.Series.rolling.skew()`` and ``rolling.kurt()`` with all equal values has floating issue (:issue:`18044`)\n\nCategorical\n^^^^^^^^^^^\n\n- Bug in :meth:`DataFrame.astype` where casting to &#39;category&#39; on an empty ``DataFrame`` causes a segmentation fault (:issue:`18004`)\n- Error messages in the testing module have been improved when items have different ``CategoricalDtype`` (:issue:`18069`)\n- ``CategoricalIndex`` can now correctly take a ``pd.api.types.CategoricalDtype`` as its dtype (:issue:`18116`)\n- Bug in ``Categorical.unique()`` returning read-only ``codes``  array when all categories were ``NaN`` (:issue:`18051`)\n- Bug in ``DataFrame.groupby(axis=1)`` with a ``CategoricalIndex`` (:issue:`18432`)\n\nString\n^^^^^^\n\n- :meth:`Series.str.split()` will now propagate ``NaN`` values across all expanded columns instead of ``None`` (:issue:`18450`)\n\n\n.. _whatsnew_060:\n   ```\n   \n  \n  \n   ### 0.21.0\n   ```\n   --------------------------\n\nThis is a major release from 0.20.3 and includes a number of API changes, deprecations, new features,\nenhancements, and performance improvements along with a large number of bug fixes. We recommend that all\nusers upgrade to this version.\n\nHighlights include:\n\n- Integration with `Apache Parquet &lt;https://parquet.apache.org/&gt;`__, including a new top-level :func:`read_parquet` function and :meth:`DataFrame.to_parquet` method, see :ref:`here &lt;whatsnew_0210.enhancements.parquet&gt;`.\n- New user-facing :class:`pandas.api.types.CategoricalDtype` for specifying\n  categoricals independent of the data, see :ref:`here &lt;whatsnew_0210.enhancements.categorical_dtype&gt;`.\n- The behavior of ``sum`` and ``prod`` on all-NaN Series/DataFrames is now consistent and no longer depends on whether `bottleneck &lt;http://berkeleyanalytics.com/bottleneck&gt;`__ is installed, and ``sum`` and ``prod`` on empty Series now return NaN instead of 0, see :ref:`here &lt;whatsnew_0210.api_breaking.bottleneck&gt;`.\n- Compatibility fixes for pypy, see :ref:`here &lt;whatsnew_0210.pypy&gt;`.\n- Additions to the ``drop``, ``reindex`` and ``rename`` API to make them more consistent, see :ref:`here &lt;whatsnew_0210.enhancements.drop_api&gt;`.\n- Addition of the new methods ``DataFrame.infer_objects`` (see :ref:`here &lt;whatsnew_0210.enhancements.infer_objects&gt;`) and ``GroupBy.pipe`` (see :ref:`here &lt;whatsnew_0210.enhancements.GroupBy_pipe&gt;`).\n- Indexing with a list of labels, where one or more of the labels is missing, is deprecated and will raise a KeyError in a future version, see :ref:`here &lt;whatsnew_0210.api_breaking.loc&gt;`.\n\nCheck the :ref:`API Changes &lt;whatsnew_0210.api_breaking&gt;` and :ref:`deprecations &lt;whatsnew_0210.deprecations&gt;` before updating.\n\n.. contents:: What&#39;s new in v0.21.0\n    :local:\n    :backlinks: none\n    :depth: 2\n\n.. _whatsnew_0210.enhancements:\n\nNew features\n~~~~~~~~~~~~\n\n.. _whatsnew_0210.enhancements.parquet:\n\nIntegration with Apache Parquet file format\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nIntegration with `Apache Parquet &lt;https://parquet.apache.org/&gt;`__, including a new top-level :func:`read_parquet` and :func:`DataFrame.to_parquet` method, see :ref:`here &lt;io.parquet&gt;` (:issue:`15838`, :issue:`17438`).\n\n`Apache Parquet &lt;https://parquet.apache.org/&gt;`__ provides a cross-language, binary file format for reading and writing data frames efficiently.\nParquet is designed to faithfully serialize and de-serialize ``DataFrame`` s, supporting all of the pandas\ndtypes, including extension dtypes such as datetime with timezones.\n\nThis functionality depends on either the `pyarrow &lt;http://arrow.apache.org/docs/python/&gt;`__ or `fastparquet &lt;https://fastparquet.readthedocs.io/en/latest/&gt;`__ library.\nFor more details, see see :ref:`the IO docs on Parquet &lt;io.parquet&gt;`.\n\n\n.. _whatsnew_0210.enhancements.infer_objects:\n\n``infer_objects`` type conversion\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nThe :meth:`DataFrame.infer_objects` and :meth:`Series.infer_objects`\nmethods have been added to perform dtype inference on object columns, replacing\nsome of the functionality of the deprecated ``convert_objects``\nmethod. See the documentation :ref:`here &lt;basics.object_conversion&gt;`\nfor more details. (:issue:`11221`)\n\nThis method only performs soft conversions on object columns, converting Python objects\nto native types, but not any coercive conversions. For example:\n\n.. ipython:: python\n\n   df = pd.DataFrame({&#39;A&#39;: [1, 2, 3],\n                      &#39;B&#39;: np.array([1, 2, 3], dtype=&#39;object&#39;),\n                      &#39;C&#39;: [&#39;1&#39;, &#39;2&#39;, &#39;3&#39;]})\n   df.dtypes\n   df.infer_objects().dtypes\n\nNote that column ``&#39;C&#39;`` was not converted - only scalar numeric types\nwill be converted to a new type.  Other types of conversion should be accomplished\nusing the :func:`to_numeric` function (or :func:`to_datetime`, :func:`to_timedelta`).\n\n.. ipython:: python\n\n   df = df.infer_objects()\n   df[&#39;C&#39;] = pd.to_numeric(df[&#39;C&#39;], errors=&#39;coerce&#39;)\n   df.dtypes\n\n.. _whatsnew_0210.enhancements.attribute_access:\n\nImproved warnings when attempting to create columns\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nNew users are often puzzled by the relationship between column operations and\nattribute access on ``DataFrame`` instances (:issue:`7175`). One specific\ninstance of this confusion is attempting to create a new column by setting an\nattribute on the ``DataFrame``:\n\n.. code-block:: ipython\n\n   In[1]: df = pd.DataFrame({&#39;one&#39;: [1., 2., 3.]})\n   In[2]: df.two = [4, 5, 6]\n\nThis does not raise any obvious exceptions, but also does not create a new column:\n\n.. code-block:: ipython\n\n   In[3]: df\n   Out[3]:\n       one\n   0  1.0\n   1  2.0\n   2  3.0\n\nSetting a list-like data structure into a new attribute now raises a ``UserWarning`` about the potential for unexpected behavior. See :ref:`Attribute Access &lt;indexing.attribute_access&gt;`.\n\n.. _whatsnew_0210.enhancements.drop_api:\n\n``drop`` now also accepts index/columns keywords\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nThe :meth:`~DataFrame.drop` method has gained ``index``/``columns`` keywords as an\nalternative to specifying the ``axis``. This is similar to the behavior of ``reindex``\n(:issue:`12392`).\n\nFor example:\n\n.. ipython:: python\n\n    df = pd.DataFrame(np.arange(8).reshape(2,4),\n                      columns=[&#39;A&#39;, &#39;B&#39;, &#39;C&#39;, &#39;D&#39;])\n    df\n    df.drop([&#39;B&#39;, &#39;C&#39;], axis=1)\n     the following is now equivalent\n    df.drop(columns=[&#39;B&#39;, &#39;C&#39;])\n\n.. _whatsnew_0210.enhancements.rename_reindex_axis:\n\n``rename``, ``reindex`` now also accept axis keyword\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nThe :meth:`DataFrame.rename` and :meth:`DataFrame.reindex` methods have gained\nthe ``axis`` keyword to specify the axis to target with the operation\n(:issue:`12392`).\n\nHere&#39;s ``rename``:\n\n.. ipython:: python\n\n   df = pd.DataFrame({&quot;A&quot;: [1, 2, 3], &quot;B&quot;: [4, 5, 6]})\n   df.rename(str.lower, axis=&#39;columns&#39;)\n   df.rename(id, axis=&#39;index&#39;)\n\nAnd ``reindex``:\n\n.. ipython:: python\n\n   df.reindex([&#39;A&#39;, &#39;B&#39;, &#39;C&#39;], axis=&#39;columns&#39;)\n   df.reindex([0, 1, 3], axis=&#39;index&#39;)\n\nThe &quot;index, columns&quot; style continues to work as before.\n\n.. ipython:: python\n\n   df.rename(index=id, columns=str.lower)\n   df.reindex(index=[0, 1, 3], columns=[&#39;A&#39;, &#39;B&#39;, &#39;C&#39;])\n\nWe *highly* encourage using named arguments to avoid confusion when using either\nstyle.\n\n.. _whatsnew_0210.enhancements.categorical_dtype:\n\n``CategoricalDtype`` for specifying categoricals\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n:class:`pandas.api.types.CategoricalDtype` has been added to the public API and\nexpanded to include the ``categories`` and ``ordered`` attributes. A\n``CategoricalDtype`` can be used to specify the set of categories and\norderedness of an array, independent of the data. This can be useful for example,\nwhen converting string data to a ``Categorical`` (:issue:`14711`,\n:issue:`15078`, :issue:`16015`, :issue:`17643`):\n\n.. ipython:: python\n\n   from pandas.api.types import CategoricalDtype\n\n   s = pd.Series([&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;a&#39;])   strings\n   dtype = CategoricalDtype(categories=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;, &#39;d&#39;], ordered=True)\n   s.astype(dtype)\n\nOne place that deserves special mention is in :meth:`read_csv`. Previously, with\n``dtype={&#39;col&#39;: &#39;category&#39;}``, the returned values and categories would always\nbe strings.\n\n.. ipython:: python\n   :suppress:\n\n   from pandas.compat import StringIO\n\n.. ipython:: python\n\n   data = &#39;A,B\\na,1\\nb,2\\nc,3&#39;\n   pd.read_csv(StringIO(data), dtype={&#39;B&#39;: &#39;category&#39;}).B.cat.categories\n\nNotice the &quot;object&quot; dtype.\n\nWith a ``CategoricalDtype`` of all numerics, datetimes, or\ntimedeltas, we can automatically convert to the correct type\n\n.. ipython:: python\n\n   dtype = {&#39;B&#39;: CategoricalDtype([1, 2, 3])}\n   pd.read_csv(StringIO(data), dtype=dtype).B.cat.c"},"comment":{"url":"https://api.github.com/repos/melvin15may/ssdedupe/issues/comments/377951714","html_url":"https://github.com/melvin15may/ssdedupe/pull/41#issuecomment-377951714","issue_url":"https://api.github.com/repos/melvin15may/ssdedupe/issues/41","id":377951714,"user":{"login":"pyup-bot","id":16239342,"avatar_url":"https://avatars0.githubusercontent.com/u/16239342?v=4","gravatar_id":"","url":"https://api.github.com/users/pyup-bot","html_url":"https://github.com/pyup-bot","followers_url":"https://api.github.com/users/pyup-bot/followers","following_url":"https://api.github.com/users/pyup-bot/following{/other_user}","gists_url":"https://api.github.com/users/pyup-bot/gists{/gist_id}","starred_url":"https://api.github.com/users/pyup-bot/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/pyup-bot/subscriptions","organizations_url":"https://api.github.com/users/pyup-bot/orgs","repos_url":"https://api.github.com/users/pyup-bot/repos","events_url":"https://api.github.com/users/pyup-bot/events{/privacy}","received_events_url":"https://api.github.com/users/pyup-bot/received_events","type":"User","site_admin":false},"created_at":"2018-04-02T15:12:37Z","updated_at":"2018-04-02T15:12:37Z","author_association":"COLLABORATOR","body":"Closing this in favor of #42"}}
{"actor":{"display_login":"pyup-bot"}}