remove pickle dump/load support
This commit is contained in:
@ -30,7 +30,7 @@ from .option import OptionDescription, Option, SymLinkOption, \
|
||||
from .option.baseoption import valid_name
|
||||
from .setting import groups, Settings, default_encoding, undefined
|
||||
from .storage import get_storages, get_storage, set_storage, \
|
||||
_impl_getstate_setting, get_default_values_storages
|
||||
get_default_values_storages
|
||||
from .value import Values, Multi
|
||||
from .i18n import _
|
||||
|
||||
@ -720,42 +720,8 @@ class _CommonConfig(SubConfig):
|
||||
def impl_del_information(self, key, raises=True):
|
||||
self._impl_values.del_information(key, raises)
|
||||
|
||||
# ----- state
|
||||
def __getstate__(self):
|
||||
if self._impl_meta is not None:
|
||||
raise ConfigError(_('cannot serialize Config with MetaConfig')) # pragma: optional cover
|
||||
slots = set()
|
||||
for subclass in self.__class__.__mro__:
|
||||
if subclass is not object:
|
||||
slots.update(subclass.__slots__)
|
||||
slots -= frozenset(['_impl_context', '_impl_meta', '__weakref__'])
|
||||
state = {}
|
||||
for slot in slots:
|
||||
try:
|
||||
state[slot] = getattr(self, slot)
|
||||
except AttributeError: # pragma: optional cover
|
||||
pass
|
||||
storage = self._impl_values._p_._storage
|
||||
if not storage.serializable:
|
||||
raise ConfigError(_('this storage is not serialisable, could be a '
|
||||
'none persistent storage')) # pragma: optional cover
|
||||
state['_storage'] = {'session_id': storage.session_id,
|
||||
'persistent': storage.persistent}
|
||||
state['_impl_setting'] = _impl_getstate_setting()
|
||||
return state
|
||||
|
||||
def __setstate__(self, state):
|
||||
for key, value in state.items():
|
||||
if key not in ['_storage', '_impl_setting']:
|
||||
setattr(self, key, value)
|
||||
set_storage('config', **state['_impl_setting'])
|
||||
self._impl_context = weakref.ref(self)
|
||||
self._impl_settings.context = weakref.ref(self)
|
||||
self._impl_values.context = weakref.ref(self)
|
||||
storage = get_storage(test=self._impl_test, **state['_storage'])
|
||||
self._impl_values._impl_setstate(storage)
|
||||
self._impl_settings._impl_setstate(storage)
|
||||
self._impl_meta = None
|
||||
raise NotImplementedError()
|
||||
|
||||
def _gen_fake_values(self, session):
|
||||
fake_config = Config(self._impl_descr, persistent=False,
|
||||
|
||||
@ -256,156 +256,8 @@ class BaseOption(Base):
|
||||
"""
|
||||
__slots__ = tuple()
|
||||
|
||||
# ____________________________________________________________
|
||||
# serialize object
|
||||
def _impl_convert_dependencies(self, descr, load=False):
|
||||
"""export of the requires during the serialization process
|
||||
|
||||
:type descr: :class:`tiramisu.option.OptionDescription`
|
||||
:param load: `True` if we are at the init of the option description
|
||||
:type load: bool
|
||||
"""
|
||||
if not load and getattr(self, '_dependencies', None) is None:
|
||||
self._state_dependencies = None
|
||||
elif load and self._state_dependencies is None:
|
||||
del(self._state_dependencies)
|
||||
else:
|
||||
if load:
|
||||
self._dependencies = []
|
||||
for dependency in self._state_dependencies:
|
||||
option = descr.impl_get_opt_by_path(dependency)
|
||||
if option.impl_is_optiondescription():
|
||||
# test if _group_type is already loaded
|
||||
group_type = getattr(option, '_group_type', undefined)
|
||||
if group_type is undefined:
|
||||
group_type = getattr(groups, option._state_group_type)
|
||||
if group_type == groups.master:
|
||||
master_path = dependency + '.' + dependency.split('.')[-1]
|
||||
option = descr.impl_get_opt_by_path(master_path).impl_get_master_slaves()
|
||||
self._dependencies.append(option)
|
||||
self._dependencies = tuple(self._dependencies)
|
||||
del(self._state_dependencies)
|
||||
else:
|
||||
self._state_dependencies = []
|
||||
for dependency in self._dependencies:
|
||||
if isinstance(dependency, MasterSlaves):
|
||||
self._state_dependencies.append('.'.join(descr.impl_get_path_by_opt(dependency._p_.master).split('.')[:-1]))
|
||||
else:
|
||||
self._state_dependencies.append(descr.impl_get_path_by_opt(dependency))
|
||||
|
||||
def _impl_convert_requires(self, descr, load=False):
|
||||
"""export of the requires during the serialization process
|
||||
|
||||
:type descr: :class:`tiramisu.option.OptionDescription`
|
||||
:param load: `True` if we are at the init of the option description
|
||||
:type load: bool
|
||||
"""
|
||||
if not load and self.impl_getrequires() == []:
|
||||
self._state_requires = None
|
||||
elif load and self._state_requires is None:
|
||||
del(self._state_requires)
|
||||
else:
|
||||
if load:
|
||||
_requires = self._state_requires
|
||||
else:
|
||||
_requires = self.impl_getrequires()
|
||||
new_value = []
|
||||
for requires in _requires:
|
||||
new_requires = []
|
||||
new_req = []
|
||||
for require in requires:
|
||||
for req in require[0]:
|
||||
if load:
|
||||
new_req.append([(descr.impl_get_opt_by_path(req[0]), req[1])])
|
||||
else:
|
||||
new_req.append([(descr.impl_get_path_by_opt(req[0]), req[1])])
|
||||
new_req.extend(require[1:])
|
||||
new_requires.append(tuple(new_req))
|
||||
new_value.append(tuple(new_requires))
|
||||
if load:
|
||||
del(self._state_requires)
|
||||
if new_value != []:
|
||||
self._requires = tuple(new_value)
|
||||
else:
|
||||
self._state_requires = tuple(new_value)
|
||||
|
||||
# serialize
|
||||
def _impl_getstate(self, descr):
|
||||
"""the under the hood stuff that need to be done
|
||||
before the serialization.
|
||||
|
||||
:param descr: the parent :class:`tiramisu.option.OptionDescription`
|
||||
"""
|
||||
self._stated = True
|
||||
for func in dir(self):
|
||||
if func.startswith('_impl_convert_'):
|
||||
getattr(self, func)(descr)
|
||||
|
||||
def __getstate__(self, stated=True):
|
||||
"""special method to enable the serialization with pickle
|
||||
Usualy, a `__getstate__` method does'nt need any parameter,
|
||||
but somme under the hood stuff need to be done before this action
|
||||
|
||||
:parameter stated: if stated is `True`, the serialization protocol
|
||||
can be performed, not ready yet otherwise
|
||||
:parameter type: bool
|
||||
"""
|
||||
try:
|
||||
self._stated
|
||||
except AttributeError:
|
||||
raise SystemError(_('cannot serialize Option, '
|
||||
'only in OptionDescription'))
|
||||
if isinstance(self, SymLinkOption):
|
||||
slots = frozenset(['_name', '_state_opt', '_stated'])
|
||||
else:
|
||||
slots = self._impl_getattributes()
|
||||
slots -= frozenset(['_cache_paths', '_cache_consistencies',
|
||||
'__weakref__'])
|
||||
states = {}
|
||||
for slot in slots:
|
||||
# remove variable if save variable converted
|
||||
# in _state_xxxx variable
|
||||
if '_state' + slot not in slots:
|
||||
try:
|
||||
if slot.startswith('_state'):
|
||||
states[slot] = getattr(self, slot)
|
||||
# remove _state_xxx variable
|
||||
self.__delattr__(slot)
|
||||
else:
|
||||
states[slot] = getattr(self, slot)
|
||||
except AttributeError:
|
||||
pass
|
||||
if not stated:
|
||||
del(states['_stated'])
|
||||
return states
|
||||
|
||||
# unserialize
|
||||
def _impl_setstate(self, descr):
|
||||
"""the under the hood stuff that need to be done
|
||||
before the serialization.
|
||||
|
||||
:type descr: :class:`tiramisu.option.OptionDescription`
|
||||
"""
|
||||
for func in dir(self):
|
||||
if func.startswith('_impl_convert_'):
|
||||
getattr(self, func)(descr, load=True)
|
||||
try:
|
||||
del(self._stated)
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
def __setstate__(self, state):
|
||||
"""special method that enables us to serialize (pickle)
|
||||
|
||||
Usualy, a `__setstate__` method does'nt need any parameter,
|
||||
but somme under the hood stuff need to be done before this action
|
||||
|
||||
:parameter state: a dict is passed to the loads, it is the attributes
|
||||
of the options object
|
||||
:type state: dict
|
||||
"""
|
||||
for key, value in state.items():
|
||||
setattr(self, key, value)
|
||||
def __getstate__(self):
|
||||
raise NotImplementedError()
|
||||
|
||||
def __setattr__(self, name, value):
|
||||
"""set once and only once some attributes in the option,
|
||||
@ -417,9 +269,7 @@ class BaseOption(Base):
|
||||
propertie or "read_only" property)
|
||||
"""
|
||||
if name != '_option' and \
|
||||
not isinstance(value, tuple) and \
|
||||
not name.startswith('_state') and \
|
||||
not name == '_sa_instance_state':
|
||||
not isinstance(value, tuple):
|
||||
is_readonly = False
|
||||
# never change _name dans _opt
|
||||
if name == '_name':
|
||||
@ -932,41 +782,6 @@ class Option(OnlyOption):
|
||||
equal_name.append(opt.impl_get_display_name())
|
||||
return ValueError(msg.format(display_list(list(equal_name))))
|
||||
|
||||
# serialize/unserialize
|
||||
def _impl_convert_consistencies(self, descr, load=False):
|
||||
"""during serialization process, many things have to be done.
|
||||
one of them is the localisation of the options.
|
||||
The paths are set once for all.
|
||||
|
||||
:type descr: :class:`tiramisu.option.OptionDescription`
|
||||
:param load: `True` if we are at the init of the option description
|
||||
:type load: bool
|
||||
"""
|
||||
if not load and not self._has_consistencies():
|
||||
self._state_consistencies = None
|
||||
elif load and self._state_consistencies is None:
|
||||
del(self._state_consistencies)
|
||||
else:
|
||||
if load:
|
||||
consistencies = self._state_consistencies
|
||||
else:
|
||||
consistencies = self._get_consistencies()
|
||||
new_value = []
|
||||
for consistency in consistencies:
|
||||
values = []
|
||||
for obj in consistency[1]:
|
||||
if load:
|
||||
values.append(descr.impl_get_opt_by_path(obj))
|
||||
else:
|
||||
values.append(descr.impl_get_path_by_opt(obj))
|
||||
new_value.append((consistency[0], tuple(values), consistency[2]))
|
||||
if load:
|
||||
del(self._state_consistencies)
|
||||
for new_val in new_value:
|
||||
self._add_consistency(new_val[0], new_val[1], new_val[2])
|
||||
else:
|
||||
self._state_consistencies = new_value
|
||||
|
||||
def _second_level_validation(self, value, warnings_only):
|
||||
pass
|
||||
|
||||
@ -1139,7 +954,6 @@ def validate_requires_arg(new_option, multi, requires, name):
|
||||
|
||||
|
||||
class SymLinkOption(OnlyOption):
|
||||
# __slots__ = ('_opt', '_state_opt')
|
||||
|
||||
def __init__(self, name, opt):
|
||||
if not isinstance(opt, Option):
|
||||
@ -1155,21 +969,11 @@ class SymLinkOption(OnlyOption):
|
||||
|
||||
def __getattr__(self, name, context=undefined):
|
||||
if name in ('_opt', '_readonly', 'impl_getpath', '_name',
|
||||
'_state_opt', '_impl_setopt'):
|
||||
'_impl_setopt'):
|
||||
return object.__getattr__(self, name)
|
||||
else:
|
||||
return getattr(self._impl_getopt(), name)
|
||||
|
||||
def _impl_getstate(self, descr):
|
||||
self._stated = True
|
||||
self._state_opt = descr.impl_get_path_by_opt(self._impl_getopt())
|
||||
|
||||
def _impl_setstate(self, descr):
|
||||
self._impl_setopt(descr.impl_get_opt_by_path(self._state_opt))
|
||||
del(self._state_opt)
|
||||
del(self._stated)
|
||||
self._set_readonly(True)
|
||||
|
||||
def impl_get_information(self, key, default=undefined):
|
||||
return self._impl_getopt().impl_get_information(key, default)
|
||||
|
||||
@ -1208,7 +1012,7 @@ class DynSymLinkOption(object):
|
||||
self._opt = opt
|
||||
|
||||
def __getattr__(self, name, context=undefined):
|
||||
if name in ('_opt', '_readonly', 'impl_getpath', '_name', '_state_opt'):
|
||||
if name in ('_opt', '_readonly', 'impl_getpath', '_name'):
|
||||
return object.__getattr__(self, name)
|
||||
else:
|
||||
return getattr(self._impl_getopt(), name)
|
||||
|
||||
@ -260,58 +260,8 @@ class OptionDescription(BaseOption, StorageOptionDescription):
|
||||
raise ValueError(_('group_type: {0}'
|
||||
' not allowed').format(group_type))
|
||||
|
||||
def _impl_getstate(self, descr=None):
|
||||
"""enables us to export into a dict
|
||||
:param descr: parent :class:`tiramisu.option.OptionDescription`
|
||||
"""
|
||||
if descr is None:
|
||||
self.impl_build_cache_option()
|
||||
descr = self
|
||||
super(OptionDescription, self)._impl_getstate(descr)
|
||||
self._state_group_type = str(self._group_type)
|
||||
for option in self._impl_getchildren():
|
||||
option._impl_getstate(descr)
|
||||
|
||||
def __getstate__(self):
|
||||
"""special method to enable the serialization with pickle
|
||||
"""
|
||||
stated = True
|
||||
try:
|
||||
# the `_state` attribute is a flag that which tells us if
|
||||
# the serialization can be performed
|
||||
self._stated
|
||||
except AttributeError:
|
||||
# if cannot delete, _impl_getstate never launch
|
||||
# launch it recursivement
|
||||
# _stated prevent __getstate__ launch more than one time
|
||||
# _stated is delete, if re-serialize, re-lauch _impl_getstate
|
||||
self._impl_getstate()
|
||||
stated = False
|
||||
return super(OptionDescription, self).__getstate__(stated)
|
||||
|
||||
def _impl_setstate(self, descr=None):
|
||||
"""enables us to import from a dict
|
||||
:param descr: parent :class:`tiramisu.option.OptionDescription`
|
||||
"""
|
||||
if descr is None:
|
||||
self._cache_consistencies = None
|
||||
self.impl_build_cache_option()
|
||||
descr = self
|
||||
self._group_type = getattr(groups, self._state_group_type)
|
||||
if isinstance(self._group_type, groups.MasterGroupType):
|
||||
MasterSlaves(self.impl_getname(), self.impl_getchildren(),
|
||||
validate=False)
|
||||
del(self._state_group_type)
|
||||
super(OptionDescription, self)._impl_setstate(descr)
|
||||
for option in self._impl_getchildren(dyn=False):
|
||||
option._impl_setstate(descr)
|
||||
|
||||
def __setstate__(self, state):
|
||||
super(OptionDescription, self).__setstate__(state)
|
||||
try:
|
||||
self._stated
|
||||
except AttributeError:
|
||||
self._impl_setstate()
|
||||
raise NotImplementedError()
|
||||
|
||||
def _impl_get_suffixes(self, context):
|
||||
callback, callback_params = self.impl_get_callback()
|
||||
|
||||
@ -770,18 +770,3 @@ class Settings(object):
|
||||
|
||||
def get_modified_permissives(self):
|
||||
return self._pp_.get_modified_permissives()
|
||||
|
||||
def __getstate__(self):
|
||||
return {'_p_': self._p_, '_pp_': self._pp_, '_owner': str(self._owner)}
|
||||
|
||||
def _impl_setstate(self, storage):
|
||||
self._p_._storage = storage
|
||||
|
||||
def __setstate__(self, states):
|
||||
self._p_ = states['_p_']
|
||||
self._pp_ = states['_pp_']
|
||||
try:
|
||||
self._owner = getattr(owners, states['_owner'])
|
||||
except AttributeError:
|
||||
owners.addowner(states['_owner'])
|
||||
self._owner = getattr(owners, states['_owner'])
|
||||
|
||||
@ -66,6 +66,8 @@ class StorageType(object):
|
||||
try:
|
||||
mod = __import__(modulepath)
|
||||
except ImportError: # pragma: no cover
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
raise SystemError(_('cannot import the storage {0}').format(
|
||||
self.default_storage))
|
||||
for token in modulepath.split(".")[1:]:
|
||||
@ -81,33 +83,6 @@ default_validation = StorageType()
|
||||
default_validation.set(DEFAULT_STORAGE)
|
||||
|
||||
|
||||
def set_storage(type_, name): # pragma: optional cover
|
||||
"""Change storage's configuration
|
||||
|
||||
:params name: is the storage name. If storage is already set, cannot
|
||||
reset storage name
|
||||
|
||||
Other attributes are differents according to the selected storage's name
|
||||
"""
|
||||
storage_type.set(name)
|
||||
setting = storage_type.get().setting
|
||||
|
||||
|
||||
def _impl_getstate_setting():
|
||||
setting = storage_type.get().setting
|
||||
state = {'name': storage_type.storage_type}
|
||||
for var in dir(setting):
|
||||
if not var.startswith('_'):
|
||||
state[var] = getattr(setting, var)
|
||||
return state
|
||||
|
||||
|
||||
def get_storage(session_id, persistent, test): # pragma: optional cover
|
||||
"""all used when __setstate__ a Config
|
||||
"""
|
||||
return storage_type.get().Storage(session_id, persistent, test)
|
||||
|
||||
|
||||
def get_storages(context, session_id, persistent):
|
||||
def gen_id(config):
|
||||
return 'c' + str(id(config)) + str(int(time())) + str(randint(0, 500))
|
||||
|
||||
@ -57,15 +57,6 @@ class StorageBase(object):
|
||||
#other
|
||||
'_has_dependency',
|
||||
'_dependencies',
|
||||
'_state_master_slaves',
|
||||
'_state_val_call',
|
||||
'_state_requires',
|
||||
'_stated',
|
||||
'_state_consistencies',
|
||||
'_state_informations',
|
||||
'_state_extra',
|
||||
'_state_readonly',
|
||||
'_state_dependencies',
|
||||
'__weakref__'
|
||||
)
|
||||
|
||||
@ -219,44 +210,6 @@ class StorageBase(object):
|
||||
ret_val = val
|
||||
return ret_val
|
||||
|
||||
def _impl_convert_callback(self, descr, load=False):
|
||||
if self.__class__.__name__ in ['OptionDescription', 'SymLinkOption']:
|
||||
return
|
||||
if not load and getattr(self, '_val_call', None) is None:
|
||||
self._state_val_call = None
|
||||
elif load and self._state_val_call is None:
|
||||
del(self._state_val_call)
|
||||
else:
|
||||
if load:
|
||||
val_call = self._state_val_call
|
||||
else:
|
||||
val_call = self._val_call
|
||||
new_val_call = []
|
||||
for vals in val_call:
|
||||
if vals is None or len(vals) == 1:
|
||||
new_val_call.append(vals)
|
||||
else:
|
||||
prms = {}
|
||||
val, params = vals
|
||||
for key, values in params.items():
|
||||
vls = []
|
||||
for value in values:
|
||||
if isinstance(value, tuple) and value[0] is not None:
|
||||
if load:
|
||||
value = (descr.impl_get_opt_by_path(value[0]),
|
||||
value[1])
|
||||
else:
|
||||
value = (descr.impl_get_path_by_opt(value[0]),
|
||||
value[1])
|
||||
vls.append(value)
|
||||
prms[key] = tuple(vls)
|
||||
new_val_call.append((val, prms))
|
||||
if load:
|
||||
del(self._state_val_call)
|
||||
self._val_call = new_val_call
|
||||
else:
|
||||
self._state_val_call = new_val_call
|
||||
|
||||
def _get_id(self):
|
||||
return id(self)
|
||||
|
||||
@ -287,58 +240,12 @@ class StorageBase(object):
|
||||
def _impl_setsubdyn(self, subdyn):
|
||||
self._subdyn = subdyn
|
||||
|
||||
def _impl_setopt(self, opt):
|
||||
self._opt = opt
|
||||
|
||||
def _is_string(self, infos):
|
||||
if sys.version_info[0] >= 3: # pragma: no cover
|
||||
return isinstance(infos, str)
|
||||
else:
|
||||
return isinstance(infos, str) or isinstance(infos, unicode)
|
||||
|
||||
def _impl_convert_zinformations(self, descr, load=False):
|
||||
if not load:
|
||||
infos = self._informations
|
||||
if isinstance(infos, tuple):
|
||||
self._state_informations = {}
|
||||
for idx, key in enumerate(infos[0]):
|
||||
self._state_informations[key] = infos[1][idx]
|
||||
elif self._is_string(infos):
|
||||
self._state_informations = {'doc': infos}
|
||||
else:
|
||||
self._state_informations = infos
|
||||
self._state_readonly = self.impl_is_readonly()
|
||||
else:
|
||||
_setattr = object.__setattr__
|
||||
_setattr(self, '_informations', self._state_informations)
|
||||
del(self._state_informations)
|
||||
if self._state_readonly:
|
||||
self._set_readonly(True)
|
||||
del(self._state_readonly)
|
||||
|
||||
def _impl_convert_extra(self, descr, load=False):
|
||||
if not load:
|
||||
extra = getattr(self, '_extra', None)
|
||||
if isinstance(extra, tuple):
|
||||
self._state_extra = {}
|
||||
for idx, key in enumerate(extra[0]):
|
||||
self._state_extra[key] = extra[1][idx]
|
||||
elif isinstance(extra, dict):
|
||||
self._state_extra = extra
|
||||
else:
|
||||
extra = getattr(self, '_state_extra', None)
|
||||
if extra is not None:
|
||||
_setattr = object.__setattr__
|
||||
_setattr(self, '_extra', extra)
|
||||
del(self._state_extra)
|
||||
|
||||
def _impl_getattributes(self):
|
||||
slots = set()
|
||||
for subclass in self.__class__.__mro__:
|
||||
if subclass is not object:
|
||||
slots.update(subclass.__slots__)
|
||||
return slots
|
||||
|
||||
def impl_is_readonly(self):
|
||||
return not isinstance(getattr(self, '_informations', dict()), dict)
|
||||
|
||||
@ -400,7 +307,7 @@ class StorageBase(object):
|
||||
|
||||
class StorageOptionDescription(StorageBase):
|
||||
__slots__ = ('_children', '_cache_paths', '_cache_consistencies',
|
||||
'_group_type', '_state_group_type', '_cache_force_store_values')
|
||||
'_group_type', '_cache_force_store_values')
|
||||
|
||||
def _add_children(self, child_names, children):
|
||||
_setattr = object.__setattr__
|
||||
|
||||
@ -16,10 +16,9 @@
|
||||
# ____________________________________________________________
|
||||
from ...i18n import _
|
||||
from ...error import ConfigError, ConflictError
|
||||
from ..util import SerializeObject
|
||||
|
||||
|
||||
class Setting(SerializeObject):
|
||||
class Setting(object):
|
||||
"""Dictionary storage has no particular setting.
|
||||
"""
|
||||
pass
|
||||
|
||||
@ -15,13 +15,12 @@
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
# ____________________________________________________________
|
||||
from tiramisu.i18n import _
|
||||
from ..util import SerializeObject
|
||||
from .util import SqlAlchemyBase
|
||||
import util
|
||||
from sqlalchemy import Column, Integer, String
|
||||
|
||||
|
||||
class Setting(SerializeObject):
|
||||
class Setting(object):
|
||||
""":param extension: database file extension (by default: db)
|
||||
:param dir_database: root database directory (by default: /tmp)
|
||||
"""
|
||||
|
||||
@ -20,10 +20,9 @@ from os import unlink
|
||||
from os.path import basename, splitext, join, isfile
|
||||
import sqlite3
|
||||
from glob import glob
|
||||
from ..util import SerializeObject
|
||||
|
||||
|
||||
class Setting(SerializeObject):
|
||||
class Setting(object):
|
||||
""":param extension: database file extension (by default: db)
|
||||
:param dir_database: root database directory (by default: /tmp)
|
||||
"""
|
||||
|
||||
@ -18,15 +18,6 @@
|
||||
from ..setting import owners
|
||||
|
||||
|
||||
class SerializeObject(object):
|
||||
def __getstate__(self): # pragma: no cover
|
||||
ret = {}
|
||||
for key in dir(self):
|
||||
if not key.startswith('__'):
|
||||
ret[key] = getattr(self, key)
|
||||
return ret
|
||||
|
||||
|
||||
class Cache(object):
|
||||
__slots__ = ('_cache', '_storage')
|
||||
key_is_path = False
|
||||
@ -35,68 +26,6 @@ class Cache(object):
|
||||
self._cache = {}
|
||||
self._storage = storage
|
||||
|
||||
def __getstate__(self):
|
||||
slots = set()
|
||||
for subclass in self.__class__.__mro__:
|
||||
if subclass is not object:
|
||||
slots.update(subclass.__slots__)
|
||||
slots -= frozenset(['__weakref__', '_storage'])
|
||||
states = {}
|
||||
for slot in slots:
|
||||
try:
|
||||
value = getattr(self, slot)
|
||||
#value has owners object, need 'str()' it
|
||||
if slot == '_values':
|
||||
_value = []
|
||||
_value.append(value[0])
|
||||
_value.append(value[1])
|
||||
str_owner = []
|
||||
_value.append(value[2])
|
||||
for owner in value[3]:
|
||||
if isinstance(owner, list): # pragma: no cover
|
||||
str_owners = []
|
||||
for subowner in owner:
|
||||
str_owners.append(str(subowner))
|
||||
str_owner.append(str_owners)
|
||||
else:
|
||||
str_owner.append(str(owner))
|
||||
_value.append(str_owner)
|
||||
states[slot] = _value
|
||||
else:
|
||||
states[slot] = value
|
||||
except AttributeError: # pragma: no cover
|
||||
pass
|
||||
return states
|
||||
|
||||
def __setstate__(self, states):
|
||||
def convert_owner(owner):
|
||||
try:
|
||||
owner = getattr(owners, owner)
|
||||
except AttributeError: # pragma: no cover
|
||||
owners.addowner(owner)
|
||||
owner = getattr(owners, owner)
|
||||
return owner
|
||||
|
||||
for key, value in states.items():
|
||||
#value has owners object, need to reconstruct it
|
||||
if key == '_values':
|
||||
_value = []
|
||||
_value.append(value[0])
|
||||
_value.append(value[1])
|
||||
_value.append(value[2])
|
||||
obj_owner = []
|
||||
for owner in value[3]:
|
||||
if isinstance(owner, list): # pragma: no cover
|
||||
obj_owners = []
|
||||
for subowner in owner:
|
||||
obj_owners.append(convert_owner(subowner))
|
||||
obj_owner.append(tuple(obj_owners))
|
||||
else:
|
||||
obj_owner.append(convert_owner(owner))
|
||||
_value.append(tuple(obj_owner))
|
||||
value = tuple(_value)
|
||||
setattr(self, key, value)
|
||||
|
||||
def setcache(self, path, val, time, index):
|
||||
"""add val in cache for a specified path
|
||||
if slave, add index
|
||||
|
||||
@ -690,15 +690,6 @@ class Values(object):
|
||||
if isinstance(err, Exception) and not isinstance(err, PropertiesOptionError): # pragma: no cover
|
||||
raise err
|
||||
|
||||
def __getstate__(self):
|
||||
return {'_p_': self._p_}
|
||||
|
||||
def _impl_setstate(self, storage):
|
||||
self._p_._storage = storage
|
||||
|
||||
def __setstate__(self, states):
|
||||
self._p_ = states['_p_']
|
||||
|
||||
|
||||
# ____________________________________________________________
|
||||
# multi types
|
||||
|
||||
Reference in New Issue
Block a user