{"action":"opened","number":104,"pull_request":{"url":"https://api.github.com/repos/biracruz/rasterrgb/pulls/104","id":209940534,"node_id":"MDExOlB1bGxSZXF1ZXN0MjA5OTQwNTM0","html_url":"https://github.com/biracruz/rasterrgb/pull/104","diff_url":"https://github.com/biracruz/rasterrgb/pull/104.diff","patch_url":"https://github.com/biracruz/rasterrgb/pull/104.patch","issue_url":"https://api.github.com/repos/biracruz/rasterrgb/issues/104","number":104,"state":"open","locked":false,"title":"Pin numpy to latest version 1.15.1","user":{"login":"pyup-bot","id":16239342,"node_id":"MDQ6VXNlcjE2MjM5MzQy","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},"body":"\nThis PR pins [numpy](https://pypi.org/project/numpy) to the latest release **1.15.1**.\n\n\n\n<details>\n  <summary>Changelog</summary>\n  \n  \n   ### 1.15.0\n   ```\n   ==========================\n\nNumPy 1.15.0 is a release with an unusual number of cleanups, many deprecations\nof old functions, and improvements to many existing functions. Please read the\ndetailed descriptions below to see if you are affected.\n\nFor testing, we have switched to pytest as a replacement for the no longer\nmaintained nose framework. The old nose based interface remains for downstream\nprojects who may still be using it.\n\nThe Python versions supported by this release are 2.7, 3.4-3.7. The wheels are\nlinked with OpenBLAS v0.3.0, which should fix some of the linalg problems\nreported for NumPy 1.14.\n\n\nHighlights\n==========\n\n* NumPy has switched to pytest for testing.\n* A new  `numpy.printoptions` context manager.\n* Many improvements to the histogram functions.\n* Support for unicode field names in python 2.7.\n* Improved support for PyPy.\n* Fixes and improvements to `numpy.einsum`.\n\n\nNew functions\n=============\n\n* `numpy.gcd` and `numpy.lcm`, to compute the greatest common divisor and least\n  common multiple.\n\n* `numpy.ma.stack`, the `numpy.stack` array-joining function generalized to\n  masked arrays.\n\n* `numpy.quantile` function, an interface to ``percentile`` without factors of\n  100\n\n* `numpy.nanquantile` function, an interface to ``nanpercentile`` without\n  factors of 100\n\n* `numpy.printoptions`, a context manager that sets print options temporarily\n  for the scope of the ``with`` block::\n\n    &gt;&gt;&gt; with np.printoptions(precision=2):\n    ...     print(np.array([2.0]) / 3)\n    [0.67]\n\n* `numpy.histogram_bin_edges`, a function to get the edges of the bins used by a\n  histogram without needing to calculate the histogram.\n\n* C functions `npy_get_floatstatus_barrier` and `npy_clear_floatstatus_barrier`\n  have been added to deal with compiler optimization changing the order of\n  operations.  See below for details.\n\n\nDeprecations\n============\n\n* Aliases of builtin `pickle` functions are deprecated, in favor of their\n  unaliased ``pickle.&lt;func&gt;`` names:\n\n  * `numpy.loads`\n  * `numpy.core.numeric.load`\n  * `numpy.core.numeric.loads`\n  * `numpy.ma.loads`, `numpy.ma.dumps`\n  * `numpy.ma.load`, `numpy.ma.dump` - these functions already failed on\n    python 3 when called with a string.\n\n* Multidimensional indexing with anything but a tuple is deprecated. This means\n  that the index list in ``ind = [slice(None), 0]; arr[ind]`` should be changed\n  to a tuple, e.g., ``ind = [slice(None), 0]; arr[tuple(ind)]`` or\n  ``arr[(slice(None), 0)]``. That change is necessary to avoid ambiguity in\n  expressions such as ``arr[[[0, 1], [0, 1]]]``, currently interpreted as\n  ``arr[array([0, 1]), array([0, 1])]``, that will be interpreted\n  as ``arr[array([[0, 1], [0, 1]])]`` in the future.\n\n* Imports from the following sub-modules are deprecated, they will be removed\n  at some future date.\n\n  * `numpy.testing.utils`\n  * `numpy.testing.decorators`\n  * `numpy.testing.nosetester`\n  * `numpy.testing.noseclasses`\n  * `numpy.core.umath_tests`\n\n* Giving a generator to `numpy.sum` is now deprecated. This was undocumented\n  behavior, but worked. Previously, it would calculate the sum of the generator\n  expression.  In the future, it might return a different result. Use\n  ``np.sum(np.from_iter(generator))`` or the built-in Python ``sum`` instead.\n\n* Users of the C-API should call ``PyArrayResolveWriteBackIfCopy`` or\n  ``PyArray_DiscardWritbackIfCopy`` on any array with the ``WRITEBACKIFCOPY``\n  flag set, before deallocating the array. A deprecation warning will be\n  emitted if those calls are not used when needed.\n\n* Users of ``nditer`` should use the nditer object as a context manager\n  anytime one of the iterator operands is writeable, so that numpy can\n  manage writeback semantics, or should call ``it.close()``. A\n  `RuntimeWarning` may be emitted otherwise in these cases.\n\n* The ``normed`` argument of ``np.histogram``, deprecated long ago in 1.6.0,\n  now emits a ``DeprecationWarning``.\n\n\nFuture Changes\n==============\n\n* NumPy 1.16 will drop support for Python 3.4.\n* NumPy 1.17 will drop support for Python 2.7.\n\n\nCompatibility notes\n===================\n\nCompiled testing modules renamed and made private\n-------------------------------------------------\nThe following compiled modules have been renamed and made private:\n\n* ``umath_tests`` -&gt; ``_umath_tests``\n* ``test_rational`` -&gt; ``_rational_tests``\n* ``multiarray_tests`` -&gt; ``_multiarray_tests``\n* ``struct_ufunc_test`` -&gt; ``_struct_ufunc_tests``\n* ``operand_flag_tests`` -&gt; ``_operand_flag_tests``\n\nThe ``umath_tests`` module is still available for backwards compatibility, but\nwill be removed in the future.\n\nThe ``NpzFile`` returned by ``np.savez`` is now a ``collections.abc.Mapping``\n-----------------------------------------------------------------------------\nThis means it behaves like a readonly dictionary, and has a new ``.values()``\nmethod and ``len()`` implementation.\n\nFor python 3, this means that ``.iteritems()``, ``.iterkeys()`` have been\ndeprecated, and ``.keys()`` and ``.items()`` now return views and not lists.\nThis is consistent with how the builtin ``dict`` type changed between python 2\nand python 3.\n\nUnder certain conditions, ``nditer`` must be used in a context manager\n----------------------------------------------------------------------\nWhen using an `numpy.nditer` with the ``&quot;writeonly&quot;`` or ``&quot;readwrite&quot;`` flags, there\nare some circumstances where nditer doesn&#39;t actually give you a view of the\nwritable array. Instead, it gives you a copy, and if you make changes to the\ncopy, nditer later writes those changes back into your actual array. Currently,\nthis writeback occurs when the array objects are garbage collected, which makes\nthis API error-prone on CPython and entirely broken on PyPy. Therefore,\n``nditer`` should now be used as a context manager whenever it is used\nwith writeable arrays, e.g., ``with np.nditer(...) as it: ...``. You may also\nexplicitly call ``it.close()`` for cases where a context manager is unusable,\nfor instance in generator expressions.\n\nNumpy has switched to using pytest instead of nose for testing\n--------------------------------------------------------------\nThe last nose release was 1.3.7 in June, 2015, and development of that tool has\nended, consequently NumPy has now switched to using pytest. The old decorators\nand nose tools that were previously used by some downstream projects remain\navailable, but will not be maintained. The standard testing utilities,\n``assert_almost_equal`` and such, are not be affected by this change except for\nthe nose specific functions ``import_nose`` and ``raises``. Those functions are\nnot used in numpy, but are kept for downstream compatibility.\n\nNumpy no longer monkey-patches ``ctypes`` with ``__array_interface__``\n----------------------------------------------------------------------\nPreviously numpy added ``__array_interface__`` attributes to all the integer\ntypes from ``ctypes``.\n\n``np.ma.notmasked_contiguous`` and ``np.ma.flatnotmasked_contiguous`` always return lists\n-----------------------------------------------------------------------------------------\nThis is the documented behavior, but previously the result could be any of\nslice, None, or list.\n\nAll downstream users seem to check for the ``None`` result from\n``flatnotmasked_contiguous`` and replace it with ``[]``.  Those callers will\ncontinue to work as before.\n\n``np.squeeze`` restores old behavior of objects that cannot handle an ``axis`` argument\n---------------------------------------------------------------------------------------\nPrior to version ``1.7.0``, `numpy.squeeze` did not have an ``axis`` argument and\nall empty axes were removed by default. The incorporation of an ``axis``\nargument made it possible to selectively squeeze single or multiple empty axes,\nbut the old API expectation was not respected because axes could still be\nselectively removed (silent success) from an object expecting all empty axes to\nbe removed. That silent, selective removal of empty axes for objects expecting\nthe old behavior has been fixed and the old behavior restored.\n\nunstructured void array&#39;s ``.item`` method now returns a bytes object\n---------------------------------------------------------------------\n``.item`` now returns a ``bytes`` object instead of a buffer or byte array.\nThis may affect code which assumed the return value was mutable, which is no\nlonger the case.\n\n``copy.copy`` and ``copy.deepcopy`` no longer turn ``masked`` into an array\n---------------------------------------------------------------------------\nSince ``np.ma.masked`` is a readonly scalar, copying should be a no-op. These\nfunctions now behave consistently with ``np.copy()``.\n\nMultifield Indexing of Structured Arrays will still return a copy\n-----------------------------------------------------------------\nThe change that multi-field indexing of structured arrays returns a view\ninstead of a copy is pushed back to 1.16. A new method\n``numpy.lib.recfunctions.repack_fields`` has been introduced to help mitigate\nthe effects of this change, which can be used to write code compatible with\nboth numpy 1.15 and 1.16. For more information on how to update code to account\nfor this future change see the &quot;accessing multiple fields&quot; section of the\n`user guide &lt;https://docs.scipy.org/doc/numpy/user/basics.rec.html&gt;`__.\n\n\nC API changes\n=============\n\nNew functions ``npy_get_floatstatus_barrier`` and ``npy_clear_floatstatus_barrier``\n-----------------------------------------------------------------------------------\nFunctions ``npy_get_floatstatus_barrier`` and ``npy_clear_floatstatus_barrier``\nhave been added and should be used in place of the ``npy_get_floatstatus``and\n``npy_clear_status`` functions. Optimizing compilers like GCC 8.1 and Clang\nwere rearranging the order of operations when the previous functions were used\nin the ufunc SIMD functions, resulting in the floatstatus flags being checked\nbefore the operation whose status we wanted to check was run.  See `10339\n&lt;https://github.com/numpy/numpy/issues/10370&gt;`__.\n\nChanges to ``PyArray_GetDTypeTransferFunction``\n-----------------------------------------------\n``PyArray_GetDTypeTransferFunction`` now defaults to using user-defined\n``copyswapn`` / ``copyswap`` for user-defined dtypes. If this causes a\nsignificant performance hit, consider implementing ``copyswapn`` to reflect the\nimplementation of ``PyArray_GetStridedCopyFn``.  See `10898\n&lt;https://github.com/numpy/numpy/pull/10898&gt;`__.\n\n\nNew Features\n============\n\n``np.gcd`` and ``np.lcm`` ufuncs added for integer and objects types\n--------------------------------------------------------------------\nThese compute the greatest common divisor, and lowest common multiple,\nrespectively. These work on all the numpy integer types, as well as the\nbuiltin arbitrary-precision ``Decimal`` and ``long`` types.\n\nSupport for cross-platform builds for iOS\n-----------------------------------------\nThe build system has been modified to add support for the\n``_PYTHON_HOST_PLATFORM`` environment variable, used by ``distutils`` when\ncompiling on one platform for another platform. This makes it possible to\ncompile NumPy for iOS targets.\n\nThis only enables you to compile NumPy for one specific platform at a time.\nCreating a full iOS-compatible NumPy package requires building for the 5\narchitectures supported by iOS (i386, x86_64, armv7, armv7s and arm64), and\ncombining these 5 compiled builds products into a single &quot;fat&quot; binary.\n\n``return_indices`` keyword added for ``np.intersect1d``\n-------------------------------------------------------\nNew keyword ``return_indices`` returns the indices of the two input arrays\nthat correspond to the common elements.\n\n``np.quantile`` and ``np.nanquantile``\n--------------------------------------\nLike ``np.percentile`` and ``np.nanpercentile``, but takes quantiles in [0, 1]\nrather than percentiles in [0, 100]. ``np.percentile`` is now a thin wrapper\naround ``np.quantile`` with the extra step of dividing by 100.\n\n\nBuild system\n------------\nAdded experimental support for the 64-bit RISC-V architecture.\n\n\nImprovements\n============\n\n``np.einsum`` updates\n---------------------\nSyncs einsum path optimization tech between `numpy` and `opt_einsum`. In\nparticular, the `greedy` path has received many enhancements by jcmgray. A\nfull list of issues fixed are:\n\n* Arbitrary memory can be passed into the `greedy` path. Fixes gh-11210.\n* The greedy path has been updated to contain more dynamic programming ideas\n  preventing a large number of duplicate (and expensive) calls that figure out\n  the actual pair contraction that takes place. Now takes a few seconds on\n  several hundred input tensors. Useful for matrix product state theories.\n* Reworks the broadcasting dot error catching found in gh-11218 gh-10352 to be\n  a bit earlier in the process.\n* Enhances the `can_dot` functionality that previous missed an edge case (part\n  of gh-11308).\n\n``np.ufunc.reduce`` and related functions now accept an initial value\n---------------------------------------------------------------------\n``np.ufunc.reduce``, ``np.sum``, ``np.prod``, ``np.min`` and ``np.max`` all\nnow accept an ``initial`` keyword argument that specifies the value to start\nthe reduction with.\n\n``np.flip`` can operate over multiple axes\n------------------------------------------\n``np.flip`` now accepts None, or tuples of int, in its ``axis`` argument. If\naxis is None, it will flip over all the axes.\n\n``histogram`` and ``histogramdd`` functions have moved to ``np.lib.histograms``\n-------------------------------------------------------------------------------\nThese were originally found in ``np.lib.function_base``. They are still\navailable under their un-scoped ``np.histogram(dd)`` names, and\nto maintain compatibility, aliased at ``np.lib.function_base.histogram(dd)``.\n\nCode that does ``from np.lib.function_base import *`` will need to be updated\nwith the new location, and should consider not using ``import *`` in future.\n\n``histogram`` will accept NaN values when explicit bins are given\n-----------------------------------------------------------------\nPreviously it would fail when trying to compute a finite range for the data.\nSince the range is ignored anyway when the bins are given explicitly, this error\nwas needless.\n\nNote that calling ``histogram`` on NaN values continues to raise the\n``RuntimeWarning`` s typical of working with nan values, which can be silenced\nas usual with ``errstate``.\n\n``histogram`` works on datetime types, when explicit bin edges are given\n------------------------------------------------------------------------\nDates, times, and timedeltas can now be histogrammed. The bin edges must be\npassed explicitly, and are not yet computed automatically.\n\n``histogram`` &quot;auto&quot; estimator handles limited variance better\n--------------------------------------------------------------\nNo longer does an IQR of 0 result in ``n_bins=1``, rather the number of bins\nchosen is related to the data size in this situation.\n\nThe edges retuned by `histogram`` and ``histogramdd`` now match the data float type\n-----------------------------------------------------------------------------------\nWhen passed ``np.float16``, ``np.float32``, or ``np.longdouble`` data, the\nreturned edges are now of the same dtype. Previously, ``histogram`` would only\nreturn the same type if explicit bins were given, and ``histogram`` would\nproduce ``float64`` bins no matter what the inputs.\n\n``histogramdd`` allows explicit ranges to be given in a subset of axes\n----------------------------------------------------------------------\nThe ``range`` argument of `numpy.histogramdd` can now contain ``None`` values to\nindicate that the range for the corresponding axis should be computed from the\ndata. Previously, this could not be specified on a per-axis basis.\n\nThe normed arguments of ``histogramdd`` and ``histogram2d`` have been renamed\n-----------------------------------------------------------------------------\nThese arguments are now called ``density``, which is consistent with\n``histogram``. The old argument continues to work, but the new name should be\npreferred.\n\n``np.r_`` works with 0d arrays, and ``np.ma.mr_`` works with ``np.ma.masked``\n-----------------------------------------------------------------------------\n0d arrays passed to the `r_` and `mr_` concatenation helpers are now treated as\nthough they are arrays of length 1. Previously, passing these was an error.\nAs a result, `numpy.ma.mr_` now works correctly on the ``masked`` constant.\n\n``np.ptp`` accepts a ``keepdims`` argument, and extended axis tuples\n--------------------------------------------------------------------\n``np.ptp`` (peak-to-peak) can now work over multiple axes, just like ``np.max``\nand ``np.min``.\n\n``MaskedArray.astype`` now is identical to ``ndarray.astype``\n-------------------------------------------------------------\nThis means it takes all the same arguments, making more code written for\nndarray work for masked array too.\n\nEnable AVX2/AVX512 at compile time\n----------------------------------\nChange to simd.inc.src to allow use of AVX2 or AVX512 at compile time. Previously\ncompilation for avx2 (or 512) with -march=native would still use the SSE\ncode for the simd functions even when the rest of the code got AVX2.\n\n``nan_to_num`` always returns scalars when receiving scalar or 0d inputs\n------------------------------------------------------------------------\nPreviously an array was returned for integer scalar inputs, which is\ninconsistent with the behavior for float inputs, and that of ufuncs in general.\nFor all types of scalar or 0d input, the result is now a scalar.\n\n``np.flatnonzero`` works on numpy-convertible types\n---------------------------------------------------\n``np.flatnonzero`` now uses ``np.ravel(a)`` instead of ``a.ravel()``, so it\nworks for lists, tuples, etc.\n\n``np.interp`` returns numpy scalars rather than builtin scalars\n---------------------------------------------------------------\nPreviously ``np.interp(0.5, [0, 1], [10, 20])`` would return a ``float``, but\nnow it returns a ``np.float64`` object, which more closely matches the behavior\nof other functions.\n\nAdditionally, the special case of ``np.interp(object_array_0d, ...)`` is no\nlonger supported, as ``np.interp(object_array_nd)`` was never supported anyway.\n\nAs a result of this change, the ``period`` argument can now be used on 0d\narrays.\n\nAllow dtype field names to be unicode in Python 2\n-------------------------------------------------\nPreviously ``np.dtype([(u&#39;name&#39;, float)])`` would raise a ``TypeError`` in\nPython 2, as only bytestrings were allowed in field names. Now any unicode\nstring field names will be encoded with the ``ascii`` codec, raising a\n``UnicodeEncodeError`` upon failure.\n\nThis change makes it easier to write Python 2/3 compatible code using\n``from __future__ import unicode_literals``, which previously would cause\nstring literal field names to raise a TypeError in Python 2.\n\nComparison ufuncs accept ``dtype=object``, overriding the default ``bool``\n--------------------------------------------------------------------------\nThis allows object arrays of symbolic types, which override ``==`` and other\noperators to return expressions, to be compared elementwise with\n``np.equal(a, b, dtype=object)``.\n\n``sort`` functions accept ``kind=&#39;stable&#39;``\n-------------------------------------------\nUp until now, to perform a stable sort on the data, the user must do:\n\n    &gt;&gt;&gt; np.sort([5, 2, 6, 2, 1], kind=&#39;mergesort&#39;)\n    [1, 2, 2, 5, 6]\n\nbecause merge sort is the only stable sorting algorithm available in\nNumPy. However, having kind=&#39;mergesort&#39; does not make it explicit that\nthe user wants to perform a stable sort thus harming the readability.\n\nThis change allows the user to specify kind=&#39;stable&#39; thus clarifying\nthe intent.\n\nDo not make temporary copies for in-place accumulation\n------------------------------------------------------\nWhen ufuncs perform accumulation they no longer make temporary copies because\nof the overlap between input an output, that is, the next element accumulated\nis added before the accumulated result is stored in its place, hence the\noverlap is safe. Avoiding the copy results in faster execution.\n\n``linalg.matrix_power`` can now handle stacks of matrices\n---------------------------------------------------------\nLike other functions in ``linalg``, ``matrix_power`` can now deal with arrays\nof dimension larger than 2, which are treated as stacks of matrices. As part\nof the change, to further improve consistency, the name of the first argument\nhas been changed to ``a`` (from ``M``), and the exceptions for non-square\nmatrices have been changed to ``LinAlgError`` (from ``ValueError``).\n\nIncreased performance in ``random.permutation`` for multidimensional arrays\n---------------------------------------------------------------------------\n``permutation`` uses the fast path in ``random.shuffle`` for all input\narray dimensions.  Previously the fast path was only used for 1-d arrays.\n\nGeneralized ufuncs now accept ``axes``, ``axis`` and ``keepdims`` arguments\n---------------------------------------------------------------------------\nOne can control over which axes a generalized ufunc operates by passing in an\n``axes`` argument, a list of tuples with indices of particular axes.  For\ninstance, for a signature of ``(i,j),(j,k)-&gt;(i,k)`` appropriate for matrix\nmultiplication, the base elements are two-dimensional matrices and these are\ntaken to be stored in the two last axes of each argument.  The corresponding\naxes keyword would be ``[(-2, -1), (-2, -1), (-2, -1)]``. If one wanted to\nuse leading dimensions instead, one would pass in ``[(0, 1), (0, 1), (0, 1)]``.\n\nFor simplicity, for generalized ufuncs that operate on 1-dimensional arrays\n(vectors), a single integer is accepted instead of a single-element tuple, and\nfor generalized ufuncs for which all outputs are scalars, the (empty) output\ntuples can be omitted.  Hence, for a signature of ``(i),(i)-&gt;()`` appropriate\nfor an inner product, one could pass in ``axes=[0, 0]`` to indicate that the\nvectors are stored in the first dimensions of the two inputs arguments.\n\nAs a short-cut for generalized ufuncs that are similar to reductions, i.e.,\nthat act on a single, shared core dimension such as the inner product example\nabove, one can pass an ``axis`` argument. This is equivalent to passing in\n``axes`` with identical entries for all arguments with that core dimension\n(e.g., for the example above, ``axes=[(axis,), (axis,)]``).\n\nFurthermore, like for reductions, for generalized ufuncs that have inputs that\nall have the same number of core dimensions and outputs with no core dimension,\none can pass in ``keepdims`` to leave a dimension with size 1 in the outputs,\nthus allowing proper broadcasting against the original inputs. The location of\nthe extra dimension can be controlled with ``axes``. For instance, for the\ninner-product example, ``keepdims=True, axes=[-2, -2, -2]`` would act on the\ninner-product example, ``keepdims=True, axis=-2`` would act on the\none-but-last dimension of the input arguments, and leave a size 1 dimension in\nthat place in the output.\n\nfloat128 values now print correctly on ppc systems\n--------------------------------------------------\nPreviously printing float128 values was buggy on ppc, since the special\ndouble-double floating-point-format on these systems was not accounted for.\nfloat128s now print with correct rounding and uniqueness.\n\nWarning to ppc users: You should upgrade glibc if it is version &lt;=2.23,\nespecially if using float128. On ppc, glibc&#39;s malloc in these version often\nmisaligns allocated memory which can crash numpy when using float128 values.\n\nNew ``np.take_along_axis`` and ``np.put_along_axis`` functions\n--------------------------------------------------------------\nWhen used on multidimensional arrays, ``argsort``, ``argmin``, ``argmax``, and\n``argpartition`` return arrays that are difficult to use as indices.\n``take_along_axis`` provides an easy way to use these indices to lookup values\nwithin an array, so that::\n\n    np.take_along_axis(a, np.argsort(a, axis=axis), axis=axis)\n\nis the same as::\n\n    np.sort(a, axis=axis)\n\n``np.put_along_axis`` acts as the dual operation for writing to these indices\nwithin an array.\n\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.14.5\n   ```\n   ==========================\n\nThis is a bugfix release for bugs reported following the 1.14.4 release. The\nmost significant fixes are:\n\n* fixes for compilation errors on alpine and NetBSD\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.28.2 and should work for the upcoming Python 3.7.\n\nContributors\n============\n\nA total of 1 person contributed to this release.  People with a &quot;+&quot; by their\nnames contributed a patch for the first time.\n\n* Charles Harris\n\nPull requests merged\n====================\n\nA total of 2 pull requests were merged for this release.\n\n* `11274 &lt;https://github.com/numpy/numpy/pull/11274&gt;`__: BUG: Correct use of NPY_UNUSED.\n* `11294 &lt;https://github.com/numpy/numpy/pull/11294&gt;`__: BUG: Remove extra trailing parentheses.\n\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.14.4\n   ```\n   ==========================\n\nThis is a bugfix release for bugs reported following the 1.14.3 release. The\nmost significant fixes are:\n\n* fixes for compiler instruction reordering that resulted in NaN&#39;s not being\n  properly propagated in `np.max` and `np.min`,\n\n* fixes for bus faults on SPARC and older ARM due to incorrect alignment\n  checks.\n\nThere are also improvements to printing of long doubles on PPC platforms. All\nis not yet perfect on that platform, the whitespace padding is still incorrect\nand is to be fixed in numpy 1.15, consequently NumPy still fails some\nprinting-related (and other) unit tests on ppc systems. However, the printed\nvalues are now correct.\n\nNote that NumPy will error on import if it detects incorrect float32 `dot`\nresults. This problem has been seen on the Mac when working in the Anaconda\nenviroment and is due to a subtle interaction between MKL and PyQt5.  It is not\nstrictly a NumPy problem, but it is best that users be aware of it.  See the\ngh-8577 NumPy issue for more information.\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.28.2 and should work for the upcoming Python 3.7.\n\nContributors\n============\n\nA total of 7 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* Marten van Kerkwijk\n* Matti Picus\n* Pauli Virtanen\n* Ryan Soklaski +\n* Sebastian Berg\n\nPull requests merged\n====================\n\nA total of 11 pull requests were merged for this release.\n\n* `11104 &lt;https://github.com/numpy/numpy/pull/11104&gt;`__: BUG: str of DOUBLE_DOUBLE format wrong on ppc64\n* `11170 &lt;https://github.com/numpy/numpy/pull/11170&gt;`__: TST: linalg: add regression test for gh-8577\n* `11174 &lt;https://github.com/numpy/numpy/pull/11174&gt;`__: MAINT: add sanity-checks to be run at import time\n* `11181 &lt;https://github.com/numpy/numpy/pull/11181&gt;`__: BUG: void dtype setup checked offset not actual pointer for alignment\n* `11194 &lt;https://github.com/numpy/numpy/pull/11194&gt;`__: BUG: Python2 doubles don&#39;t print correctly in interactive shell.\n* `11198 &lt;https://github.com/numpy/numpy/pull/11198&gt;`__: BUG: optimizing compilers can reorder call to npy_get_floatstatus\n* `11199 &lt;https://github.com/numpy/numpy/pull/11199&gt;`__: BUG: reduce using SSE only warns if inside SSE loop\n* `11203 &lt;https://github.com/numpy/numpy/pull/11203&gt;`__: BUG: Bytes delimiter/comments in genfromtxt should be decoded\n* `11211 &lt;https://github.com/numpy/numpy/pull/11211&gt;`__: BUG: Fix reference count/memory leak exposed by better testing\n* `11219 &lt;https://github.com/numpy/numpy/pull/11219&gt;`__: BUG: Fixes einsum broadcasting bug when optimize=True\n* `11251 &lt;https://github.com/numpy/numpy/pull/11251&gt;`__: DOC: Document 1.14.4 release.\n\n\n==========================\n   ```\n   \n  \n  \n   ### 1.14.3\n   ```\n   ==========================\n\nThis is a bugfix release for a few bugs reported following the 1.14.2 release:\n\n* np.lib.recfunctions.fromrecords accepts a list-of-lists, until 1.15\n* In python2, float types use the new print style when printing to a file\n* style arg in &quot;legacy&quot; print mode now works for 0d arrays\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.28.2.\n\nContributors\n============\n\nA total of 6 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* Jonathan March +\n* Malcolm Smith +\n* Matti Picus\n* Pauli Virtanen\n\nPull requests merged\n====================\n\nA total of 8 pull requests were merged for this release.\n\n* `10862 &lt;https://github.com/numpy/numpy/pull/10862&gt;`__: BUG: floating types should override tp_print (1.14 backport)\n* `10905 &lt;https://github.com/numpy/numpy/pull/10905&gt;`__: BUG: for 1.14 back-compat, accept list-of-lists in fromrecords\n* `10947 &lt;https://github.com/numpy/numpy/pull/10947&gt;`__: BUG: &#39;style&#39; arg to array2string broken in legacy mode (1.14...\n* `10959 &lt;https://github.com/numpy/numpy/pull/10959&gt;`__: BUG: test, fix for missing flags[&#39;WRITEBACKIFCOPY&#39;] key\n* `10960 &lt;https://github.com/numpy/numpy/pull/10960&gt;`__: BUG: Add missing underscore to prototype in check_embedded_lapack\n* `10961 &lt;https://github.com/numpy/numpy/pull/10961&gt;`__: BUG: Fix encoding regression in ma/bench.py (Issue 10868)\n* `10962 &lt;https://github.com/numpy/numpy/pull/10962&gt;`__: BUG: core: fix NPY_TITLE_KEY macro on pypy\n* `10974 &lt;https://github.com/numpy/numpy/pull/10974&gt;`__: BUG: test, fix PyArray_DiscardWritebackIfCopy...\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.14.2\n   ```\n   ==========================\n\nThis is a bugfix release for some bugs reported following the 1.14.1 release. The major\nproblems dealt with are as follows.\n\n* Residual bugs in the new array printing functionality.\n* Regression resulting in a relocation problem with shared library.\n* Improved PyPy compatibility.\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 4 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* Eric Wieser\n* Pauli Virtanen\n\nPull requests merged\n====================\n\nA total of 5 pull requests were merged for this release.\n\n* `10674 &lt;https://github.com/numpy/numpy/pull/10674&gt;`__: BUG: Further back-compat fix for subclassed array repr\n* `10725 &lt;https://github.com/numpy/numpy/pull/10725&gt;`__: BUG: dragon4 fractional output mode adds too many trailing zeros\n* `10726 &lt;https://github.com/numpy/numpy/pull/10726&gt;`__: BUG: Fix f2py generated code to work on PyPy\n* `10727 &lt;https://github.com/numpy/numpy/pull/10727&gt;`__: BUG: Fix missing NPY_VISIBILITY_HIDDEN on npy_longdouble_to_PyLong\n* `10729 &lt;https://github.com/numpy/numpy/pull/10729&gt;`__: DOC: Create 1.14.2 notes and changelog.\n\n\n=========================\n   ```\n   \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 `NEP 12`_.\n\nThis release supports Python 2.7 and 3.4 - 3.6.\n\n.. _`NEP 12`: http://www.numpy.org/neps/nep-0014-dropping-python2.7-proposal.html\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 ","created_at":"2018-08-21T20:06:09Z","updated_at":"2018-08-21T20:06:09Z","closed_at":null,"merged_at":null,"merge_commit_sha":null,"assignee":null,"assignees":[],"requested_reviewers":[],"requested_teams":[],"labels":[],"milestone":null,"commits_url":"https://api.github.com/repos/biracruz/rasterrgb/pulls/104/commits","review_comments_url":"https://api.github.com/repos/biracruz/rasterrgb/pulls/104/comments","review_comment_url":"https://api.github.com/repos/biracruz/rasterrgb/pulls/comments{/number}","comments_url":"https://api.github.com/repos/biracruz/rasterrgb/issues/104/comments","statuses_url":"https://api.github.com/repos/biracruz/rasterrgb/statuses/6179095777471a3e26e2e181cc7f7a3aac7b9e7d","head":{"label":"biracruz:pyup-pin-numpy-1.15.1","ref":"pyup-pin-numpy-1.15.1","sha":"6179095777471a3e26e2e181cc7f7a3aac7b9e7d","user":{"login":"biracruz","id":635197,"node_id":"MDQ6VXNlcjYzNTE5Nw==","avatar_url":"https://avatars1.githubusercontent.com/u/635197?v=4","gravatar_id":"","url":"https://api.github.com/users/biracruz","html_url":"https://github.com/biracruz","followers_url":"https://api.github.com/users/biracruz/followers","following_url":"https://api.github.com/users/biracruz/following{/other_user}","gists_url":"https://api.github.com/users/biracruz/gists{/gist_id}","starred_url":"https://api.github.com/users/biracruz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/biracruz/subscriptions","organizations_url":"https://api.github.com/users/biracruz/orgs","repos_url":"https://api.github.com/users/biracruz/repos","events_url":"https://api.github.com/users/biracruz/events{/privacy}","received_events_url":"https://api.github.com/users/biracruz/received_events","type":"User","site_admin":false},"repo":{"id":80581183,"node_id":"MDEwOlJlcG9zaXRvcnk4MDU4MTE4Mw==","name":"rasterrgb","full_name":"biracruz/rasterrgb","owner":{"login":"biracruz","id":635197,"node_id":"MDQ6VXNlcjYzNTE5Nw==","avatar_url":"https://avatars1.githubusercontent.com/u/635197?v=4","gravatar_id":"","url":"https://api.github.com/users/biracruz","html_url":"https://github.com/biracruz","followers_url":"https://api.github.com/users/biracruz/followers","following_url":"https://api.github.com/users/biracruz/following{/other_user}","gists_url":"https://api.github.com/users/biracruz/gists{/gist_id}","starred_url":"https://api.github.com/users/biracruz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/biracruz/subscriptions","organizations_url":"https://api.github.com/users/biracruz/orgs","repos_url":"https://api.github.com/users/biracruz/repos","events_url":"https://api.github.com/users/biracruz/events{/privacy}","received_events_url":"https://api.github.com/users/biracruz/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/biracruz/rasterrgb","description":null,"fork":false,"url":"https://api.github.com/repos/biracruz/rasterrgb","forks_url":"https://api.github.com/repos/biracruz/rasterrgb/forks","keys_url":"https://api.github.com/repos/biracruz/rasterrgb/keys{/key_id}","collaborators_url":"https://api.github.com/repos/biracruz/rasterrgb/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/biracruz/rasterrgb/teams","hooks_url":"https://api.github.com/repos/biracruz/rasterrgb/hooks","issue_events_url":"https://api.github.com/repos/biracruz/rasterrgb/issues/events{/number}","events_url":"https://api.github.com/repos/biracruz/rasterrgb/events","assignees_url":"https://api.github.com/repos/biracruz/rasterrgb/assignees{/user}","branches_url":"https://api.github.com/repos/biracruz/rasterrgb/branches{/branch}","tags_url":"https://api.github.com/repos/biracruz/rasterrgb/tags","blobs_url":"https://api.github.com/repos/biracruz/rasterrgb/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/biracruz/rasterrgb/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/biracruz/rasterrgb/git/refs{/sha}","trees_url":"https://api.github.com/repos/biracruz/rasterrgb/git/trees{/sha}","statuses_url":"https://api.github.com/repos/biracruz/rasterrgb/statuses/{sha}","languages_url":"https://api.github.com/repos/biracruz/rasterrgb/languages","stargazers_url":"https://api.github.com/repos/biracruz/rasterrgb/stargazers","contributors_url":"https://api.github.com/repos/biracruz/rasterrgb/contributors","subscribers_url":"https://api.github.com/repos/biracruz/rasterrgb/subscribers","subscription_url":"https://api.github.com/repos/biracruz/rasterrgb/subscription","commits_url":"https://api.github.com/repos/biracruz/rasterrgb/commits{/sha}","git_commits_url":"https://api.github.com/repos/biracruz/rasterrgb/git/commits{/sha}","comments_url":"https://api.github.com/repos/biracruz/rasterrgb/comments{/number}","issue_comment_url":"https://api.github.com/repos/biracruz/rasterrgb/issues/comments{/number}","contents_url":"https://api.github.com/repos/biracruz/rasterrgb/contents/{+path}","compare_url":"https://api.github.com/repos/biracruz/rasterrgb/compare/{base}...{head}","merges_url":"https://api.github.com/repos/biracruz/rasterrgb/merges","archive_url":"https://api.github.com/repos/biracruz/rasterrgb/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/biracruz/rasterrgb/downloads","issues_url":"https://api.github.com/repos/biracruz/rasterrgb/issues{/number}","pulls_url":"https://api.github.com/repos/biracruz/rasterrgb/pulls{/number}","milestones_url":"https://api.github.com/repos/biracruz/rasterrgb/milestones{/number}","notifications_url":"https://api.github.com/repos/biracruz/rasterrgb/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/biracruz/rasterrgb/labels{/name}","releases_url":"https://api.github.com/repos/biracruz/rasterrgb/releases{/id}","deployments_url":"https://api.github.com/repos/biracruz/rasterrgb/deployments","created_at":"2017-02-01T01:54:14Z","updated_at":"2018-01-03T20:35:01Z","pushed_at":"2018-08-21T20:06:08Z","git_url":"git://github.com/biracruz/rasterrgb.git","ssh_url":"git@github.com:biracruz/rasterrgb.git","clone_url":"https://github.com/biracruz/rasterrgb.git","svn_url":"https://github.com/biracruz/rasterrgb","homepage":null,"size":51,"stargazers_count":1,"watchers_count":1,"language":"Python","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"archived":false,"open_issues_count":36,"license":{"key":"mit","name":"MIT License","spdx_id":"MIT","url":"https://api.github.com/licenses/mit","node_id":"MDc6TGljZW5zZTEz"},"forks":0,"open_issues":36,"watchers":1,"default_branch":"master"}},"base":{"label":"biracruz:master","ref":"master","sha":"a342dd116dabf1c44e03a8d7d413395a70796231","user":{"login":"biracruz","id":635197,"node_id":"MDQ6VXNlcjYzNTE5Nw==","avatar_url":"https://avatars1.githubusercontent.com/u/635197?v=4","gravatar_id":"","url":"https://api.github.com/users/biracruz","html_url":"https://github.com/biracruz","followers_url":"https://api.github.com/users/biracruz/followers","following_url":"https://api.github.com/users/biracruz/following{/other_user}","gists_url":"https://api.github.com/users/biracruz/gists{/gist_id}","starred_url":"https://api.github.com/users/biracruz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/biracruz/subscriptions","organizations_url":"https://api.github.com/users/biracruz/orgs","repos_url":"https://api.github.com/users/biracruz/repos","events_url":"https://api.github.com/users/biracruz/events{/privacy}","received_events_url":"https://api.github.com/users/biracruz/received_events","type":"User","site_admin":false},"repo":{"id":80581183,"node_id":"MDEwOlJlcG9zaXRvcnk4MDU4MTE4Mw==","name":"rasterrgb","full_name":"biracruz/rasterrgb","owner":{"login":"biracruz","id":635197,"node_id":"MDQ6VXNlcjYzNTE5Nw==","avatar_url":"https://avatars1.githubusercontent.com/u/635197?v=4","gravatar_id":"","url":"https://api.github.com/users/biracruz","html_url":"https://github.com/biracruz","followers_url":"https://api.github.com/users/biracruz/followers","following_url":"https://api.github.com/users/biracruz/following{/other_user}","gists_url":"https://api.github.com/users/biracruz/gists{/gist_id}","starred_url":"https://api.github.com/users/biracruz/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/biracruz/subscriptions","organizations_url":"https://api.github.com/users/biracruz/orgs","repos_url":"https://api.github.com/users/biracruz/repos","events_url":"https://api.github.com/users/biracruz/events{/privacy}","received_events_url":"https://api.github.com/users/biracruz/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/biracruz/rasterrgb","description":null,"fork":false,"url":"https://api.github.com/repos/biracruz/rasterrgb","forks_url":"https://api.github.com/repos/biracruz/rasterrgb/forks","keys_url":"https://api.github.com/repos/biracruz/rasterrgb/keys{/key_id}","collaborators_url":"https://api.github.com/repos/biracruz/rasterrgb/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/biracruz/rasterrgb/teams","hooks_url":"https://api.github.com/repos/biracruz/rasterrgb/hooks","issue_events_url":"https://api.github.com/repos/biracruz/rasterrgb/issues/events{/number}","events_url":"https://api.github.com/repos/biracruz/rasterrgb/events","assignees_url":"https://api.github.com/repos/biracruz/rasterrgb/assignees{/user}","branches_url":"https://api.github.com/repos/biracruz/rasterrgb/branches{/branch}","tags_url":"https://api.github.com/repos/biracruz/rasterrgb/tags","blobs_url":"https://api.github.com/repos/biracruz/rasterrgb/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/biracruz/rasterrgb/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/biracruz/rasterrgb/git/refs{/sha}","trees_url":"https://api.github.com/repos/biracruz/rasterrgb/git/trees{/sha}","statuses_url":"https://api.github.com/repos/biracruz/rasterrgb/statuses/{sha}","languages_url":"https://api.github.com/repos/biracruz/rasterrgb/languages","stargazers_url":"https://api.github.com/repos/biracruz/rasterrgb/stargazers","contributors_url":"https://api.github.com/repos/biracruz/rasterrgb/contributors","subscribers_url":"https://api.github.com/repos/biracruz/rasterrgb/subscribers","subscription_url":"https://api.github.com/repos/biracruz/rasterrgb/subscription","commits_url":"https://api.github.com/repos/biracruz/rasterrgb/commits{/sha}","git_commits_url":"https://api.github.com/repos/biracruz/rasterrgb/git/commits{/sha}","comments_url":"https://api.github.com/repos/biracruz/rasterrgb/comments{/number}","issue_comment_url":"https://api.github.com/repos/biracruz/rasterrgb/issues/comments{/number}","contents_url":"https://api.github.com/repos/biracruz/rasterrgb/contents/{+path}","compare_url":"https://api.github.com/repos/biracruz/rasterrgb/compare/{base}...{head}","merges_url":"https://api.github.com/repos/biracruz/rasterrgb/merges","archive_url":"https://api.github.com/repos/biracruz/rasterrgb/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/biracruz/rasterrgb/downloads","issues_url":"https://api.github.com/repos/biracruz/rasterrgb/issues{/number}","pulls_url":"https://api.github.com/repos/biracruz/rasterrgb/pulls{/number}","milestones_url":"https://api.github.com/repos/biracruz/rasterrgb/milestones{/number}","notifications_url":"https://api.github.com/repos/biracruz/rasterrgb/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/biracruz/rasterrgb/labels{/name}","releases_url":"https://api.github.com/repos/biracruz/rasterrgb/releases{/id}","deployments_url":"https://api.github.com/repos/biracruz/rasterrgb/deployments","created_at":"2017-02-01T01:54:14Z","updated_at":"2018-01-03T20:35:01Z","pushed_at":"2018-08-21T20:06:08Z","git_url":"git://github.com/biracruz/rasterrgb.git","ssh_url":"git@github.com:biracruz/rasterrgb.git","clone_url":"https://github.com/biracruz/rasterrgb.git","svn_url":"https://github.com/biracruz/rasterrgb","homepage":null,"size":51,"stargazers_count":1,"watchers_count":1,"language":"Python","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"archived":false,"open_issues_count":36,"license":{"key":"mit","name":"MIT License","spdx_id":"MIT","url":"https://api.github.com/licenses/mit","node_id":"MDc6TGljZW5zZTEz"},"forks":0,"open_issues":36,"watchers":1,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/biracruz/rasterrgb/pulls/104"},"html":{"href":"https://github.com/biracruz/rasterrgb/pull/104"},"issue":{"href":"https://api.github.com/repos/biracruz/rasterrgb/issues/104"},"comments":{"href":"https://api.github.com/repos/biracruz/rasterrgb/issues/104/comments"},"review_comments":{"href":"https://api.github.com/repos/biracruz/rasterrgb/pulls/104/comments"},"review_comment":{"href":"https://api.github.com/repos/biracruz/rasterrgb/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/biracruz/rasterrgb/pulls/104/commits"},"statuses":{"href":"https://api.github.com/repos/biracruz/rasterrgb/statuses/6179095777471a3e26e2e181cc7f7a3aac7b9e7d"}},"author_association":"NONE","merged":false,"mergeable":null,"rebaseable":null,"mergeable_state":"unknown","merged_by":null,"comments":0,"review_comments":0,"maintainer_can_modify":false,"commits":2,"additions":2,"deletions":2,"changed_files":2}}
{"actor":{"display_login":"pyup-bot"}}