RF: Make _gzip_open a bit cleaner and simpler. Move the DummyLock out of

read_segments, and to the model level. Cleaned up ArrayProxy._get_fileobj
docs (and replaced all triple-single quotes with triple-double quotes)

Author: pauldmccarthy

nibabel/arrayproxy.py

@@ -135,21 +135,21 @@ def __init__(self, file_like, spec, mmap=True, keep_file_open=False):
         self._lock = Lock()
 
     def __del__(self):
-        '''If this ``ArrayProxy`` was created with ``keep_file_open=True``,
+        """If this ``ArrayProxy`` was created with ``keep_file_open=True``,
         the open file object is closed if necessary.
-        '''
+        """
         if hasattr(self, '_opener') and not self._opener.closed:
             self._opener.close()
             self._opener = None
 
     def __getstate__(self):
-        '''Returns the state of this ``ArrayProxy`` during pickling. '''
+        """Returns the state of this ``ArrayProxy`` during pickling. """
         state = self.__dict__.copy()
         state.pop('_lock', None)
         return state
 
     def __setstate__(self, state):
-        '''Sets the state of this ``ArrayProxy`` during unpickling. '''
+        """Sets the state of this ``ArrayProxy`` during unpickling. """
         self.__dict__.update(state)
         self._lock = Lock()
 
@@ -184,10 +184,18 @@ def is_proxy(self):
 
     @contextmanager
     def _get_fileobj(self):
-        '''Create and return a new ``ImageOpener``, or return an existing one.
-        one. The specific behaviour depends on the value of the
-        ``keep_file_open`` flag that was passed to ``__init__``.
-        '''
+        """Create and return a new ``ImageOpener``, or return an existing one.
+
+        The specific behaviour depends on the value of the ``keep_file_open``
+        flag that was passed to ``__init__``.
+
+
+        Yields
+        ------
+        ImageOpener
+            A newly created ``ImageOpener`` instance, or an existing one,
+            which provides access to the file.
+        """
         if self._keep_file_open:
             if not hasattr(self, '_opener'):
                 self._opener = ImageOpener(self.file_like)
@@ -197,10 +205,10 @@ def _get_fileobj(self):
                 yield opener
 
     def get_unscaled(self):
-        ''' Read of data from file
+        """ Read of data from file
 
         This is an optional part of the proxy API
-        '''
+        """
         with self._get_fileobj() as fileobj:
             raw_data = array_from_file(self._shape,
                                        self._dtype,
@@ -228,7 +236,7 @@ def __getitem__(self, slicer):
         return apply_read_scaling(raw_data, self._slope, self._inter)
 
     def reshape(self, shape):
-        ''' Return an ArrayProxy with a new shape, without modifying data '''
+        """ Return an ArrayProxy with a new shape, without modifying data """
         size = np.prod(self._shape)
 
         # Calculate new shape if not fully specified

nibabel/fileslice.py

@@ -17,6 +17,21 @@
 SKIP_THRESH = 2 ** 8
 
 
+
+class _NullLock(object):
+    """The ``_NullLock`` is an object which can be used in place of a
+    ``threading.Lock`` object, but doesn't actually do anything.
+
+    It is used by the ``read_segments`` function in the event that a
+    ``Lock`` is not provided by the caller.
+    """
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
 def is_fancy(sliceobj):
     """ Returns True if sliceobj is attempting fancy indexing
 
@@ -647,17 +662,9 @@ def read_segments(fileobj, segments, n_bytes, lock=None):
         object implementing buffer protocol, such as byte string or ndarray or
         mmap or ctypes ``c_char_array``
     """
-    # Make a dummy lock-like thing to make the code below a bit nicer
+    # Make a lock-like thing to make the code below a bit nicer
     if lock is None:
-
-        class DummyLock(object):
-            def __enter__(self):
-                pass
-
-            def __exit__(self, exc_type, exc_val, exc_tb):
-                return False
-
-        lock = DummyLock()
+        lock = _NullLock()
 
     if len(segments) == 0:
         if n_bytes != 0:

nibabel/openers.py

@@ -70,20 +70,18 @@ def _gzip_open(fileish, mode='rb', compresslevel=9):
         have_indexed_gzip = False
 
     # is this a file? if not we assume it is a string
-    is_file = (hasattr(fileish, 'read') and hasattr(fileish, 'write') and
-               hasattr(fileish, 'mode'))
+    is_file = hasattr(fileish, 'read') and hasattr(fileish, 'write')
 
     # If we've been given a file object, we can't change its mode.
-    if is_file:
+    if is_file and hasattr(fileish, 'mode'):
         mode = fileish.mode
 
     # use indexed_gzip if possible for faster read access
     if mode == 'rb' and have_indexed_gzip:
-        kwargs = {'spacing':4194304, 'readbuf_size':1048576}
-        if hasattr(fileish, 'read') and hasattr(fileish, 'write'):
-            gzip_file = SafeIndexedGzipFile(fid=fileish, **kwargs)
+        if is_file:
+            gzip_file = SafeIndexedGzipFile(fid=fileish)
         else:
-            gzip_file = SafeIndexedGzipFile(filename=fileish, **kwargs)
+            gzip_file = SafeIndexedGzipFile(filename=fileish)
 
     # Fall-back to built-in GzipFile (wrapped with the BufferedGzipFile class
     # defined above)