io: retrofit classes wih destructors into context-mans

smmap/buf.py

@@ -47,6 +47,12 @@ def __init__(self, cursor=None, offset=0, size=sys.maxsize, flags=0):
     def __del__(self):
         self.end_access()
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.end_access()
+
     def __len__(self):
         return self._size
 
@@ -83,15 +89,15 @@ def __getslice__(self, i, j):
             # in the previous iteration of this code
             pyvers = sys.version_info[:2]
             if (3, 0) <= pyvers <= (3, 3):
-                # Memory view cannot be joined below python 3.4 ... 
+                # Memory view cannot be joined below python 3.4 ...
                 out = bytes()
                 while l:
                     c.use_region(ofs, l)
                     assert c.is_valid()
                     d = c.buffer()[:l]
                     ofs += len(d)
                     l -= len(d)
-                    # This is slower than the join ... but what can we do ... 
+                    # This is slower than the join ... but what can we do ...
                     out += d
                     del(d)
                 # END while there are bytes to read
@@ -104,7 +110,7 @@ def __getslice__(self, i, j):
                     d = c.buffer()[:l]
                     ofs += len(d)
                     l -= len(d)
-                    # Make sure we don't keep references, as c.use_region() might attempt to free resources, but 
+                    # Make sure we don't keep references, as c.use_region() might attempt to free resources, but
                     # can't unless we use pure bytes
                     if hasattr(d, 'tobytes'):
                         d = d.tobytes()

smmap/mman.py

@@ -46,6 +46,12 @@ def __init__(self, manager=None, regions=None):
     def __del__(self):
         self._destroy()
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._destroy()
+
     def _destroy(self):
         """Destruction code to decrement counters"""
         self.unuse_region()

smmap/test/lib.py

@@ -21,10 +21,9 @@ def __init__(self, size, prefix=''):
         self._path = tempfile.mktemp(prefix=prefix)
         self._size = size
 
-        fp = open(self._path, "wb")
-        fp.seek(size - 1)
-        fp.write(b'1')
-        fp.close()
+        with open(self._path, "wb") as fp:
+            fp.seek(size - 1)
+            fp.write(b'1')
 
         assert os.path.getsize(self.path) == size
 
@@ -35,6 +34,12 @@ def __del__(self):
             pass
         # END exception handling
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.__del__()
+
     @property
     def path(self):
         return self._path

smmap/test/test_buf.py

@@ -25,104 +25,104 @@
 class TestBuf(TestBase):
 
     def test_basics(self):
