_pickle.UnpicklingError: Memo value not found at index 1

[erik895]

Bug report

Bug description:

When pickling a container object. The pickler class will store child-objects to its self.memo even if the container could not be fully pickled (and not written to the output).
This can cause references to memo objects that are not in the output stream.

import sys
import pickle
import io

buf = io.BytesIO()
pickler = pickle.Pickler(buf)
i_will_be_memorized = 'qqqqqqqqqqqq'
i_cant_be_pickled = sys

try:
    pickler.dump([i_will_be_memorized, i_cant_be_pickled])
except TypeError:
    # i_will_be_memorized is now in pickler memory despite the exception
    pass

# this dump will use the memo
pickler.dump(i_will_be_memorized)

data = buf.getbuffer().tobytes()

# so this will fail with:
#   _pickle.UnpicklingError: Memo value not found at index 1
pickle.loads(data)

CPython versions tested on:

3.12

Operating systems tested on:

Windows

Linked PRs

• gh-125756: Document Pickler.clear_memo #125762
• [3.12] gh-125756: Document Pickler.clear_memo() (GH-125762) #130231
• [3.13] gh-125756: Document Pickler.clear_memo() (GH-125762) #130232

[tomasr8]

There's an undocumented clear_memo function which seems to be intended for this exact case:

This method is useful when re-using picklers

cpython/Lib/pickle.py

Lines 478 to 486 in b3c6b2c

	def clear_memo(self):
	"""Clears the pickler's "memo".
	The memo is the data structure that remembers which objects the
	pickler has already seen, so that shared or recursive objects
	are pickled by reference and not by value. This method is
	useful when re-using picklers.
	"""
	self.memo.clear()

In your case, you could probably do something like this:

try:
    pickler.dump([i_will_be_memorized, i_cant_be_pickled])
except TypeError:
    # i_will_be_memorized is now in pickler memory despite the exception
    pickler.clear_memo()

[erik895]

Thanks for the quick reply! I thought clear_memo was not documented because it’s dangerous to use. When you clear the memo, I don’t think that 'action' gets written to the output, so the loader won’t clear its own memo (I have't checked any code, this is just my observation).

As a result, loading a stream where clear_memo was used could lead to loading the wrong objects. If clear_memo is used publicly, I think it deserves its own issue.

import pickle
import io

buf = io.BytesIO()
pickler = pickle.Pickler(buf)

pickler.dump("foo")
pickler.clear_memo()
pickler.dump("bar")
pickler.dump("bar")

buf.seek(0)
loader = pickle.Unpickler(buf)
print(loader.load()) # prints foo
print(loader.load()) # prints bar
print(loader.load()) # prints foo (I wanted bar)

[serhiy-storchaka]

clear_memo() is incompatible with the MEMOIZE opcode. It works with PUT, BINPUT and LONG_BINPUT, i.e. with protocol <= 3. I do not have good solution for this. Possible solutions:

• Disabling MEMOIZE after clearing the memo.
• Track the next memo index and do not reset it by clear_memo().

This will lead to a silent degradation of pickle size and performance, but at least the result can be correctly unpickled.

We can also introduce an opcode for clearing the memo in the loader, but this is a PEP-level change. I am not sure that we have enough of good use cases for such feature.

cc @pitrou

[serhiy-storchaka]

We can also combine two solutions -- disable MEMOIZE until the memo size achieve its maximal size before clearing. After that, MEMOIZE can be used. It still has impact.

Alternatively, we can deprecate clear_memo(). The user can just create a new Pickler instance with the same output file.

If creating a new Pickler instance for every portion of data is too costly, we should add also clear_memo() in Unpickler, to avoid creating multiple Unpickler instances on the receiving end.

In any case this is a difficult-to-use-correctly feature.