RF - fill out arrayproxy object and add tests

Arrayproxy was previously a partly-specified API.  Fill out the API with
the analyze implementation and add tests.

Author: matthew-brett

nibabel/arrayproxy.py

@@ -6,14 +6,48 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-''' Array proxy base class '''
+""" Array proxy base class
+
+The API is - at minimum:
+
+* The object has an attribute ``shape``
+* that the object returns the data array from ``np.asarray(obj)``
+* that modifying no object outside ``obj`` will affect the result of
+  ``np.asarray(obj)``.  Specifically, if you pass a header into the the
+  __init__, then modifying the original header will not affect the result of the
+  array return.
+
+You might also want to implement ``state_stamper``
+"""
+
+from .volumeutils import allopen
+
 
 class ArrayProxy(object):
+    """
+    The array proxy allows us to freeze the passed fileobj and header such that
+    it returns the expected data array.
+
+    This fairly generic implementation allows us to deal with Analyze and its
+    variants, including Nifti1, and with the MGH format, apparently.
+
+    It requires a ``header`` object with methods:
+    * copy
+    * get_data_shape
+    * data_from_fileobj
+
+    Other image types might need to implement their own implementation of this
+    API.  See :mod:`minc` for an example.
+    """
     def __init__(self, file_like, header):
         self.file_like = file_like
         self.header = header.copy()
         self._data = None
-        self.shape = header.get_data_shape()
+        self._shape = header.get_data_shape()
+
+    @property
+    def shape(self):
+        return self._shape
 
     def __array__(self):
         ''' Cached read of data from file '''
@@ -22,6 +56,10 @@ def __array__(self):
         return self._data
 
     def _read_data(self):
-        raise NotImplementedError
+        fileobj = allopen(self.file_like)
+        data = self.header.data_from_fileobj(fileobj)
+        if isinstance(self.file_like, basestring):  # filename
+            fileobj.close()
+        return data
 
 

nibabel/tests/test_arrayproxy.py

@@ -0,0 +1,88 @@
+# emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+#
+#   See COPYING file distributed along with the NiBabel package for the
+#   copyright and license terms.
+#
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+""" Tests for arrayproxy module
+"""
+from __future__ import with_statement
+
+from copy import deepcopy
+
+from ..py3k import BytesIO, ZEROB, asbytes
+from ..tmpdirs import InTemporaryDirectory
+
+import numpy as np
+
+from ..arrayproxy import ArrayProxy
+from ..nifti1 import Nifti1Header
+
+from numpy.testing import assert_array_equal, assert_array_almost_equal
+from nose.tools import (assert_true, assert_false, assert_equal,
+                        assert_not_equal, assert_raises)
+
+
+class FunkyHeader(object):
+    def __init__(self, shape):
+        self.shape = shape
+
+    def copy(self):
+        return self.__class__(self.shape[:])
+
+    def get_data_shape(self):
+        return self.shape[:]
+
+    def data_from_fileobj(self, fileobj):
+        return np.arange(np.prod(self.shape)).reshape(self.shape)
+
+
+def test_init():
+    bio = BytesIO()
+    shape = [2,3,4]
+    hdr = FunkyHeader(shape)
+    ap = ArrayProxy(bio, hdr)
+    assert_true(ap.file_like is bio)
+    assert_equal(ap.shape, shape)
+    # shape should be read only
+    assert_raises(AttributeError, setattr, ap, 'shape', shape)
+    # Check there has been a copy of the header
+    assert_false(ap.header is hdr)
+    # Check we can modify the original header without changing the ap version
+    hdr.shape[0] = 6
+    assert_not_equal(ap.shape, shape)
+    # Get the data
+    assert_array_equal(np.asarray(ap), np.arange(24).reshape((2,3,4)))
+
+
+def write_raw_data(arr, hdr, fileobj):
+    hdr.set_data_shape(arr.shape)
+    hdr.set_data_dtype(arr.dtype)
+    fileobj.write(ZEROB * hdr.get_data_offset())
+    fileobj.write(arr.tostring(order='F'))
+
+
+def test_nifti1_init():
+    bio = BytesIO()
+    shape = (2,3,4)
+    hdr = Nifti1Header()
+    arr = np.arange(24, dtype=np.int16).reshape(shape)
+    write_raw_data(arr, hdr, bio)
+    hdr.set_slope_inter(2, 10)
+    ap = ArrayProxy(bio, hdr)
+    assert_true(ap.file_like == bio)
+    assert_equal(ap.shape, shape)
+    # Check there has been a copy of the header
+    assert_false(ap.header is hdr)
+    # Get the data
+    assert_array_equal(np.asarray(ap), arr * 2.0 + 10)
+    with InTemporaryDirectory():
+        f = open('test.nii', 'wb')
+        write_raw_data(arr, hdr, f)
+        f.close()
+        ap = ArrayProxy('test.nii', hdr)
+        assert_true(ap.file_like == 'test.nii')
+        assert_equal(ap.shape, shape)
+        assert_array_equal(np.asarray(ap), arr * 2.0 + 10)