-        fc = FileCreator(self.k_window_test_size, "buffer_test")
-
-        # invalid paths fail upon construction
-        c = man_optimal.make_cursor(fc.path)
-        self.assertRaises(ValueError, SlidingWindowMapBuffer, type(c)())            # invalid cursor
-        self.assertRaises(ValueError, SlidingWindowMapBuffer, c, fc.size)       # offset too large
-
-        buf = SlidingWindowMapBuffer()                                              # can create uninitailized buffers
-        assert buf.cursor() is None
-
-        # can call end access any time
-        buf.end_access()
-        buf.end_access()
-        assert len(buf) == 0
-
-        # begin access can revive it, if the offset is suitable
-        offset = 100
-        assert buf.begin_access(c, fc.size) == False
-        assert buf.begin_access(c, offset) == True
-        assert len(buf) == fc.size - offset
-        assert buf.cursor().is_valid()
-
-        # empty begin access keeps it valid on the same path, but alters the offset
-        assert buf.begin_access() == True
-        assert len(buf) == fc.size
-        assert buf.cursor().is_valid()
-
-        # simple access
-        with open(fc.path, 'rb') as fp:
-            data = fp.read()
-        assert data[offset] == buf[0]
-        assert data[offset:offset * 2] == buf[0:offset]
-
-        # negative indices, partial slices
-        assert buf[-1] == buf[len(buf) - 1]
-        assert buf[-10:] == buf[len(buf) - 10:len(buf)]
-
-        # end access makes its cursor invalid
-        buf.end_access()
-        assert not buf.cursor().is_valid()
-        assert buf.cursor().is_associated()         # but it remains associated
-
-        # an empty begin access fixes it up again
-        assert buf.begin_access() == True and buf.cursor().is_valid()
-        del(buf)        # ends access automatically
-        del(c)
-
-        assert man_optimal.num_file_handles() == 1
-
-        # PERFORMANCE
-        # blast away with random access and a full mapping - we don't want to
-        # exaggerate the manager's overhead, but measure the buffer overhead
-        # We do it once with an optimal setting, and with a worse manager which
-        # will produce small mappings only !
-        max_num_accesses = 100
-        fd = os.open(fc.path, os.O_RDONLY)
-        for item in (fc.path, fd):
-            for manager, man_id in ((man_optimal, 'optimal'),
-                                    (man_worst_case, 'worst case'),
-                                    (static_man, 'static optimal')):
-                buf = SlidingWindowMapBuffer(manager.make_cursor(item))
-                assert manager.num_file_handles() == 1
-                for access_mode in range(2):    # single, multi
-                    num_accesses_left = max_num_accesses
-                    num_bytes = 0
-                    fsize = fc.size
-
-                    st = time()
-                    buf.begin_access()
-                    while num_accesses_left:
-                        num_accesses_left -= 1
-                        if access_mode:  # multi
-                            ofs_start = randint(0, fsize)
-                            ofs_end = randint(ofs_start, fsize)
-                            d = buf[ofs_start:ofs_end]
-                            assert len(d) == ofs_end - ofs_start
-                            assert d == data[ofs_start:ofs_end]
-                            num_bytes += len(d)
-                            del d
-                        else:
-                            pos = randint(0, fsize)
-                            assert buf[pos] == data[pos]
-                            num_bytes += 1
-                        # END handle mode
-                    # END handle num accesses
-
-                    buf.end_access()
-                    assert manager.num_file_handles()
-                    assert manager.collect()
-                    assert manager.num_file_handles() == 0
-                    elapsed = max(time() - st, 0.001)  # prevent zero division errors on windows
-                    mb = float(1000 * 1000)
-                    mode_str = (access_mode and "slice") or "single byte"
-                    print("%s: Made %i random %s accesses to buffer created from %s reading a total of %f mb in %f s (%f mb/s)"
-                          % (man_id, max_num_accesses, mode_str, type(item), num_bytes / mb, elapsed, (num_bytes / mb) / elapsed),
-                          file=sys.stderr)
-                # END handle access mode
-                del buf
-            # END for each manager
-        # END for each input
-        os.close(fd)
+        with FileCreator(self.k_window_test_size, "buffer_test") as fc:
+
+            # invalid paths fail upon construction
+            c = man_optimal.make_cursor(fc.path)
+            self.assertRaises(ValueError, SlidingWindowMapBuffer, type(c)())            # invalid cursor
+            self.assertRaises(ValueError, SlidingWindowMapBuffer, c, fc.size)       # offset too large
+
+            buf = SlidingWindowMapBuffer()                                              # can create uninitailized buffers
+            assert buf.cursor() is None
+
+            # can call end access any time
+            buf.end_access()
+            buf.end_access()
+            assert len(buf) == 0
+
+            # begin access can revive it, if the offset is suitable
+            offset = 100
+            assert buf.begin_access(c, fc.size) == False
+            assert buf.begin_access(c, offset) == True
+            assert len(buf) == fc.size - offset
+            assert buf.cursor().is_valid()
+
+            # empty begin access keeps it valid on the same path, but alters the offset
+            assert buf.begin_access() == True
+            assert len(buf) == fc.size
+            assert buf.cursor().is_valid()
+
+            # simple access
+            with open(fc.path, 'rb') as fp:
+                data = fp.read()
+            assert data[offset] == buf[0]
+            assert data[offset:offset * 2] == buf[0:offset]
+
+            # negative indices, partial slices
+            assert buf[-1] == buf[len(buf) - 1]
+            assert buf[-10:] == buf[len(buf) - 10:len(buf)]
+
+            # end access makes its cursor invalid
+            buf.end_access()
+            assert not buf.cursor().is_valid()
+            assert buf.cursor().is_associated()         # but it remains associated
+
+            # an empty begin access fixes it up again
+            assert buf.begin_access() == True and buf.cursor().is_valid()
+            del(buf)        # ends access automatically
+            del(c)
+
+            assert man_optimal.num_file_handles() == 1
+
+            # PERFORMANCE
+            # blast away with random access and a full mapping - we don't want to
+            # exaggerate the manager's overhead, but measure the buffer overhead
+            # We do it once with an optimal setting, and with a worse manager which
+            # will produce small mappings only !
+            max_num_accesses = 100
+            fd = os.open(fc.path, os.O_RDONLY)
+            for item in (fc.path, fd):
+                for manager, man_id in ((man_optimal, 'optimal'),
+                                        (man_worst_case, 'worst case'),
+                                        (static_man, 'static optimal')):
+                    buf = SlidingWindowMapBuffer(manager.make_cursor(item))
+                    assert manager.num_file_handles() == 1
+                    for access_mode in range(2):    # single, multi
+                        num_accesses_left = max_num_accesses
+                        num_bytes = 0
+                        fsize = fc.size
+
+                        st = time()
+                        buf.begin_access()
+                        while num_accesses_left:
+                            num_accesses_left -= 1
+                            if access_mode:  # multi
+                                ofs_start = randint(0, fsize)
+                                ofs_end = randint(ofs_start, fsize)
+                                d = buf[ofs_start:ofs_end]
+                                assert len(d) == ofs_end - ofs_start
+                                assert d == data[ofs_start:ofs_end]
+                                num_bytes += len(d)
+                                del d
+                            else:
+                                pos = randint(0, fsize)
+                                assert buf[pos] == data[pos]
+                                num_bytes += 1
+                            # END handle mode
+                        # END handle num accesses
+
+                        buf.end_access()
+                        assert manager.num_file_handles()
+                        assert manager.collect()
+                        assert manager.num_file_handles() == 0
+                        elapsed = max(time() - st, 0.001)  # prevent zero division errors on windows
+                        mb = float(1000 * 1000)
+                        mode_str = (access_mode and "slice") or "single byte"
+                        print("%s: Made %i random %s accesses to buffer created from %s reading a total of %f mb in %f s (%f mb/s)"
+                              % (man_id, max_num_accesses, mode_str, type(item), num_bytes / mb, elapsed, (num_bytes / mb) / elapsed),
+                              file=sys.stderr)
+                    # END handle access mode
+                    del buf
+                # END for each manager
+            # END for each input
+            os.close(fd)