Python 需要使用Django存储bytestring

我需要存储一个bytestring

由于Django不支持BlobFields，我想我应该创建自己的Base64Field， 在与数据库交互时编码并解码到base64。 因此，我重写了（？）to_python并获得了用于该目的的_db_prep_save方法

问题在于，python在各种不同的场景中被调用，而不是一次又一次 无法判断字符串是否已解码。如果已经解码了， 显然发生了错误

我的困境有什么解决办法

可能的解决方案对我来说很难看：尝试除了解码过程之外的其他方法，如果解码失败，则返回值，使用实例变量只允许使用1 to_python（这似乎更糟）

您可以使用某种方法

类PickledObjectField（models.Field）：
__元类=模型.SubfieldBase
marker_re=re.compile（r'^T\[（？P\w+）\]（？P.*）$，re.DOTALL）
markable_types=dict（（t.u name_uu，t）表示t in（str，int，unicode））
定义初始化（self，*args，**kwargs）：
self.compress=kwargs.pop（'compress'，True）
self.protocol=kwargs.pop（'protocol'，2）
kwargs.setdefault（'null'，True）
kwargs.setdefault（'editable'，False）
super（PickledObjectField，self）。\uuuuuu init\uuuuuu（*args，**kwargs）
def生成\类型\标记\值（自身，值）：
返回PickledObject（u“T[%s]%s”%（类型（值）。\u名称\u值））
def读取标记值（自身，值）：
m=自标记匹配（值）
如果m：
marker=m.group（'type'）
value=m.group（'value'）
如果标记为self.markable_类型：
value=self.markable_类型[marker]（值）
返回值
def get_默认值（自身）：
如果self.has_default（）：
如果可调用（self.default）：
返回self.default（）
返回self.default
返回super（PickledObjectField，self）.get_default（）
定义到python（自身，值）：
如果值不是“无”：
尝试：
如果值.startswith（“T[”）：
值=自身。读取标记值（值）
其他：
value=dbsafe_解码（value，self.compress）
除：
如果isinstance（值，PickledObject）：
提升
返回值
def get_db_prep_值（自身，值）：
如果值不是None且不是isinstance（值，PickledObject）：
如果类型（值）。\uuuuu name\uuuuuuuuuuuuuuuuuuu在self.markable\u类型中，而不是（isinstance（值，基串）和len（值
)>最大可标记字符串长度）：
value=unicode（自生成\类型\标记\值（值））
其他：
value=unicode（dbsafe_编码（value，self.compress））
返回值
def值_至_字符串（自身，obj）：
值=自身。从对象（对象）获取值
返回self.get_db_prep_值（值）
def get_内部_类型（自身）：
返回“TextField”
def get_db_prep_查找（自身、查找类型、值）：
如果查找类型不在['exact'，'in'，'isnull']中：
raise TypeError（'不支持查找类型%s）。%Lookup\u类型）
返回super（PickledObjectField，self）。获取\u db\u prep\u查找（查找类型，值）

您能展示一下这些方法吗？

class PickledObjectField(models.Field):
    __metaclass__ = models.SubfieldBase

    marker_re = re.compile(r'^T\[(?P<type>\w+)\](?P<value>.*)$', re.DOTALL)
    markable_types = dict((t.__name__, t) for t in (str, int, unicode))

    def __init__(self, *args, **kwargs):
        self.compress = kwargs.pop('compress', True)
        self.protocol = kwargs.pop('protocol', 2)
        kwargs.setdefault('null', True)
        kwargs.setdefault('editable', False)
        super(PickledObjectField, self).__init__(*args, **kwargs)

    def generate_type_marked_value(self, value):
        return PickledObject(u"T[%s]%s" % (type(value).__name__, value))

    def read_marked_value(self, value):
        m = self.marker_re.match(value)

        if m:
            marker = m.group('type')
            value = m.group('value')
            if marker in self.markable_types:
                value = self.markable_types[marker](value)

        return value

    def get_default(self):
        if self.has_default():
            if callable(self.default):
                return self.default()
            return self.default

        return super(PickledObjectField, self).get_default()

    def to_python(self, value):
        if value is not None:
            try:
                if value.startswith("T["):
                    value = self.read_marked_value(value)
                else:
                    value = dbsafe_decode(value, self.compress)
            except:
                if isinstance(value, PickledObject):
                    raise
        return value

    def get_db_prep_value(self, value):
        if value is not None and not isinstance(value, PickledObject):
            if type(value).__name__ in self.markable_types and not (isinstance(value, basestring) and len(value
                                                                                                          ) > MAX_MARKABLE_STRING_LENGTH):
                value = unicode(self.generate_type_marked_value(value))
            else:
                value = unicode(dbsafe_encode(value, self.compress))
        return value

    def value_to_string(self, obj):
        value = self._get_val_from_obj(obj)
        return self.get_db_prep_value(value)

    def get_internal_type(self):
        return 'TextField'

    def get_db_prep_lookup(self, lookup_type, value):
        if lookup_type not in ['exact', 'in', 'isnull']:
            raise TypeError('Lookup type %s is not supported.' % lookup_type)
        return super(PickledObjectField, self).get_db_prep_lookup(lookup_type, value)