payload: {"action":"closed","number":231,"pull_request":{"url":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/231","id":273007766,"node_id":"MDExOlB1bGxSZXF1ZXN0MjczMDA3NzY2","html_url":"https://github.com/inbo/niche_vlaanderen/pull/231","diff_url":"https://github.com/inbo/niche_vlaanderen/pull/231.diff","patch_url":"https://github.com/inbo/niche_vlaanderen/pull/231.patch","issue_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/231","number":231,"state":"closed","locked":false,"title":"Pin numpy to latest version 1.16.3","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.16.3**.\n\n\n\n<details>\n  <summary>Changelog</summary>\n  \n  \n   ### 1.16.2\n   ```\n   ==========================\n\nNumPy 1.16.2 is a quick release fixing several problems encountered on Windows.\nThe Python versions supported are 2.7 and 3.5-3.7. The Windows problems\naddressed are:\n\n- DLL load problems for NumPy wheels on Windows,\n- distutils command line parsing on Windows.\n\nThere is also a regression fix correcting signed zeros produced by divmod, see\nbelow for details.\n\nDownstream developers building this release should use Cython &gt;= 0.29.2 and, if\nusing OpenBLAS, OpenBLAS &gt; v0.3.4.\n\nIf you are installing using pip, you may encounter a problem with older\ninstalled versions of NumPy that pip did not delete becoming mixed with the\ncurrent version, resulting in an ``ImportError``. That problem is particularly\ncommon on Debian derived distributions due to a modified pip.  The fix is to\nmake sure all previous NumPy versions installed by pip have been removed. See\n`12736 &lt;https://github.com/numpy/numpy/issues/12736&gt;`__ for discussion of the\nissue.\n\n\nCompatibility notes\n===================\n\nSigned zero when using divmod\n-----------------------------\nStarting in version 1.12.0, numpy incorrectly returned a negatively signed zero\nwhen using the ``divmod`` and ``floor_divide`` functions when the result was\nzero. For example::\n\n   &gt;&gt;&gt; np.zeros(10)//1\n   array([-0., -0., -0., -0., -0., -0., -0., -0., -0., -0.])\n\nWith this release, the result is correctly returned as a positively signed\nzero::\n\n   &gt;&gt;&gt; np.zeros(10)//1\n   array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n\n\nContributors\n============\n\nA total of 5 people contributed to this release.  People with a &quot;+&quot; by their\nnames contributed a patch for the first time.\n\n* Charles Harris\n* Eric Wieser\n* Matti Picus\n* Tyler Reddy\n* Tony LaTorre +\n\n\nPull requests merged\n====================\n\nA total of 7 pull requests were merged for this release.\n\n* `12909 &lt;https://github.com/numpy/numpy/pull/12909&gt;`__: TST: fix vmImage dispatch in Azure\n* `12923 &lt;https://github.com/numpy/numpy/pull/12923&gt;`__: MAINT: remove complicated test of multiarray import failure mode\n* `13020 &lt;https://github.com/numpy/numpy/pull/13020&gt;`__: BUG: fix signed zero behavior in npy_divmod\n* `13026 &lt;https://github.com/numpy/numpy/pull/13026&gt;`__: MAINT: Add functions to parse shell-strings in the platform-native...\n* `13028 &lt;https://github.com/numpy/numpy/pull/13028&gt;`__: BUG: Fix regression in parsing of F90 and F77 environment variables\n* `13038 &lt;https://github.com/numpy/numpy/pull/13038&gt;`__: BUG: parse shell escaping in extra_compile_args and extra_link_args\n* `13041 &lt;https://github.com/numpy/numpy/pull/13041&gt;`__: BLD: Windows absolute path DLL loading\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.16.1\n   ```\n   ==========================\n\nThe NumPy 1.16.1 release fixes bugs reported against the 1.16.0 release, and\nalso backports several enhancements from master that seem appropriate for a\nrelease series that is the last to support Python 2.7. The wheels on PyPI are\nlinked with OpenBLAS v0.3.4+,  which should fix the known threading issues\nfound in previous OpenBLAS versions.\n\nDownstream developers building this release should use Cython &gt;= 0.29.2 and, if\nusing OpenBLAS, OpenBLAS &gt; v0.3.4.\n\nIf you are installing using pip, you may encounter a problem with older\ninstalled versions of NumPy that pip did not delete becoming mixed with the\ncurrent version, resulting in an ``ImportError``. That problem is particularly\ncommon on Debian derived distributions due to a modified pip.  The fix is to\nmake sure all previous NumPy versions installed by pip have been removed. See\n`12736 &lt;https://github.com/numpy/numpy/issues/12736&gt;`__ for discussion of the\nissue. Note that previously this problem resulted in an ``AttributeError``.\n\n\nContributors\n============\n\nA total of 16 people contributed to this release.  People with a &quot;+&quot; by their\nnames contributed a patch for the first time.\n\n* Antoine Pitrou\n* Arcesio Castaneda Medina +\n* Charles Harris\n* Chris Markiewicz +\n* Christoph Gohlke\n* Christopher J. Markiewicz +\n* Daniel Hrisca +\n* EelcoPeacs +\n* Eric Wieser\n* Kevin Sheppard\n* Matti Picus\n* OBATA Akio +\n* Ralf Gommers\n* Sebastian Berg\n* Stephan Hoyer\n* Tyler Reddy\n\n\nEnhancements\n============\n\n* `12767 &lt;https://github.com/numpy/numpy/pull/12767&gt;`__: ENH: add mm-&gt;q floordiv\n* `12768 &lt;https://github.com/numpy/numpy/pull/12768&gt;`__: ENH: port np.core.overrides to C for speed\n* `12769 &lt;https://github.com/numpy/numpy/pull/12769&gt;`__: ENH: Add np.ctypeslib.as_ctypes_type(dtype), improve `np.ctypeslib.as_ctypes`\n* `12773 &lt;https://github.com/numpy/numpy/pull/12773&gt;`__: ENH: add &quot;max difference&quot; messages to np.testing.assert_array_equal...\n* `12820 &lt;https://github.com/numpy/numpy/pull/12820&gt;`__: ENH: Add mm-&gt;qm divmod\n* `12890 &lt;https://github.com/numpy/numpy/pull/12890&gt;`__: ENH: add _dtype_ctype to namespace for freeze analysis\n\n\nCompatibility notes\n===================\n\n* The changed error message emited by array comparison testing functions may\n  affect doctests. See below for detail.\n\n* Casting from double and single denormals to float16 has been corrected.  In\n  some rare cases, this may result in results being rounded up instead of down,\n  changing the last bit (ULP) of the result.\n\n\nNew Features\n============\n\ndivmod operation is now supported for two ``timedelta64`` operands\n------------------------------------------------------------------\nThe divmod operator now handles two ``np.timedelta64`` operands, with\ntype signature ``mm-&gt;qm``.\n\n\nImprovements\n============\n\nFurther improvements to ``ctypes`` support in ``np.ctypeslib``\n--------------------------------------------------------------\nA new `numpy.ctypeslib.as_ctypes_type` function has been added, which can be\nused to converts a `dtype` into a best-guess `ctypes` type. Thanks to this\nnew function, `numpy.ctypeslib.as_ctypes` now supports a much wider range of\narray types, including structures, booleans, and integers of non-native\nendianness.\n\nArray comparison assertions include maximum differences\n-------------------------------------------------------\nError messages from array comparison tests such as\n`np.testing.assert_allclose` now include &quot;max absolute difference&quot; and\n&quot;max relative difference,&quot; in addition to the previous &quot;mismatch&quot; percentage.\nThis information makes it easier to update absolute and relative error\ntolerances.\n\n\nChanges\n=======\n\n``timedelta64 % 0`` behavior adjusted to return ``NaT``\n-------------------------------------------------------\nThe modulus operation with two ``np.timedelta64`` operands now returns\n``NaT`` in the case of division by zero, rather than returning zero\n\n\n\n\n\n==========================\n   ```\n   \n  \n  \n   ### 1.16.0\n   ```\n   ==========================\n\nThis NumPy release is the last one to support Python 2.7 and will be maintained\nas a long term release with bug fixes until 2020.  Support for Python 3.4 been\ndropped, the supported Python versions are 2.7 and 3.5-3.7. The wheels on PyPI\nare linked with OpenBLAS v0.3.4+,  which should fix the known threading issues\nfound in previous OpenBLAS versions.\n\nDownstream developers building this release should use Cython &gt;= 0.29 and, if\nusing OpenBLAS, OpenBLAS &gt; v0.3.4.\n\nThis release has seen a lot of refactoring and features many bug fixes, improved\ncode organization, and better cross platform compatibility. Not all of these\nimprovements will be visible to users, but they should help make maintenance\neasier going forward.\n\n\nHighlights\n==========\n\n* Experimental (opt-in only) support for overriding numpy functions,\n  see ``__array_function__`` below.\n\n* The ``matmul`` function is now a ufunc. This provides better\n  performance and allows overriding with ``__array_ufunc__``.\n\n* Improved support for the ARM and POWER architectures.\n\n* Improved support for AIX and PyPy.\n\n* Improved interop with ctypes.\n\n* Improved support for PEP 3118.\n\n\n\nNew functions\n=============\n\n* New functions added to the `numpy.lib.recfuntions` module to ease the\n  structured assignment changes:\n\n    * ``assign_fields_by_name``\n    * ``structured_to_unstructured``\n    * ``unstructured_to_structured``\n    * ``apply_along_fields``\n    * ``require_fields``\n\n  See the user guide at &lt;https://docs.scipy.org/doc/numpy/user/basics.rec.html&gt;\n  for more info.\n\n\nNew deprecations\n================\n\n* The type dictionaries `numpy.core.typeNA` and `numpy.core.sctypeNA` are\n  deprecated. They were buggy and not documented and will be removed in the\n  1.18 release. Use`numpy.sctypeDict` instead.\n\n* The `numpy.asscalar` function is deprecated. It is an alias to the more\n  powerful `numpy.ndarray.item`, not tested, and fails for scalars.\n\n* The `numpy.set_array_ops` and `numpy.get_array_ops` functions are deprecated.\n  As part of `NEP 15`, they have been deprecated along with the C-API functions\n  :c:func:`PyArray_SetNumericOps` and :c:func:`PyArray_GetNumericOps`. Users\n  who wish to override the inner loop functions in built-in ufuncs should use\n  :c:func:`PyUFunc_ReplaceLoopBySignature`.\n\n* The `numpy.unravel_index` keyword argument ``dims`` is deprecated, use\n  ``shape`` instead.\n\n* The `numpy.histogram` ``normed`` argument is deprecated.  It was deprecated\n  previously, but no warning was issued.\n\n* The ``positive`` operator (``+``) applied to non-numerical arrays is\n  deprecated. See below for details.\n\n* Passing an iterator to the stack functions is deprecated\n\n\nExpired deprecations\n====================\n\n* NaT comparisons now return ``False`` without a warning, finishing a\n  deprecation cycle begun in NumPy 1.11.\n\n* ``np.lib.function_base.unique`` was removed, finishing a deprecation cycle\n  begun in NumPy 1.4. Use `numpy.unique` instead.\n\n* multi-field indexing now returns views instead of copies, finishing a\n  deprecation cycle begun in NumPy 1.7. The change was previously attempted in\n  NumPy 1.14 but reverted until now.\n\n* ``np.PackageLoader`` and ``np.pkgload`` have been removed. These were\n  deprecated in 1.10, had no tests, and seem to no longer work in 1.15.\n\n\nFuture changes\n==============\n\n* NumPy 1.17 will drop support for Python 2.7.\n\n\nCompatibility notes\n===================\n\nf2py script on Windows\n----------------------\nOn Windows, the installed script for running f2py is now an ``.exe`` file\nrather than a ``*.py`` file and should be run from the command line as ``f2py``\nwhenever the ``Scripts`` directory is in the path. Running ``f2py`` as a module\n``python -m numpy.f2py [...]`` will work without path modification in any\nversion of NumPy.\n\nNaT comparisons\n---------------\nConsistent with the behavior of NaN, all comparisons other than inequality\nchecks with datetime64 or timedelta64 NaT (&quot;not-a-time&quot;) values now always\nreturn ``False``, and inequality checks with NaT now always return ``True``.\nThis includes comparisons beteween NaT values. For compatibility with the\nold behavior, use ``np.isnat`` to explicitly check for NaT or convert\ndatetime64/timedelta64 arrays with ``.astype(np.int64)`` before making\ncomparisons.\n\ncomplex64/128 alignment has changed\n-----------------------------------\nThe memory alignment of complex types is now the same as a C-struct composed of\ntwo floating point values, while before it was equal to the size of the type.\nFor many users (for instance on x64/unix/gcc) this means that complex64 is now\n4-byte aligned instead of 8-byte aligned. An important consequence is that\naligned structured dtypes may now have a different size. For instance,\n``np.dtype(&#39;c8,u1&#39;, align=True)`` used to have an itemsize of 16 (on x64/gcc)\nbut now it is 12.\n\nMore in detail, the complex64 type now has the same alignment as a C-struct\n``struct {float r, i;}``, according to the compiler used to compile numpy, and\nsimilarly for the complex128 and complex256 types.\n\nnd_grid __len__ removal\n-----------------------\n``len(np.mgrid)`` and ``len(np.ogrid)`` are now considered nonsensical\nand raise a ``TypeError``.\n\n``np.unravel_index`` now accepts ``shape`` keyword argument\n-----------------------------------------------------------\nPreviously, only the ``dims`` keyword argument was accepted\nfor specification of the shape of the array to be used\nfor unraveling. ``dims`` remains supported, but is now deprecated.\n\nmulti-field views return a view instead of a copy\n-------------------------------------------------\nIndexing a structured array with multiple fields, e.g., ``arr[[&#39;f1&#39;, &#39;f3&#39;]]``,\nreturns a view into the original array instead of a copy. The returned view\nwill often have extra padding bytes corresponding to intervening fields in the\noriginal array, unlike before, which will affect code such as\n``arr[[&#39;f1&#39;, &#39;f3&#39;]].view(&#39;float64&#39;)``. This change has been planned since numpy\n1.7. Operations hitting this path have emitted ``FutureWarnings`` since then.\nAdditional ``FutureWarnings`` about this change were added in 1.12.\n\nTo help users update their code to account for these changes, a number of\nfunctions have been added to the ``numpy.lib.recfunctions`` module which\nsafely allow such operations. For instance, the code above can be replaced\nwith ``structured_to_unstructured(arr[[&#39;f1&#39;, &#39;f3&#39;]], dtype=&#39;float64&#39;)``.\nSee the &quot;accessing multiple fields&quot; section of the\n`user guide &lt;https://docs.scipy.org/doc/numpy/user/basics.rec.htmlaccessing-multiple-fields&gt;`__.\n\n\nC API changes\n=============\n\nThe :c:data:`NPY_API_VERSION` was incremented to 0x0000D, due to the addition\nof:\n\n* :c:member:`PyUFuncObject.core_dim_flags`\n* :c:member:`PyUFuncObject.core_dim_sizes`\n* :c:member:`PyUFuncObject.identity_value`\n* :c:func:`PyUFunc_FromFuncAndDataAndSignatureAndIdentity`\n\n\nNew Features\n============\n\nIntegrated squared error (ISE) estimator added to ``histogram``\n---------------------------------------------------------------\nThis method (``bins=&#39;stone&#39;``) for optimizing the bin number is a\ngeneralization of the Scott&#39;s rule. The Scott&#39;s rule assumes the distribution\nis approximately Normal, while the ISE_ is a non-parametric method based on\ncross-validation.\n\n.. _ISE: https://en.wikipedia.org/wiki/HistogramMinimizing_cross-validation_estimated_squared_error\n\n``max_rows`` keyword added for ``np.loadtxt``\n---------------------------------------------\nNew keyword ``max_rows`` in `numpy.loadtxt` sets the maximum rows of the\ncontent to be read after ``skiprows``, as in `numpy.genfromtxt`.\n\nmodulus operator support added for ``np.timedelta64`` operands\n--------------------------------------------------------------\nThe modulus (remainder) operator is now supported for two operands\nof type ``np.timedelta64``. The operands may have different units\nand the return value will match the type of the operands.\n\n\nImprovements\n============\n\nno-copy pickling of numpy arrays\n--------------------------------\nUp to protocol 4, numpy array pickling created 2 spurious copies of the data\nbeing serialized.  With pickle protocol 5, and the ``PickleBuffer`` API, a\nlarge variety of numpy arrays can now be serialized without any copy using\nout-of-band buffers, and with one less copy using in-band buffers. This\nresults, for large arrays, in an up to 66% drop in peak memory usage.\n\nbuild shell independence\n------------------------\nNumPy builds should no longer interact with the host machine\nshell directly. ``exec_command`` has been replaced with\n``subprocess.check_output`` where appropriate.\n\n`np.polynomial.Polynomial` classes render in LaTeX in Jupyter notebooks\n-----------------------------------------------------------------------\nWhen used in a front-end that supports it, `Polynomial` instances are now\nrendered through LaTeX. The current format is experimental, and is subject to\nchange.\n\n``randint`` and ``choice`` now work on empty distributions\n----------------------------------------------------------\nEven when no elements needed to be drawn, ``np.random.randint`` and\n``np.random.choice`` raised an error when the arguments described an empty\ndistribution. This has been fixed so that e.g.\n``np.random.choice([], 0) == np.array([], dtype=float64)``.\n\n``linalg.lstsq``, ``linalg.qr``, and ``linalg.svd`` now work with empty arrays\n------------------------------------------------------------------------------\nPreviously, a ``LinAlgError`` would be raised when an empty matrix/empty\nmatrices (with zero rows and/or columns) is/are passed in. Now outputs of\nappropriate shapes are returned.\n\nChain exceptions to give better error messages for invalid PEP3118 format strings\n---------------------------------------------------------------------------------\nThis should help track down problems.\n\nEinsum optimization path updates and efficiency improvements\n------------------------------------------------------------\nEinsum was synchronized with the current upstream work.\n\n`numpy.angle` and `numpy.expand_dims` now work on ``ndarray`` subclasses\n------------------------------------------------------------------------\nIn particular, they now work for masked arrays.\n\n``NPY_NO_DEPRECATED_API`` compiler warning suppression\n------------------------------------------------------\nSetting ``NPY_NO_DEPRECATED_API`` to a value of 0 will suppress the current compiler\nwarnings when the deprecated numpy API is used.\n\n``np.diff`` Added kwargs prepend and append\n-------------------------------------------\nNew kwargs ``prepend`` and ``append``, allow for values to be inserted on\neither end of the differences.  Similar to options for `ediff1d`. Now the\ninverse of `cumsum` can be obtained easily via ``prepend=0``.\n\nARM support updated\n-------------------\nSupport for ARM CPUs has been updated to accommodate 32 and 64 bit targets,\nand also big and little endian byte ordering. AARCH32 memory alignment issues\nhave been addressed. CI testing has been expanded to include AARCH64 targets\nvia the services of shippable.com.\n\nAppending to build flags\n------------------------\n`numpy.distutils` has always overridden rather than appended to `LDFLAGS` and\nother similar such environment variables for compiling Fortran extensions.\nNow, if the `NPY_DISTUTILS_APPEND_FLAGS` environment variable is set to 1, the\nbehavior will be appending.  This applied to: `LDFLAGS`, `F77FLAGS`,\n`F90FLAGS`, `FREEFLAGS`, `FOPT`, `FDEBUG`, and `FFLAGS`.  See gh-11525 for more\ndetails.\n\nGeneralized ufunc signatures now allow fixed-size dimensions\n------------------------------------------------------------\nBy using a numerical value in the signature of a generalized ufunc, one can\nindicate that the given function requires input or output to have dimensions\nwith the given size. E.g., the signature of a function that converts a polar\nangle to a two-dimensional cartesian unit vector would be ``()-&gt;(2)``; that\nfor one that converts two spherical angles to a three-dimensional unit vector\nwould be ``(),()-&gt;(3)``; and that for the cross product of two\nthree-dimensional vectors would be ``(3),(3)-&gt;(3)``.\n\nNote that to the elementary function these dimensions are not treated any\ndifferently from variable ones indicated with a name starting with a letter;\nthe loop still is passed the corresponding size, but it can now count on that\nsize being equal to the fixed one given in the signature.\n\nGeneralized ufunc signatures now allow flexible dimensions\n----------------------------------------------------------\nSome functions, in particular numpy&#39;s implementation of ` as ``matmul``,\nare very similar to generalized ufuncs in that they operate over core\ndimensions, but one could not present them as such because they were able to\ndeal with inputs in which a dimension is missing. To support this, it is now\nallowed to postfix a dimension name with a question mark to indicate that the\ndimension does not necessarily have to be present.\n\nWith this addition, the signature for ``matmul`` can be expressed as\n``(m?,n),(n,p?)-&gt;(m?,p?)``.  This indicates that if, e.g., the second operand\nhas only one dimension, for the purposes of the elementary function it will be\ntreated as if that input has core shape ``(n, 1)``, and the output has the\ncorresponding core shape of ``(m, 1)``. The actual output array, however, has\nthe flexible dimension removed, i.e., it will have shape ``(..., m)``.\nSimilarly, if both arguments have only a single dimension, the inputs will be\npresented as having shapes ``(1, n)`` and ``(n, 1)`` to the elementary\nfunction, and the output as ``(1, 1)``, while the actual output array returned\nwill have shape ``()``. In this way, the signature allows one to use a\nsingle elementary function for four related but different signatures,\n``(m,n),(n,p)-&gt;(m,p)``, ``(n),(n,p)-&gt;(p)``, ``(m,n),(n)-&gt;(m)`` and\n``(n),(n)-&gt;()``.\n\n``np.clip`` and the ``clip`` method check for memory overlap\n------------------------------------------------------------\nThe ``out`` argument to these functions is now always tested for memory overlap\nto avoid corrupted results when memory overlap occurs.\n\nNew value ``unscaled`` for option ``cov`` in ``np.polyfit``\n-----------------------------------------------------------\nA further possible value has been added to the ``cov`` parameter of the\n``np.polyfit`` function. With ``cov=&#39;unscaled&#39;`` the scaling of the covariance\nmatrix is disabled completely (similar to setting ``absolute_sigma=True`` in\n``scipy.optimize.curve_fit``). This would be useful in occasions, where the\nweights are given by 1/sigma with sigma being the (known) standard errors of\n(Gaussian distributed) data points, in which case the unscaled matrix is\nalready a correct estimate for the covariance matrix.\n\nDetailed docstrings for scalar numeric types\n--------------------------------------------\nThe ``help`` function, when applied to numeric types such as `numpy.intc`,\n`numpy.int_`, and `numpy.longlong`, now lists all of the aliased names for that\ntype, distinguishing between platform -dependent and -independent aliases.\n\n``__module__`` attribute now points to public modules\n-----------------------------------------------------\nThe ``__module__`` attribute on most NumPy functions has been updated to refer\nto the preferred public module from which to access a function, rather than\nthe module in which the function happens to be defined. This produces more\ninformative displays for functions in tools such as IPython, e.g., instead of\n``&lt;function &#39;numpy.core.fromnumeric.sum&#39;&gt;`` you now see\n``&lt;function &#39;numpy.sum&#39;&gt;``.\n\nLarge allocations marked as suitable for transparent hugepages\n--------------------------------------------------------------\nOn systems that support transparent hugepages over the madvise system call\nnumpy now marks that large memory allocations can be backed by hugepages which\nreduces page fault overhead and can in some fault heavy cases improve\nperformance significantly. On Linux the setting for huge pages to be used,\n`/sys/kernel/mm/transparent_hugepage/enabled`, must be at least `madvise`.\nSystems which already have it set to `always` will not see much difference as\nthe kernel will automatically use huge pages where appropriate.\n\nUsers of very old Linux kernels (~3.x and older) should make sure that\n`/sys/kernel/mm/transparent_hugepage/defrag` is not set to `always` to avoid\nperformance problems due concurrency issues in the memory defragmentation.\n\nAlpine Linux (and other musl c library distros) support\n-------------------------------------------------------\nWe now default to use `fenv.h` for floating point status error reporting.\nPreviously we had a broken default that sometimes would not report underflow,\noverflow, and invalid floating point operations. Now we can support non-glibc\ndistrubutions like Alpine Linux as long as they ship `fenv.h`.\n\nSpeedup ``np.block`` for large arrays\n-------------------------------------\nLarge arrays (greater than ``512 * 512``) now use a blocking algorithm based on\ncopying the data directly into the appropriate slice of the resulting array.\nThis results in significant speedups for these large arrays, particularly for\narrays being blocked along more than 2 dimensions.\n\n``arr.ctypes.data_as(...)`` holds a reference to arr\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nPreviously the caller was responsible for keeping the array alive for the\nlifetime of the pointer.\n\nSpeedup ``np.take`` for read-only arrays\n----------------------------------------\nThe implementation of ``np.take`` no longer makes an unnecessary copy of the\nsource array when its ``writeable`` flag is set to ``False``.\n\nSupport path-like objects for more functions\n--------------------------------------------\nThe ``np.core.records.fromfile`` function now supports ``pathlib.Path``\nand other path-like objects in addition to a file object. Furthermore, the\n``np.load`` function now also supports path-like objects when using memory\nmapping (``mmap_mode`` keyword argument).\n\nBetter behaviour of ufunc identities during reductions\n------------------------------------------------------\nUniversal functions have an ``.identity`` which is used when ``.reduce`` is\ncalled on an empty axis.\n\nAs of this release, the logical binary ufuncs, `logical_and`, `logical_or`,\nand `logical_xor`, now have ``identity`` s of type `bool`, where previously they\nwere of type `int`. This restores the 1.14 behavior of getting ``bool`` s when\nreducing empty object arrays with these ufuncs, while also keeping the 1.15\nbehavior of getting ``int`` s when reducing empty object arrays with arithmetic\nufuncs like ``add`` and ``multiply``.\n\nAdditionally, `logaddexp` now has an identity of ``-inf``, allowing it to be\ncalled on empty sequences, where previously it could not be.\n\nThis is possible thanks to the new\n:c:func:`PyUFunc_FromFuncAndDataAndSignatureAndIdentity`, which allows\narbitrary values to be used as identities now.\n\nImproved conversion from ctypes objects\n---------------------------------------\nNumpy has always supported taking a value or type from ``ctypes`` and\nconverting it into an array or dtype, but only behaved correctly for simpler\ntypes. As of this release, this caveat is lifted - now:\n\n* The ``_pack_`` attribute of ``ctypes.Structure``, used to emulate C&#39;s\n  ``__attribute__((packed))``, is respected.\n* Endianness of all ctypes objects is preserved\n* ``ctypes.Union`` is supported\n* Non-representable constructs raise exceptions, rather than producing\n  dangerously incorrect results:\n\n  * Bitfields are no longer interpreted as sub-arrays\n  * Pointers are no longer replaced with the type that they point to\n\nA new ``ndpointer.contents`` member\n-----------------------------------\nThis matches the ``.contents`` member of normal ctypes arrays, and can be used\nto construct an ``np.array`` around the pointers contents.  This replaces\n``np.array(some_nd_pointer)``, which stopped working in 1.15.  As a side effect\nof this change, ``ndpointer`` now supports dtypes with overlapping fields and\npadding.\n\n``matmul`` is now a ``ufunc``\n-----------------------------\n`numpy.matmul` is now a ufunc which means that both the function and the\n``__matmul__`` operator can now be overridden by ``__array_ufunc__``. Its\nimplementation has also changed. It uses the same BLAS routines as\n`numpy.dot`, ensuring its performance is similar for large matrices.\n\nStart and stop arrays for ``linspace``, ``logspace`` and ``geomspace``\n----------------------------------------------------------------------\nThese functions used to be limited to scalar stop and start values, but can\nnow take arrays, which will be properly broadcast and result in an output\nwhich has one axis prepended.  This can be used, e.g., to obtain linearly\ninterpolated points between sets of points.\n\nCI extended with additional services\n------------------------------------\nWe now use additional free CI services, thanks to the companies that provide:\n\n* Codecoverage testing via codecov.io\n* Arm testing via shippable.com\n* Additional test runs on azure pipelines\n\nThese are in addition to our continued use of travis, appveyor (for wheels) and\nLGTM\n\n\nChanges\n=======\n\nComparison ufuncs will now error rather than return NotImplemented\n------------------------------------------------------------------\nPreviously, comparison ufuncs such as ``np.equal`` would return\n`NotImplemented` if their arguments had structured dtypes, to help comparison\noperators such as ``__eq__`` deal with those.  This is no longer needed, as the\nrelevant logic has moved to the comparison operators proper (which thus do\ncontinue to return `NotImplemented` as needed). Hence, like all other ufuncs,\nthe comparison ufuncs will now error on structured dtypes.\n\nPositive will now raise a deprecation warning for non-numerical arrays\n----------------------------------------------------------------------\nPreviously, ``+array`` unconditionally returned a copy. Now, it will\nraise a ``DeprecationWarning`` if the array is not numerical (i.e.,\nif ``np.positive(array)`` raises a ``TypeError``. For ``ndarray``\nsubclasses that override the default ``__array_ufunc__`` implementation,\nthe ``TypeError`` is passed on.\n\n``NDArrayOperatorsMixin`` now implements matrix multiplication\n--------------------------------------------------------------\nPreviously, ``np.lib.mixins.NDArrayOperatorsMixin`` did not implement the\nspecial methods for Python&#39;s matrix multiplication operator (`). This has\nchanged now that ``matmul`` is a ufunc and can be overridden using\n``__array_ufunc__``.\n\nThe scaling of the covariance matrix in ``np.polyfit`` is different\n-------------------------------------------------------------------\nSo far, ``np.polyfit`` used a non-standard factor in the scaling of the the\ncovariance matrix. Namely, rather than using the standard ``chisq/(M-N)``, it\nscaled it with ``chisq/(M-N-2)`` where M is the number of data points and N is the\nnumber of parameters.  This scaling is inconsistent with other fitting programs\nsuch as e.g. ``scipy.optimize.curve_fit`` and was changed to ``chisq/(M-N)``.\n\n``maximum`` and ``minimum`` no longer emit warnings\n---------------------------------------------------\nAs part of code introduced in 1.10,  ``float32`` and ``float64`` set invalid\nfloat status when a Nan is encountered in `numpy.maximum` and `numpy.minimum`,\nwhen using SSE2 semantics. This caused a `RuntimeWarning` to sometimes be\nemitted. In 1.15 we fixed the inconsistencies which caused the warnings to\nbecome more conspicuous. Now no warnings will be emitted.\n\nUmath and multiarray c-extension modules merged into a single module\n--------------------------------------------------------------------\nThe two modules were merged, according to `NEP 15`_. Previously `np.core.umath`\nand `np.core.multiarray` were seperate c-extension modules. They are now python\nwrappers to the single `np.core/_multiarray_math` c-extension module.\n\n.. _`NEP 15` : http://www.numpy.org/neps/nep-0015-merge-multiarray-umath.html\n\n``getfield`` validity checks extended\n-------------------------------------\n`numpy.ndarray.getfield` now checks the dtype and offset arguments to prevent\naccessing invalid memory locations.\n\nNumPy functions now support overrides with ``__array_function__``\n-----------------------------------------------------------------\nNumPy has a new experimental mechanism for overriding the implementation of\nalmost all NumPy functions on non-NumPy arrays by defining an\n``__array_function__`` method, as described in `NEP 18`_.\n\nThis feature is not yet been enabled by default, but has been released to\nfacilitate experimentation by potential users. See the NEP for details on\nsetting the appropriate environment variable. We expect the NumPy 1.17 release\nwill enable overrides by default, which will also be more performant due to a\nnew implementation written in C.\n\n.. _`NEP 18` : http://www.numpy.org/neps/nep-0018-array-function-protocol.html\n\nArrays based off readonly buffers cannot be set ``writeable``\n-------------------------------------------------------------\nWe now disallow setting the ``writeable`` flag True on arrays created\nfrom ``fromstring(readonly-buffer)``.\n\n\n==========================\n   ```\n   \n  \n  \n   ### 1.15.4\n   ```\n   ==========================\n\nThis is a bugfix release for bugs and regressions reported following the 1.15.3\nrelease.  The Python versions supported by this release are 2.7, 3.4-3.7. The\nwheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg\nproblems reported for NumPy 1.14.\n\nCompatibility Note\n==================\n\nThe NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit\nbinaries.  That will also be the case in future releases. See\n`11625 &lt;https://github.com/numpy/numpy/issues/11625&gt;`__ for the related\ndiscussion.  Those needing 32-bit support should look elsewhere or build\nfrom source.\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* Charles Harris\n* Matti Picus\n* Sebastian Berg\n* bbbbbbbbba +\n\nPull requests merged\n====================\n\nA total of 4 pull requests were merged for this release.\n\n* `12296 &lt;https://github.com/numpy/numpy/pull/12296&gt;`__: BUG: Dealloc cached buffer info\n* `12297 &lt;https://github.com/numpy/numpy/pull/12297&gt;`__: BUG: Fix fill value in masked array &#39;==&#39; and &#39;!=&#39; ops.\n* `12307 &lt;https://github.com/numpy/numpy/pull/12307&gt;`__: DOC: Correct the default value of `optimize` in `numpy.einsum`\n* `12320 &lt;https://github.com/numpy/numpy/pull/12320&gt;`__: REL: Prepare for the NumPy 1.15.4 release\n\n\n==========================\n   ```\n   \n  \n  \n   ### 1.15.3\n   ```\n   ==========================\n\nThis is a bugfix release for bugs and regressions reported following the 1.15.2\nrelease.  The Python versions supported by this release are 2.7, 3.4-3.7. The\nwheels are linked with OpenBLAS v0.3.0, which should fix some of the linalg\nproblems reported for NumPy 1.14.\n\nCompatibility Note\n==================\n\nThe NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit\nbinaries.  That will also be the case in future releases. See\n`11625 &lt;https://github.com/numpy/numpy/issues/11625&gt;`__ for the related\ndiscussion.  Those needing 32-bit support should look elsewhere or build\nfrom source.\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* Jeroen Demeyer\n* Kevin Sheppard\n* Matthew Bowden +\n* Matti Picus\n* Tyler Reddy\n\nPull requests merged\n====================\n\nA total of 12 pull requests were merged for this release.\n\n* `12080 &lt;https://github.com/numpy/numpy/pull/12080&gt;`__: MAINT: Blacklist some MSVC complex functions.\n* `12083 &lt;https://github.com/numpy/numpy/pull/12083&gt;`__: TST: Add azure CI testing to 1.15.x branch.\n* `12084 &lt;https://github.com/numpy/numpy/pull/12084&gt;`__: BUG: test_path() now uses Path.resolve()\n* `12085 &lt;https://github.com/numpy/numpy/pull/12085&gt;`__: TST, MAINT: Fix some failing tests on azure-pipelines mac and...\n* `12187 &lt;https://github.com/numpy/numpy/pull/12187&gt;`__: BUG: Fix memory leak in mapping.c\n* `12188 &lt;https://github.com/numpy/numpy/pull/12188&gt;`__: BUG: Allow boolean subtract in histogram\n* `12189 &lt;https://github.com/numpy/numpy/pull/12189&gt;`__: BUG: Fix in-place permutation\n* `12190 &lt;https://github.com/numpy/numpy/pull/12190&gt;`__: BUG: limit default for get_num_build_jobs() to 8\n* `12191 &lt;https://github.com/numpy/numpy/pull/12191&gt;`__: BUG: OBJECT_to_* should check for errors\n* `12192 &lt;https://github.com/numpy/numpy/pull/12192&gt;`__: DOC: Prepare for NumPy 1.15.3 release.\n* `12237 &lt;https://github.com/numpy/numpy/pull/12237&gt;`__: BUG: Fix MaskedArray fill_value type conversion.\n* `12238 &lt;https://github.com/numpy/numpy/pull/12238&gt;`__: TST: Backport azure-pipeline testing fixes for Mac\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.15.2\n   ```\n   ==========================\n\nThis is a bugfix release for bugs and regressions reported following the 1.15.1\nrelease.\n\n* The matrix PendingDeprecationWarning is now suppressed in pytest 3.8.\n* The new cached allocations machinery has been fixed to be thread safe.\n* The boolean indexing of subclasses now works correctly.\n* A small memory leak in PyArray_AdaptFlexibleDType has been fixed.\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\nCompatibility Note\n==================\n\nThe NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit\nbinaries.  That will also be the case in future releases. See\n`11625 &lt;https://github.com/numpy/numpy/issues/11625&gt;`__ for the related\ndiscussion.  Those needing 32-bit support should look elsewhere or build\nfrom source.\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* Charles Harris\n* Julian Taylor\n* Marten van Kerkwijk\n* Matti Picus\n\nPull requests merged\n====================\n\nA total of 4 pull requests were merged for this release.\n\n* `11902 &lt;https://github.com/numpy/numpy/pull/11902&gt;`__: BUG: Fix matrix PendingDeprecationWarning suppression for pytest...\n* `11981 &lt;https://github.com/numpy/numpy/pull/11981&gt;`__: BUG: fix cached allocations without the GIL for 1.15.x\n* `11982 &lt;https://github.com/numpy/numpy/pull/11982&gt;`__: BUG: fix refcount leak in PyArray_AdaptFlexibleDType\n* `11992 &lt;https://github.com/numpy/numpy/pull/11992&gt;`__: BUG: Ensure boolean indexing of subclasses sets base correctly.\n\n\n=========================\n   ```\n   \n  \n  \n   ### 1.15.1\n   ```\n   ==========================\n\nThis is a bugfix release for bugs and regressions reported following the 1.15.0\nrelease.\n\n* The annoying but harmless RuntimeWarning that &quot;numpy.dtype size changed&quot; has\n  been suppressed. The long standing suppression was lost in the transition to\n  pytest.\n* The update to Cython 0.28.3 exposed a problematic use of a gcc attribute used\n  to prefer code size over speed in module initialization, possibly resulting in\n  incorrect compiled code. This has been fixed in latest Cython but has been\n  disabled here for safety.\n* Support for big-endian and ARMv8 architectures has been improved.\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\nCompatibility Note\n==================\n\nThe NumPy 1.15.x OS X wheels released on PyPI no longer contain 32-bit\nbinaries.  That will also be the case in future releases. See\n`11625 &lt;https://github.com/numpy/numpy/issues/11625&gt;`__ for the related\ndiscussion.  Those needing 32-bit support should look elsewhere or build\nfrom source.\n\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* Charles Harris\n* Chris Billington\n* Elliott Sales de Andrade +\n* Eric Wieser\n* Jeremy Manning +\n* Matti Picus\n* Ralf Gommers\n\nPull requests merged\n====================\n\nA total of 24 pull requests were merged for this release.\n\n* `11647 &lt;https://github.com/numpy/numpy/pull/11647&gt;`__: MAINT: Filter Cython warnings in ``__init__.py``\n* `11648 &lt;https://github.com/numpy/numpy/pull/11648&gt;`__: BUG: Fix doc source links to unwrap decorators\n* `11657 &lt;https://github.com/numpy/numpy/pull/11657&gt;`__: BUG: Ensure singleton dimensions are not dropped when converting...\n* `11661 &lt;https://github.com/numpy/numpy/pull/11661&gt;`__: BUG: Warn on Nan in minimum,maximum for scalars\n* `11665 &lt;https://github.com/numpy/numpy/pull/11665&gt;`__: BUG: cython sometimes emits invalid gcc attribute\n* `11682 &lt;https://github.com/numpy/numpy/pull/11682&gt;`__: BUG: Fix regression in void_getitem\n* `11698 &lt;https://github.com/numpy/numpy/pull/11698&gt;`__: BUG: Make matrix_power again work for object arrays.\n* `11700 &lt;https://github.com/numpy/numpy/pull/11700&gt;`__: BUG: Add missing PyErr_NoMemory after failing malloc\n* `11719 &lt;https://github.com/numpy/numpy/pull/11719&gt;`__: BUG: Fix undefined functions on big-endian systems.\n* `11720 &lt;https://github.com/numpy/numpy/pull/11720&gt;`__: MAINT: Make einsum optimize default to False.\n* `11746 &lt;https://github.com/numpy/numpy/pull/11746&gt;`__: BUG: Fix regression in loadtxt for bz2 text files in Python 2.\n* `11757 &lt;https://github.com/numpy/numpy/pull/11757&gt;`__: BUG: Revert use of `console_scripts`.\n* `11758 &lt;https://github.com/numpy/numpy/pull/11758&gt;`__: BUG: Fix Fortran kind detection for aarch64 &amp; s390x.\n* `11759 &lt;https://github.com/numpy/numpy/pull/11759&gt;`__: BUG: Fix printing of longdouble on ppc64le.\n* `11760 &lt;https://github.com/numpy/numpy/pull/11760&gt;`__: BUG: Fixes for unicode field names in Python 2\n* `11761 &lt;https://github.com/numpy/numpy/pull/11761&gt;`__: BUG: Increase required cython version on python 3.7\n* `11763 &lt;https://github.com/numpy/numpy/pull/11763&gt;`__: BUG: check return value of _buffer_format_string\n* `11775 &lt;https://github.com/numpy/numpy/pull/11775&gt;`__: MAINT: Make assert_array_compare more generic.\n* `11776 &lt;https://github.com/numpy/numpy/pull/11776&gt;`__: TST: Fix urlopen stubbing.\n* `11777 &lt;https://github.com/numpy/numpy/pull/11777&gt;`__: BUG: Fix regression in intersect1d.\n* `11779 &lt;https://github.com/numpy/numpy/pull/11779&gt;`__: BUG: Fix test sensitive to platform byte order.\n* `11781 &lt;https://github.com/numpy/numpy/pull/11781&gt;`__: BUG: Avoid signed overflow in histogram\n* `11785 &lt;https://github.com/numpy/numpy/pull/11785&gt;`__: BUG: Fix pickle and memoryview for datetime64, timedelta64 scalars\n* `11786 &lt;https://github.com/numpy/numpy/pull/11786&gt;`__: BUG: Deprecation triggers segfault\n\n\n==========================\n   ```\n   \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 dimensio","created_at":"2019-04-24T07:30:22Z","updated_at":"2019-04-24T07:39:33Z","closed_at":"2019-04-24T07:39:33Z","merged_at":null,"merge_commit_sha":"71390ffbfdfb4140cad0bb87b60d6074dc466797","assignee":null,"assignees":[],"requested_reviewers":[],"requested_teams":[],"labels":[],"milestone":null,"commits_url":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/231/commits","review_comments_url":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/231/comments","review_comment_url":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/comments{/number}","comments_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/231/comments","statuses_url":"https://api.github.com/repos/inbo/niche_vlaanderen/statuses/b4a4c7e9e118c9d354f5a80a5099c45e28a2fd40","head":{"label":"inbo:pyup-pin-numpy-1.16.3","ref":"pyup-pin-numpy-1.16.3","sha":"b4a4c7e9e118c9d354f5a80a5099c45e28a2fd40","user":{"login":"inbo","id":2735610,"node_id":"MDEyOk9yZ2FuaXphdGlvbjI3MzU2MTA=","avatar_url":"https://avatars1.githubusercontent.com/u/2735610?v=4","gravatar_id":"","url":"https://api.github.com/users/inbo","html_url":"https://github.com/inbo","followers_url":"https://api.github.com/users/inbo/followers","following_url":"https://api.github.com/users/inbo/following{/other_user}","gists_url":"https://api.github.com/users/inbo/gists{/gist_id}","starred_url":"https://api.github.com/users/inbo/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/inbo/subscriptions","organizations_url":"https://api.github.com/users/inbo/orgs","repos_url":"https://api.github.com/users/inbo/repos","events_url":"https://api.github.com/users/inbo/events{/privacy}","received_events_url":"https://api.github.com/users/inbo/received_events","type":"Organization","site_admin":false},"repo":{"id":102339389,"node_id":"MDEwOlJlcG9zaXRvcnkxMDIzMzkzODk=","name":"niche_vlaanderen","full_name":"inbo/niche_vlaanderen","private":false,"owner":{"login":"inbo","id":2735610,"node_id":"MDEyOk9yZ2FuaXphdGlvbjI3MzU2MTA=","avatar_url":"https://avatars1.githubusercontent.com/u/2735610?v=4","gravatar_id":"","url":"https://api.github.com/users/inbo","html_url":"https://github.com/inbo","followers_url":"https://api.github.com/users/inbo/followers","following_url":"https://api.github.com/users/inbo/following{/other_user}","gists_url":"https://api.github.com/users/inbo/gists{/gist_id}","starred_url":"https://api.github.com/users/inbo/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/inbo/subscriptions","organizations_url":"https://api.github.com/users/inbo/orgs","repos_url":"https://api.github.com/users/inbo/repos","events_url":"https://api.github.com/users/inbo/events{/privacy}","received_events_url":"https://api.github.com/users/inbo/received_events","type":"Organization","site_admin":false},"html_url":"https://github.com/inbo/niche_vlaanderen","description":"Python package to run the NICHE Vlaanderen model","fork":false,"url":"https://api.github.com/repos/inbo/niche_vlaanderen","forks_url":"https://api.github.com/repos/inbo/niche_vlaanderen/forks","keys_url":"https://api.github.com/repos/inbo/niche_vlaanderen/keys{/key_id}","collaborators_url":"https://api.github.com/repos/inbo/niche_vlaanderen/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/inbo/niche_vlaanderen/teams","hooks_url":"https://api.github.com/repos/inbo/niche_vlaanderen/hooks","issue_events_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/events{/number}","events_url":"https://api.github.com/repos/inbo/niche_vlaanderen/events","assignees_url":"https://api.github.com/repos/inbo/niche_vlaanderen/assignees{/user}","branches_url":"https://api.github.com/repos/inbo/niche_vlaanderen/branches{/branch}","tags_url":"https://api.github.com/repos/inbo/niche_vlaanderen/tags","blobs_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/refs{/sha}","trees_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/trees{/sha}","statuses_url":"https://api.github.com/repos/inbo/niche_vlaanderen/statuses/{sha}","languages_url":"https://api.github.com/repos/inbo/niche_vlaanderen/languages","stargazers_url":"https://api.github.com/repos/inbo/niche_vlaanderen/stargazers","contributors_url":"https://api.github.com/repos/inbo/niche_vlaanderen/contributors","subscribers_url":"https://api.github.com/repos/inbo/niche_vlaanderen/subscribers","subscription_url":"https://api.github.com/repos/inbo/niche_vlaanderen/subscription","commits_url":"https://api.github.com/repos/inbo/niche_vlaanderen/commits{/sha}","git_commits_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/commits{/sha}","comments_url":"https://api.github.com/repos/inbo/niche_vlaanderen/comments{/number}","issue_comment_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/comments{/number}","contents_url":"https://api.github.com/repos/inbo/niche_vlaanderen/contents/{+path}","compare_url":"https://api.github.com/repos/inbo/niche_vlaanderen/compare/{base}...{head}","merges_url":"https://api.github.com/repos/inbo/niche_vlaanderen/merges","archive_url":"https://api.github.com/repos/inbo/niche_vlaanderen/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/inbo/niche_vlaanderen/downloads","issues_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues{/number}","pulls_url":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls{/number}","milestones_url":"https://api.github.com/repos/inbo/niche_vlaanderen/milestones{/number}","notifications_url":"https://api.github.com/repos/inbo/niche_vlaanderen/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/inbo/niche_vlaanderen/labels{/name}","releases_url":"https://api.github.com/repos/inbo/niche_vlaanderen/releases{/id}","deployments_url":"https://api.github.com/repos/inbo/niche_vlaanderen/deployments","created_at":"2017-09-04T08:46:29Z","updated_at":"2019-04-24T07:33:06Z","pushed_at":"2019-04-24T07:34:52Z","git_url":"git://github.com/inbo/niche_vlaanderen.git","ssh_url":"git@github.com:inbo/niche_vlaanderen.git","clone_url":"https://github.com/inbo/niche_vlaanderen.git","svn_url":"https://github.com/inbo/niche_vlaanderen","homepage":"https://inbo.github.io/niche_vlaanderen/","size":19339,"stargazers_count":2,"watchers_count":2,"language":"Python","has_issues":true,"has_projects":false,"has_downloads":true,"has_wiki":false,"has_pages":true,"forks_count":1,"mirror_url":null,"archived":false,"disabled":false,"open_issues_count":22,"license":{"key":"mit","name":"MIT License","spdx_id":"MIT","url":"https://api.github.com/licenses/mit","node_id":"MDc6TGljZW5zZTEz"},"forks":1,"open_issues":22,"watchers":2,"default_branch":"master"}},"base":{"label":"inbo:master","ref":"master","sha":"0128a610bc9474e584fe94c49ba5860509fea180","user":{"login":"inbo","id":2735610,"node_id":"MDEyOk9yZ2FuaXphdGlvbjI3MzU2MTA=","avatar_url":"https://avatars1.githubusercontent.com/u/2735610?v=4","gravatar_id":"","url":"https://api.github.com/users/inbo","html_url":"https://github.com/inbo","followers_url":"https://api.github.com/users/inbo/followers","following_url":"https://api.github.com/users/inbo/following{/other_user}","gists_url":"https://api.github.com/users/inbo/gists{/gist_id}","starred_url":"https://api.github.com/users/inbo/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/inbo/subscriptions","organizations_url":"https://api.github.com/users/inbo/orgs","repos_url":"https://api.github.com/users/inbo/repos","events_url":"https://api.github.com/users/inbo/events{/privacy}","received_events_url":"https://api.github.com/users/inbo/received_events","type":"Organization","site_admin":false},"repo":{"id":102339389,"node_id":"MDEwOlJlcG9zaXRvcnkxMDIzMzkzODk=","name":"niche_vlaanderen","full_name":"inbo/niche_vlaanderen","private":false,"owner":{"login":"inbo","id":2735610,"node_id":"MDEyOk9yZ2FuaXphdGlvbjI3MzU2MTA=","avatar_url":"https://avatars1.githubusercontent.com/u/2735610?v=4","gravatar_id":"","url":"https://api.github.com/users/inbo","html_url":"https://github.com/inbo","followers_url":"https://api.github.com/users/inbo/followers","following_url":"https://api.github.com/users/inbo/following{/other_user}","gists_url":"https://api.github.com/users/inbo/gists{/gist_id}","starred_url":"https://api.github.com/users/inbo/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/inbo/subscriptions","organizations_url":"https://api.github.com/users/inbo/orgs","repos_url":"https://api.github.com/users/inbo/repos","events_url":"https://api.github.com/users/inbo/events{/privacy}","received_events_url":"https://api.github.com/users/inbo/received_events","type":"Organization","site_admin":false},"html_url":"https://github.com/inbo/niche_vlaanderen","description":"Python package to run the NICHE Vlaanderen model","fork":false,"url":"https://api.github.com/repos/inbo/niche_vlaanderen","forks_url":"https://api.github.com/repos/inbo/niche_vlaanderen/forks","keys_url":"https://api.github.com/repos/inbo/niche_vlaanderen/keys{/key_id}","collaborators_url":"https://api.github.com/repos/inbo/niche_vlaanderen/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/inbo/niche_vlaanderen/teams","hooks_url":"https://api.github.com/repos/inbo/niche_vlaanderen/hooks","issue_events_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/events{/number}","events_url":"https://api.github.com/repos/inbo/niche_vlaanderen/events","assignees_url":"https://api.github.com/repos/inbo/niche_vlaanderen/assignees{/user}","branches_url":"https://api.github.com/repos/inbo/niche_vlaanderen/branches{/branch}","tags_url":"https://api.github.com/repos/inbo/niche_vlaanderen/tags","blobs_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/refs{/sha}","trees_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/trees{/sha}","statuses_url":"https://api.github.com/repos/inbo/niche_vlaanderen/statuses/{sha}","languages_url":"https://api.github.com/repos/inbo/niche_vlaanderen/languages","stargazers_url":"https://api.github.com/repos/inbo/niche_vlaanderen/stargazers","contributors_url":"https://api.github.com/repos/inbo/niche_vlaanderen/contributors","subscribers_url":"https://api.github.com/repos/inbo/niche_vlaanderen/subscribers","subscription_url":"https://api.github.com/repos/inbo/niche_vlaanderen/subscription","commits_url":"https://api.github.com/repos/inbo/niche_vlaanderen/commits{/sha}","git_commits_url":"https://api.github.com/repos/inbo/niche_vlaanderen/git/commits{/sha}","comments_url":"https://api.github.com/repos/inbo/niche_vlaanderen/comments{/number}","issue_comment_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/comments{/number}","contents_url":"https://api.github.com/repos/inbo/niche_vlaanderen/contents/{+path}","compare_url":"https://api.github.com/repos/inbo/niche_vlaanderen/compare/{base}...{head}","merges_url":"https://api.github.com/repos/inbo/niche_vlaanderen/merges","archive_url":"https://api.github.com/repos/inbo/niche_vlaanderen/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/inbo/niche_vlaanderen/downloads","issues_url":"https://api.github.com/repos/inbo/niche_vlaanderen/issues{/number}","pulls_url":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls{/number}","milestones_url":"https://api.github.com/repos/inbo/niche_vlaanderen/milestones{/number}","notifications_url":"https://api.github.com/repos/inbo/niche_vlaanderen/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/inbo/niche_vlaanderen/labels{/name}","releases_url":"https://api.github.com/repos/inbo/niche_vlaanderen/releases{/id}","deployments_url":"https://api.github.com/repos/inbo/niche_vlaanderen/deployments","created_at":"2017-09-04T08:46:29Z","updated_at":"2019-04-24T07:33:06Z","pushed_at":"2019-04-24T07:34:52Z","git_url":"git://github.com/inbo/niche_vlaanderen.git","ssh_url":"git@github.com:inbo/niche_vlaanderen.git","clone_url":"https://github.com/inbo/niche_vlaanderen.git","svn_url":"https://github.com/inbo/niche_vlaanderen","homepage":"https://inbo.github.io/niche_vlaanderen/","size":19339,"stargazers_count":2,"watchers_count":2,"language":"Python","has_issues":true,"has_projects":false,"has_downloads":true,"has_wiki":false,"has_pages":true,"forks_count":1,"mirror_url":null,"archived":false,"disabled":false,"open_issues_count":22,"license":{"key":"mit","name":"MIT License","spdx_id":"MIT","url":"https://api.github.com/licenses/mit","node_id":"MDc6TGljZW5zZTEz"},"forks":1,"open_issues":22,"watchers":2,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/231"},"html":{"href":"https://github.com/inbo/niche_vlaanderen/pull/231"},"issue":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/231"},"comments":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/issues/231/comments"},"review_comments":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/231/comments"},"review_comment":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/pulls/231/commits"},"statuses":{"href":"https://api.github.com/repos/inbo/niche_vlaanderen/statuses/b4a4c7e9e118c9d354f5a80a5099c45e28a2fd40"}},"author_association":"CONTRIBUTOR","merged":false,"mergeable":null,"rebaseable":null,"mergeable_state":"unknown","merged_by":null,"comments":0,"review_comments":0,"maintainer_can_modify":false,"commits":1,"additions":1,"deletions":1,"changed_files":1}}
other: {"actor":{"display_login":"johanvdw"}}