From ddb3ed003ecfd5c8d0ddc4880e0c92ac36519d93 Mon Sep 17 00:00:00 2001 From: "R. David Murray" Date: Thu, 11 Feb 2010 02:42:19 +0000 Subject: [PATCH] Merged revisions 78141-78142 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r78141 | r.david.murray | 2010-02-10 20:38:42 -0500 (Wed, 10 Feb 2010) | 6 lines Issue 5754: tweak shelve doc wording to make it clearer that even when writeback=True values are written to the backing store when assigned to the shelf. Add test to confirm that this happens. Doc patch and added test by Robert Lehmann. I also fixed the cross references to the sync and close methods. ........ r78142 | r.david.murray | 2010-02-10 20:56:42 -0500 (Wed, 10 Feb 2010) | 3 lines Improve issue 7835 fix per MAL to handle the case that the module dictionary has also been cleared. ........ --- Doc/library/shelve.rst | 17 +++++++++-------- Lib/shelve.py | 9 +++++---- Lib/test/test_shelve.py | 13 +++++++++++++ 3 files changed, 27 insertions(+), 12 deletions(-) diff --git a/Doc/library/shelve.rst b/Doc/library/shelve.rst index 659811a2961..025259710b5 100644 --- a/Doc/library/shelve.rst +++ b/Doc/library/shelve.rst @@ -27,14 +27,15 @@ lots of shared sub-objects. The keys are ordinary strings. Because of Python semantics, a shelf cannot know when a mutable persistent-dictionary entry is modified. By default modified objects are - written only when assigned to the shelf (see :ref:`shelve-example`). If the - optional *writeback* parameter is set to *True*, all entries accessed are - cached in memory, and written back on :meth:`sync` and :meth:`close`; this - can make it handier to mutate mutable entries in the persistent dictionary, - but, if many entries are accessed, it can consume vast amounts of memory for - the cache, and it can make the close operation very slow since all accessed - entries are written back (there is no way to determine which accessed entries - are mutable, nor which ones were actually mutated). + written *only* when assigned to the shelf (see :ref:`shelve-example`). If the + optional *writeback* parameter is set to *True*, all entries accessed are also + cached in memory, and written back on :meth:`~Shelf.sync` and + :meth:`~Shelf.close`; this can make it handier to mutate mutable entries in + the persistent dictionary, but, if many entries are accessed, it can consume + vast amounts of memory for the cache, and it can make the close operation + very slow since all accessed entries are written back (there is no way to + determine which accessed entries are mutable, nor which ones were actually + mutated). .. note:: diff --git a/Lib/shelve.py b/Lib/shelve.py index 8271dfeddca..52e471ac863 100644 --- a/Lib/shelve.py +++ b/Lib/shelve.py @@ -136,11 +136,12 @@ class Shelf(collections.MutableMapping): self.dict.close() except AttributeError: pass - # _ClosedDict can be None when close is called from __del__ during shutdown - if _ClosedDict is None: - self.dict = None - else: + # Catch errors that may happen when close is called from __del__ + # because CPython is in interpreter shutdown. + try: self.dict = _ClosedDict() + except (NameError, TypeError): + self.dict = None def __del__(self): if not hasattr(self, 'writeback'): diff --git a/Lib/test/test_shelve.py b/Lib/test/test_shelve.py index 9699043fb01..066208a1c07 100644 --- a/Lib/test/test_shelve.py +++ b/Lib/test/test_shelve.py @@ -122,6 +122,19 @@ class TestCase(unittest.TestCase): self.assertEqual(len(d1), 1) self.assertEqual(len(d2), 1) + def test_writeback_also_writes_immediately(self): + # Issue 5754 + d = {} + key = 'key' + encodedkey = key.encode('utf-8') + s = shelve.Shelf(d, writeback=True) + s[key] = [1] + p1 = d[encodedkey] # Will give a KeyError if backing store not updated + s['key'].append(2) + s.close() + p2 = d[encodedkey] + self.assertNotEqual(p1, p2) # Write creates new object in store + from test import mapping_tests