numpy · mattip · Nov 1, 2018 · Jun 15, 2018 · Jun 16, 2018 · Oct 13, 2018
diff --git a/doc/release/1.15.0-notes.rst b/doc/release/1.15.0-notes.rst
@@ -216,6 +216,12 @@ Like ``np.percentile`` and ``np.nanpercentile``, but takes quantiles in [0, 1]
 rather than percentiles in [0, 100]. ``np.percentile`` is now a thin wrapper
 around ``np.quantile`` with the extra step of dividing by 100.
 
+``pathlib.Path`` support for more functions
+-------------------------------------------
+The ``np.core.records.fromfile`` function now supports ``pathlib.Path``
+objects in addition to a string or a file object. Furthermore, the
+``np.load`` function now also supports ``pathlib.Path`` objects when
+using memory mapping (``mmap_mode`` keyword argument).
 
 Build system
 ------------

diff --git a/numpy/core/records.py b/numpy/core/records.py
@@ -42,7 +42,7 @@
 
 from . import numeric as sb
 from . import numerictypes as nt
-from numpy.compat import isfileobj, bytes, long
+from numpy.compat import isfileobj, bytes, long, is_pathlib_path
 from .arrayprint import get_printoptions
 
 # All of the functions allow formats to be a dtype
@@ -737,9 +737,9 @@ def fromfile(fd, dtype=None, shape=None, offset=0, formats=None,
              names=None, titles=None, aligned=False, byteorder=None):
     """Create an array from binary file data
 
-    If file is a string then that file is opened, else it is assumed
-    to be a file object. The file object must support random access
-    (i.e. it must have tell and seek methods).
+    If file is a string or a pathlib.Path then that file is opened,
+    else it is assumed to be a file object. The file object must
+    support random access (i.e. it must have tell and seek methods).
 
     >>> from tempfile import TemporaryFile
     >>> a = np.empty(10,dtype='f8,i4,a5')
@@ -767,6 +767,9 @@ def fromfile(fd, dtype=None, shape=None, offset=0, formats=None,
     if isinstance(fd, str):
         name = 1
         fd = open(fd, 'rb')
+    elif is_pathlib_path(fd):
+        name = 1
+        fd = fd.open('rb')
     if (offset > 0):
         fd.seek(offset, 1)
     size = get_remaining_size(fd)

diff --git a/numpy/core/tests/test_records.py b/numpy/core/tests/test_records.py
@@ -14,9 +14,10 @@
 import pytest
 
 import numpy as np
+from numpy.compat import Path
 from numpy.testing import (
     assert_, assert_equal, assert_array_equal, assert_array_almost_equal,
-    assert_raises, assert_warns
+    assert_raises, assert_warns, temppath
     )
 
 
@@ -325,6 +326,24 @@ def test_zero_width_strings(self):
         assert_equal(rec['f1'], [b'', b'', b''])
 
 
+@pytest.mark.skipif(Path is None, reason="No pathlib.Path")
+class TestPathUsage(object):
+    # Test that pathlib.Path can be used
+    def test_tofile_fromfile(self):
+        with temppath(suffix='.bin') as path:
+            path = Path(path)
+            a = np.empty(10, dtype='f8,i4,a5')
+            a[5] = (0.5,10,'abcde')
+            a.newbyteorder('<')
+            with path.open("wb") as fd:
+                a.tofile(fd)
+            x = np.core.records.fromfile(path,
+                                         formats='f8,i4,a5',
+                                         shape=10,
+                                         byteorder='<')
+            assert_array_equal(x, a)
+
+
 class TestRecord(object):
     def setup(self):
         self.data = np.rec.fromrecords([(1, 2, 3), (4, 5, 6)],

diff --git a/numpy/lib/format.py b/numpy/lib/format.py
@@ -161,7 +161,9 @@
 import io
 import warnings
 from numpy.lib.utils import safe_eval
-from numpy.compat import asbytes, asstr, isfileobj, long, basestring
+from numpy.compat import (
+    asbytes, asstr, isfileobj, long, basestring, is_pathlib_path
+    )
 
 if sys.version_info[0] >= 3:
     import pickle
@@ -709,7 +711,7 @@ def open_memmap(filename, mode='r+', dtype=None, shape=None,
 
     Parameters
     ----------
-    filename : str
+    filename : str or pathlib.Path instance
         The name of the file on disk.  This may *not* be a file-like
         object.
     mode : str, optional
@@ -750,9 +752,9 @@ def open_memmap(filename, mode='r+', dtype=None, shape=None,
     memmap
 
     """
-    if not isinstance(filename, basestring):
-        raise ValueError("Filename must be a string.  Memmap cannot use"
-                         " existing file handles.")
+    if not (isinstance(filename, basestring) or is_pathlib_path(filename)):
+        raise ValueError("Filename must be a string or a pathlib.Path."
+                         "  Memmap cannot use existing file handles.")
 
     if 'w' in mode:
         # We are creating the file, not reading it.
@@ -770,7 +772,10 @@ def open_memmap(filename, mode='r+', dtype=None, shape=None,
             shape=shape,
         )
         # If we got here, then it should be safe to create the file.
-        fp = open(filename, mode+'b')
+        if is_pathlib_path(filename):
+            fp = filename.open(mode+'b')
+        else:
+            fp = open(filename, mode+'b')
         try:
             used_ver = _write_array_header(fp, d, version)
             # this warning can be removed when 1.9 has aged enough
@@ -782,7 +787,10 @@ def open_memmap(filename, mode='r+', dtype=None, shape=None,
             fp.close()
     else:
         # Read the header of the file first.
-        fp = open(filename, 'rb')
+        if is_pathlib_path(filename):
+            fp = filename.open('rb')
+        else:
+            fp = open(filename, 'rb')
         try:
             version = read_magic(fp)
             _check_version(version)

diff --git a/numpy/lib/tests/test_io.py b/numpy/lib/tests/test_io.py
@@ -2252,11 +2252,34 @@ def test_loadtxt(self):
             assert_array_equal(x, a)
 
     def test_save_load(self):
-        # Test that pathlib.Path instances can be used with savez.
+        # Test that pathlib.Path instances can be used with save.
+        with temppath(suffix='.npy') as path:
+            path = Path(path)
+            a = np.array([[1, 2], [3, 4]], int)
+            np.save(path, a)
+            data = np.load(path)
+            assert_array_equal(data, a)
+
+    def test_save_load_memmap(self):
+        # Test that pathlib.Path instances can be loaded mem-mapped.
+        with temppath(suffix='.npy') as path:
+            path = Path(path)
+            a = np.array([[1, 2], [3, 4]], int)
+            np.save(path, a)
+            data = np.load(path, mmap_mode='r')
+            assert_array_equal(data, a)
+            del data
+
+    def test_save_load_memmap_readwrite(self):
+        # Test that pathlib.Path instances can be written mem-mapped.
         with temppath(suffix='.npy') as path:
             path = Path(path)
             a = np.array([[1, 2], [3, 4]], int)
             np.save(path, a)
+            b = np.load(path, mmap_mode='r+')
+            a[0][0] = 5
+            b[0][0] = 5
+            del b  # closes the file
             data = np.load(path)
             assert_array_equal(data, a)