Python：检查对象是否可以原子方式pickle

Question

检查对象是否可以被原子腌制的准确方法是什么？当我说“原子腌制”时，我的意思是不考虑它可能引用的其他对象。例如，这个列表：

l = [threading.Lock()]

不是一个可pickle的对象，因为它引用了一个不可pickle的Lock。但从原子角度来看，这个列表本身是可腌制的。

那么如何检查一个对象是否是原子可腌制的呢？ （我猜应该在班级上进行检查，但我不确定。）

我希望它的行为如下：

>>> is_atomically_pickleable(3)
True
>>> is_atomically_pickleable(3.1)
True
>>> is_atomically_pickleable([1, 2, 3])
True
>>> is_atomically_pickleable(threading.Lock())
False
>>> is_atomically_pickleable(open('whatever', 'r'))
False

等等。

Answer 1

鉴于您愿意打破封装，我认为这是您能做的最好的事情：

from pickle import Pickler
import os

class AtomicPickler(Pickler):
  def __init__(self, protocol):
    # You may want to replace this with a fake file object that just
    # discards writes.
    blackhole = open(os.devnull, 'w')

    Pickler.__init__(self, blackhole, protocol)
    self.depth = 0

  def save(self, o):
    self.depth += 1
    if self.depth == 1:
      return Pickler.save(self, o)
    self.depth -= 1
    return

def is_atomically_pickleable(o, protocol=None):
  pickler = AtomicPickler(protocol)
  try:
    pickler.dump(o)
    return True
  except:
    # Hopefully this exception was actually caused by dump(), and not
    # something like a KeyboardInterrupt
    return False

在 Python 中，您判断某件事是否有效的唯一方法就是尝试它。这就是像 Python 这样动态的语言的本质。您的问题的困难在于您想要区分“顶层”的失败和更深层次的失败。

Pickler.save 本质上是 Python 的 pickling 逻辑的控制中心，因此上面创建了一个修改后的 Pickler，它忽略对其 save 方法的递归调用。在顶级保存中引发的任何异常都将被视为酸洗失败。您可能需要向 except 语句添加限定符。 Python 中不合格的 excepts 通常是一个坏主意，因为异常不仅用于程序错误，还用于诸如 KeyboardInterrupt 和 SystemExit 之类的情况。

对于具有奇怪的自定义酸洗逻辑的类型，这可以给出可以说是假阴性的结果。例如，如果您创建一个自定义的类似列表的类，它不会导致递归调用 Pickler.save ，而是实际上尝试以某种方式自行腌制其元素，然后创建此类的实例如果包含其自定义逻辑无法 pickle 的元素，则 is_atomically_pickleable 将在该实例中返回 False，即使删除有问题的元素会导致对象可 pickle。

另请注意 is_atomically_pickleable 的协议参数。理论上，当使用不同的协议进行腌制时，对象的行为可能会有所不同（尽管这会很奇怪），因此您应该使其与您提供给 dump 的协议参数相匹配。

Answer 2

考虑到 Python 的动态特性，我认为除了启发式方法或白名单之外，没有真正定义明确的方法来完成您所要求的操作。

如果我说：

x = object()

x 是“原子上可腌制的”吗？如果我说：

x.foo = threading.Lock()

？ x 现在是“原子可腌制的”吗？

如果我创建一个始终具有锁定属性的单独类怎么办？如果我从实例中删除该属性会怎样？

Answer 3

我认为 persist_id 接口与您尝试做的事情不太匹配。它设计用于当您的对象应该引用新程序上的等效对象而不是旧程序的副本时使用。您正在尝试过滤掉每个无法腌制的不同对象以及您为什么要尝试这样做。

我认为这是您的代码中存在问题的迹象。您想要 pickle 引用 gui 小部件、文件和锁的对象这一事实表明您正在做一些奇怪的事情。您通常保留的对象类型不应与该类型对象相关或保存对该类型对象的引用。

话虽如此，我认为你最好的选择如下：

class MyPickler(Pickler):
    def save(self, obj):
        try:
             Pickler.save(self, obj)
        except PicklingEror:
             Pickle.save( self, FilteredObject(obj) )

这应该适用于 python 实现，我不保证 C 实现中会发生什么。每个被保存的对象都将被传递给 save 方法。当无法pickle对象时，此方法将引发PicklingError。此时，您可以介入并调用该函数，要求它腌制您自己的对象，该对象应该可以正常腌制。

编辑

根据我的理解，您本质上有一个用户创建的对象字典。有些对象是可腌制的，有些则不然。我会这样做：

class saveable_dict(dict):
    def __getstate__(self):
        data = {}
        for key, value in self.items():
             try:
                  encoded = cPickle.dumps(value)
             except PicklingError:
                  encoded = cPickle.dumps( Unpickable() )
        return data

    def __setstate__(self, state):
       for key, value in state:
           self[key] = cPickle.loads(value)

