Add trivial try...finally...s to cleanup diff

Author: jakirkham

numcodecs/blosc.pyx

@@ -306,40 +306,44 @@ def compress(source, char* cname, int clevel, int shuffle=SHUFFLE,
         raise ValueError('invalid shuffle argument; expected -1, 0, 1 or 2, found %r' %
                          shuffle)
 
-    # setup destination
-    dest = PyBytes_FromStringAndSize(NULL, nbytes + BLOSC_MAX_OVERHEAD)
-    dest_ptr = PyBytes_AS_STRING(dest)
-
-    # perform compression
-    if _get_use_threads():
-        # allow blosc to use threads internally
-
-        # N.B., we are using blosc's global context, and so we need to use a lock
-        # to ensure no-one else can modify the global context while we're setting it
-        # up and using it.
-        with get_mutex():
-
-            # set compressor
-            compressor_set = blosc_set_compressor(cname)
-            if compressor_set < 0:
-                # shouldn't happen if we checked against list of compressors
-                # already, but just in case
-                _err_bad_cname(cname_str)
-
-            # set blocksize
-            blosc_set_blocksize(blocksize)
-
-            # perform compression
-            with nogil:
-                cbytes = blosc_compress(clevel, shuffle, itemsize, nbytes, source_ptr,
-                                        dest_ptr, nbytes + BLOSC_MAX_OVERHEAD)
+    try:
 
-    else:
-        with nogil:
-            cbytes = blosc_compress_ctx(clevel, shuffle, itemsize, nbytes, source_ptr,
-                                        dest_ptr, nbytes + BLOSC_MAX_OVERHEAD,
-                                        cname, blocksize, 1)
+        # setup destination
+        dest = PyBytes_FromStringAndSize(NULL, nbytes + BLOSC_MAX_OVERHEAD)
+        dest_ptr = PyBytes_AS_STRING(dest)
+
+        # perform compression
+        if _get_use_threads():
+            # allow blosc to use threads internally
+
+            # N.B., we are using blosc's global context, and so we need to use a lock
+            # to ensure no-one else can modify the global context while we're setting it
+            # up and using it.
+            with get_mutex():
 
+                # set compressor
+                compressor_set = blosc_set_compressor(cname)
+                if compressor_set < 0:
+                    # shouldn't happen if we checked against list of compressors
+                    # already, but just in case
+                    _err_bad_cname(cname_str)
+
+                # set blocksize
+                blosc_set_blocksize(blocksize)
+
+                # perform compression
+                with nogil:
+                    cbytes = blosc_compress(clevel, shuffle, itemsize, nbytes, source_ptr,
+                                            dest_ptr, nbytes + BLOSC_MAX_OVERHEAD)
+
+        else:
+            with nogil:
+                cbytes = blosc_compress_ctx(clevel, shuffle, itemsize, nbytes, source_ptr,
+                                            dest_ptr, nbytes + BLOSC_MAX_OVERHEAD,
+                                            cname, blocksize, 1)
+
+    finally:
+        pass
 
     # check compression was successful
     if cbytes <= 0:
@@ -403,19 +407,23 @@ def decompress(source, dest=None):
     dest_ptr = <char*>dest_pb.buf
     dest_nbytes = dest_pb.len
 
-    # guard condition
-    if dest_nbytes < nbytes:
-        raise ValueError('destination buffer too small; expected at least %s, '
-                         'got %s' % (nbytes, dest_nbytes))
+    try:
 
-    # perform decompression
-    if _get_use_threads():
-        # allow blosc to use threads internally
-        with nogil:
-            ret = blosc_decompress(source_ptr, dest_ptr, nbytes)
-    else:
-        with nogil:
-            ret = blosc_decompress_ctx(source_ptr, dest_ptr, nbytes, 1)
+        # guard condition
+        if dest_nbytes < nbytes:
+            raise ValueError('destination buffer too small; expected at least %s, '
+                             'got %s' % (nbytes, dest_nbytes))
+
+        # perform decompression
+        if _get_use_threads():
+            # allow blosc to use threads internally
+            with nogil:
+                ret = blosc_decompress(source_ptr, dest_ptr, nbytes)
+        else:
+            with nogil:
+                ret = blosc_decompress_ctx(source_ptr, dest_ptr, nbytes, 1)
+    finally:
+        pass
 
     # handle errors
     if ret <= 0:
@@ -490,10 +498,13 @@ def _decompress_partial(source, start, nitems, dest=None):
     dest_nbytes = dest_pb.len
 
     # try decompression
-    if dest_nbytes < nitems_bytes:
-        raise ValueError('destination buffer too small; expected at least %s, '
-                         'got %s' % (nitems_bytes, dest_nbytes))
-    ret = blosc_getitem(source_ptr, start, nitems, dest_ptr)
+    try:
+        if dest_nbytes < nitems_bytes:
+            raise ValueError('destination buffer too small; expected at least %s, '
+                             'got %s' % (nitems_bytes, dest_nbytes))
+        ret = blosc_getitem(source_ptr, start, nitems, dest_ptr)
+    finally:
+        pass
 
     # ret refers to the number of bytes returned from blosc_getitem.
     if ret <= 0:

numcodecs/lz4.pyx

@@ -86,17 +86,20 @@ def compress(source, int acceleration=DEFAULT_ACCELERATION):
     source_ptr = <const char*>source_pb.buf
     source_size = source_pb.len
 
-    # setup destination
-    dest_size = LZ4_compressBound(source_size)
-    dest = PyBytes_FromStringAndSize(NULL, dest_size + sizeof(uint32_t))
-    dest_ptr = PyBytes_AS_STRING(dest)
-    store_le32(<uint8_t*>dest_ptr, source_size)
-    dest_start = dest_ptr + sizeof(uint32_t)
-
-    # perform compression
-    with nogil:
-        compressed_size = LZ4_compress_fast(source_ptr, dest_start, source_size, dest_size,
-                                            acceleration)
+    try:
+        # setup destination
+        dest_size = LZ4_compressBound(source_size)
+        dest = PyBytes_FromStringAndSize(NULL, dest_size + sizeof(uint32_t))
+        dest_ptr = PyBytes_AS_STRING(dest)
+        store_le32(<uint8_t*>dest_ptr, source_size)
+        dest_start = dest_ptr + sizeof(uint32_t)
+
+        # perform compression
+        with nogil:
+            compressed_size = LZ4_compress_fast(source_ptr, dest_start, source_size, dest_size,
+                                                acceleration)
+    finally:
+        pass
 
     # check compression was successful
     if compressed_size <= 0:
@@ -145,35 +148,40 @@ def decompress(source, dest=None):
     source_ptr = <const char*>source_pb.buf
     source_size = source_pb.len
 
-    # determine uncompressed size
-    if source_size < sizeof(uint32_t):
-        raise ValueError('bad input data')
-    dest_size = load_le32(<uint8_t*>source_ptr)
-    if dest_size <= 0:
-        raise RuntimeError('LZ4 decompression error: invalid input data')
-    source_start = source_ptr + sizeof(uint32_t)
-    source_size -= sizeof(uint32_t)
-
-    # setup destination buffer
-    if dest is None:
-        # allocate memory
-        dest_1d = dest = PyBytes_FromStringAndSize(NULL, dest_size)
-    else:
-        dest_1d = ensure_contiguous_ndarray(dest)
-
-    # obtain dest memoryview
-    dest_mv = memoryview(dest_1d)
-    dest_pb = PyMemoryView_GET_BUFFER(dest_mv)
-    dest_ptr = <char*>dest_pb.buf
-    dest_nbytes = dest_pb.len
-
-    if dest_nbytes < dest_size:
-        raise ValueError('destination buffer too small; expected at least %s, '
-                         'got %s' % (dest_size, dest_nbytes))
-
-    # perform decompression
-    with nogil:
-        decompressed_size = LZ4_decompress_safe(source_start, dest_ptr, source_size, dest_size)
+    try:
+
+        # determine uncompressed size
+        if source_size < sizeof(uint32_t):
+            raise ValueError('bad input data')
+        dest_size = load_le32(<uint8_t*>source_ptr)
+        if dest_size <= 0:
+            raise RuntimeError('LZ4 decompression error: invalid input data')
+        source_start = source_ptr + sizeof(uint32_t)
+        source_size -= sizeof(uint32_t)
+
+        # setup destination buffer
+        if dest is None:
+            # allocate memory
+            dest_1d = dest = PyBytes_FromStringAndSize(NULL, dest_size)
+        else:
+            dest_1d = ensure_contiguous_ndarray(dest)
+
+        # obtain dest memoryview
+        dest_mv = memoryview(dest_1d)
+        dest_pb = PyMemoryView_GET_BUFFER(dest_mv)
+        dest_ptr = <char*>dest_pb.buf
+        dest_nbytes = dest_pb.len
+
+        if dest_nbytes < dest_size:
+            raise ValueError('destination buffer too small; expected at least %s, '
+                             'got %s' % (dest_size, dest_nbytes))
+
+        # perform decompression
+        with nogil:
+            decompressed_size = LZ4_decompress_safe(source_start, dest_ptr, source_size, dest_size)
+
+    finally:
+        pass
 
     # check decompression was successful
     if decompressed_size <= 0: