def apply_delta(delta, controller, mode=None):
import spyder, Spyder
if delta is None: return
is_resource = controller._model()._is_resource
is_file = controller._model()._is_file
is_leaf = isinstance(controller, controller_leaf)
if is_resource:
if mode == "json" and not isinstance(delta, str) and not isinstance(
delta, dict):
delta = tuple(delta)
elif isinstance(delta, dict):
delta = controller._model()._resourcetype.fromdict(delta)
else:
delta = controller._model()._resourcetype(delta)
controller._set(delta)
return
if is_leaf:
if is_file and mode is None and isinstance(delta, dict):
delta = Spyder.File(delta)
controller._set(delta)
return
if isinstance(delta, dict):
for k in delta:
subdelta = delta[k]
subcontroller = getattr(controller, k)
apply_delta(subdelta, subcontroller, mode)
elif isinstance(delta, list):
for n, subdelta in enumerate(delta):
subcontroller = controller[n]
apply_delta(subdelta, subcontroller, mode)
else:
controller._set(delta)
def _set(self, value, _toplevelcall=True):
need_update = False
if isinstance(value, model): value = value._get()
#print("model._set", self._path, str(value)[:30])
value, cancel = determine_value(self, value)
if cancel: return self._status()
if value == self._value: return _update_ok
is_resource_file = False
if self._is_resource:
if isinstance(value, tuple) and len(value) == 2:
is_resource_file = True
if value[0] == None: value = None
elif value[0] == "": value = None
self.__exc = None
try:
if self._basic:
#1: basic model, can be file or resource
if value is not None: self._constructionstate = "failed"
if self._is_file or is_resource_file:
filename, fileclassname = value
if self._is_file:
fileclass = getattr(Spyder, fileclassname)
v = Spyder.File(filename,fileclass,"r")
elif self._is_resource:
if is_resource_file:
v = self._resourcetype(filename=filename)
self._is_resource_file = True
else:
v = self._resourcetype(value)
elif inspect.isclass(self._type) and issubclass(self._type, Spyder.Bool):
v = True if value else False
else:
v = self._type(value)
value = v
self._constructionstate = "full" if value is not None else "empty"
elif self._is_resource:
#2: non-basic resource model
self._is_resource_file = False
if is_resource_file:
filename,fileclassname = value
fileclass = getattr(Spyder, fileclassname)
fileobj = Spyder.File(filename,fileclass,"r")
v0 = self._resourcetype(fileobj)
self._is_resource_file = True
self._constructionstate = "full"
else:
v0 = self._resourcetype(value)
if v0.filename is not None:
self._is_resource_file = True
self._constructionstate = "full" if value is not None and value != {} else "empty"
if self._is_resource_file:
value = v0.file()
self._constructionstate = "full"
else:
v = v0.data()
self._constructionstate = "full"
if not self._toplevel and value is None: self._constructionstate = "empty"
value = v
elif value is None and self._arraycount:
value = self._type([])
self._constructionstate = "empty"
elif self._type is None:
if value is not None:
assert isinstance(value, dict)
for childname in self._children:
if childname not in value:
self._constructionstate = "partial"
return
self._value = {}
for childname in self._children:
child = self._children[childname]
child._disable_passup()
child._set(value[childname], _toplevelcall=False)
child._enable_passup()
self._value[childname] = child._value
self._truevalue = self._value
self.__dif = copy.copy(self._value)
self.__ddif = copy.copy(self._value)
self._constructionstate = "full"
self._is_valued = True
return _update_ok
else:
self.__dif = None
self.__ddif = None
self._constructionstate = "empty"
if self._complete(): self._constructionstate = "full"
self._is_valued = False
else:
#non-basic non-resource model
value0 = value
value = self._type(value)
self._constructionstate = "full"
if not self._toplevel and (value0 is None or value0 == {}): self._constructionstate = "empty"
except:
self.__exc = sys.exc_info()
#return, unless we just cleared the value
if value is None and self._value is not None:
self._constructionstate = "empty"
else:
if not self._toplevel:
self._parent._child_async(self._membername)
if _toplevelcall: return self._status()
return
if not self._toplevel and not len(self._async_children):
self._parent._child_sync(self._membername)
if self._truevalue != value:
need_update = True
self._truevalue = value
if not self._toplevel and not self._parent._arraycount:
if self._parent._typedefaults[self._membername] == value:
value = None
self._value = value
self._update_children()
self.__dif = None
self.__ddif = None
c = self._constructionstate
if self._truevalue is not None:
if self._arraycount:
for n in range(len(self._truevalue)):
self.__update_dif(n, self._truevalue[n], self._truevalue[n].dict(), self._arraycount-1)
self._constructionstate = c
elif len(self._children) > 0 and not self._is_resource_file:
for childname in self._children:
mvalue = self._get_child_value(childname)
child = self._get_child(childname)
self.__update_dif(childname, mvalue, child._dif(), child._arraycount)
self._constructionstate = c
elif self._is_file or self._is_resource:
self.__dif = self._value.dict()
self.__ddif = self._value.dict()
else:
self.__dif = self._value
self.__ddif = self._value
#Are we valued or unvalued?
if self.__exc is None:
if self.__ddif is not None or self._toplevel:
self._is_valued = True
else:
self._is_valued = False
else:
self._is_valued = False
for listener in self._listeners:
listener(self._truevalue)
if self.__passup and not self._toplevel and need_update:
self._parent._update_child(self._membername)
return _update_ok