然后当您想要保存该对象集合时使用该字典。用户应该能够取回任何可picklable 对象，但其他所有内容都将以Unpicklable() 对象的形式返回。此方法与之前的方法之间的区别在于对象本身是可拾取的，但引用了不可拾取的对象。但无论如何，这些物体很可能会被损坏。

这种方法还有一个好处是它完全保留在定义的 API 内，因此应该在 cPickle 或 pickle 中工作。

Answer 4

我最终为此编写了自己的解决方案。

这是代码。 以下是测试。它是 GarlicSim 的一部分，因此您可以通过 安装 garlicsim 并执行 from Garlicsim.general_misc import pickle_tools。

如果您想在 Python 3 代码上使用它，请使用 Python 3 fork of garlicsim 。

以下是该模块的摘录（可能已过时）：

import re
import cPickle as pickle_module
import pickle # Importing just to get dispatch table, not pickling with it.
import copy_reg
import types

from garlicsim.general_misc import address_tools
from garlicsim.general_misc import misc_tools


def is_atomically_pickleable(thing):
    '''
    Return whether `thing` is an atomically pickleable object.

    "Atomically-pickleable" means that it's pickleable without considering any
    other object that it contains or refers to. For example, a `list` is
    atomically pickleable, even if it contains an unpickleable object, like a
    `threading.Lock()`.

    However, the `threading.Lock()` itself is not atomically pickleable.
    '''
    my_type = misc_tools.get_actual_type(thing)
    return _is_type_atomically_pickleable(my_type, thing)


def _is_type_atomically_pickleable(type_, thing=None):
    '''Return whether `type_` is an atomically pickleable type.'''
    try:
        return _is_type_atomically_pickleable.cache[type_]
    except KeyError:
        pass

    if thing is not None:
        assert isinstance(thing, type_)

    # Sub-function in order to do caching without crowding the main algorithm:
    def get_result():

        # We allow a flag for types to painlessly declare whether they're
        # atomically pickleable:
        if hasattr(type_, '_is_atomically_pickleable'):
            return type_._is_atomically_pickleable

        # Weird special case: `threading.Lock` objects don't have `__class__`.
        # We assume that objects that don't have `__class__` can't be pickled.
        # (With the exception of old-style classes themselves.)
        if not hasattr(thing, '__class__') and \
           (not isinstance(thing, types.ClassType)):
            return False

        if not issubclass(type_, object):
            return True

        def assert_legit_pickling_exception(exception):
            '''Assert that `exception` reports a problem in pickling.'''
            message = exception.args[0]
            segments = [
                "can't pickle",
                'should only be shared between processes through inheritance',
                'cannot be passed between processes or pickled'
            ]
            assert any((segment in message) for segment in segments)
            # todo: turn to warning

        if type_ in pickle.Pickler.dispatch:
            return True

        reduce_function = copy_reg.dispatch_table.get(type_)
        if reduce_function:
            try:
                reduce_result = reduce_function(thing)
            except Exception, exception:
                assert_legit_pickling_exception(exception)
                return False
            else:
                return True

        reduce_function = getattr(type_, '__reduce_ex__', None)
        if reduce_function:
            try:
                reduce_result = reduce_function(thing, 0)
                # (The `0` is the protocol argument.)
            except Exception, exception:
                assert_legit_pickling_exception(exception)
                return False
            else:
                return True

        reduce_function = getattr(type_, '__reduce__', None)
        if reduce_function:
            try:
                reduce_result = reduce_function(thing)
            except Exception, exception:
                assert_legit_pickling_exception(exception)
                return False
            else:
                return True

        return False

    result = get_result()
    _is_type_atomically_pickleable.cache[type_] = result
    return result

_is_type_atomically_pickleable.cache = {}

Answer 5

dill 有用于此类检查的 pickles 方法。

>>> import threading
>>> l = [threading.Lock()]
>>> 
>>> import dill
>>> dill.pickles(l)
True
>>> 
>>> dill.pickles(threading.Lock())
True
>>> f = open('whatever', 'w') 
>>> f.close()
>>> dill.pickles(open('whatever', 'r'))
True

好吧，dill 会自动腌制所有示例，所以让我们尝试其他方法：

>>> l = [iter([1,2,3]), xrange(5)]
>>> dill.pickles(l)
False

好吧，这失败了。现在，让我们调查一下：

>>> dill.detect.trace(True)
>>> dill.pickles(l)
T4: <type 'listiterator'>
False
>>> map(dill.pickles, l)
T4: <type 'listiterator'>
Si: xrange(5)
F2: <function _eval_repr at 0x106991cf8>
[False, True]

好的。我们可以看到 iter 失败，但是 xrange 执行 pickle。因此，让我们替换 iter。

>>> l[0] = xrange(1,4)
>>> dill.pickles(l)
Si: xrange(1, 4)
F2: <function _eval_repr at 0x106991cf8>
Si: xrange(5)
True

现在我们的对象自动腌制。