def addChild(self,
branch: TreeBase,
index=None,
force=False,
emitDelta=None) -> TreeBase:
"""check if a delta is necessary"""
#print("addChild")
emitDelta = emitDelta if emitDelta is not None else self.trackingDeltas
#print("emitStackDelta", emitStackDelta, self.trackingDeltas)
if emitDelta:
# check if tree is "known" to this delta tracking scope
try:
relPath = branch.relAddress(fromBranch=self.deltaTrackingRoot)
print("existing branch delta")
structDelta = TreeStructureDelta(
branchRef=TreeReference(branch,
relParent=self.deltaTrackingRoot),
oldParentRef=TreeReference(
branch.parent, relParent=self.deltaTrackingRoot),
parentRef=TreeReference(
branch=self,
relParent=self.deltaTrackingRoot,
),
oldIndex=branch.index(),
newIndex=index or -1,
eventCode=self.StructureEvents.branchAdded)
self.emitStackDelta(structDelta)
except LookupError:
print("new branch delta")
# branch not known to delta root, make creation delta
createDelta = TreeCreationDelta(
TreeReference(branch,
relParent=None,
mode=TreeReference.Mode.Uid),
parentRef=TreeReference(self,
relParent=self.deltaTrackingRoot),
name=branch.name,
value=branch.value,
index=index or -1,
treeUid=branch.uid,
treeCls=Tree)
self.emitStackDelta(createDelta)
# print("readonly", self.readOnly)
if self.readOnly:
print("read only returning")
return None
# check for read only
if self.readOnly:
raise PermissionError(
f"tree {self.address()} is read only, cannot set value")
return super(Tree, self).addChild(branch, index=index)
class TreeProxyLink(ProxyLink):
"""used as 'floating' facade, deferring to any branch
matching the original used uid
"""
def __init__(self, proxyTargetObj: TreeBase):
self._treeRef: TreeReference = None
super(TreeProxyLink, self).__init__(proxyTargetObj)
def setProxyTarget(self, proxyTargetObj: TreeBase):
self._treeRef = TreeReference(proxyTargetObj)
def getProxyTarget(self):
"""if live input exists, ensure always up to date
"""
result = self._treeRef.resolve()
if result.liveInputRoot:
result.liveInputRoot.liveInput.resultTree()
return self._treeRef.resolve()
def test_treeReference(self):
""" test that a TreeReference object remains valid
through deletion and recreation, by uid"""
testBranch = self.tree("branchA")
testUid = testBranch.uid
ref = TreeReference(testBranch)
self.assertIs(ref.resolve(), testBranch)
# delete
testBranch.remove()
testBranch.delete()
self.assertRaises(KeyError, ref.resolve)
# recreate
newBranch = self.tree("newBranch")
newBranch.setUid(testUid)
self.assertIs(ref.resolve(), newBranch)
def test_treeUidSeeding(self):
""" test that a Tree object uid can be regenerated consistently"""
testBranch = self.tree("branchA")
copyBranch = Tree("newBranchA")
copyBranch.setProperty("_baseUid", "eyyyyy")
baseCopyUid = copyBranch.uid
testBranch.seedUids(copyBranch)
seededUid = copyBranch.uid
self.assertNotEqual(baseCopyUid, seededUid)
newRef = TreeReference(copyBranch)
# regenerate a new tree
secondCopyBranch = Tree("newBranchB")
secondCopyBranch.setProperty("_baseUid", "eyyyyy")
testBranch.seedUids(secondCopyBranch)
self.assertEqual(secondCopyBranch.uid, seededUid)
self.assertIs(newRef.resolve(), secondCopyBranch)
def remove(self,
address: T.Union[TreeBase.ADDRESS_TYPES, "TreeBase",
None] = None,
delete=False,
emitDelta=None):
# print(address, type(address))
parent, child = self._getRemoveTarget(address)
# print(address, parent, child)
if parent is None:
return
if parent is not self:
return parent.remove(child, delete=delete, emitDelta=emitDelta)
emitDelta = emitDelta if emitDelta is not None else self.trackingDeltas
if emitDelta:
deletionDelta = TreeDeletionDelta(
TreeReference(child,
relParent=self.deltaTrackingRoot,
mode=TreeReference.Mode.Uid),
parentRef=TreeReference(self,
relParent=self.deltaTrackingRoot,
mode=TreeReference.Mode.Uid),
name=child.name,
value=child.value,
treeUid=child.uid,
index=child.index(),
treeCls=Tree)
self.emitStackDelta(deletionDelta)
if self.readOnly:
#print("read only returning")
return None
# check for read only
if self.readOnly:
raise PermissionError(
f"tree {self.address()} is read only, cannot set value")
return super(Tree, self).remove(address, delete=delete)
def setName(
self,
name,
allowMerging=False,
emitDelta=None,
):
""" if name is current name, do nothing
if emit delta, emit a delta
if this is read only, then return
if read-only, raise a permission error
if read-only overridden to False AND live input AND no deltas
just do nothing, this is super edge case
"""
oldName = self.name
if name == oldName:
return name
if self.parent:
if not allowMerging:
name = self.parent.getUniqueBranchName(name)
emitDelta = emitDelta if emitDelta is not None else self.trackingDeltas
if emitDelta:
delta = TreeNameDelta(
TreeReference(self, relParent=self.deltaTrackingRoot), oldName,
name)
self.emitStackDelta(delta)
if self.readOnly:
# print("post emit read only, returning")
return oldName
# check for read only
if self.readOnly:
raise PermissionError(
f"tree {self.address()} is read only, cannot set name")
super(Tree, self).setName(name, allowMerging=allowMerging)
return name
def setValue(self, val, emitDelta=None):
"""set this tree's value - optionally emitting a delta object"""
oldValue = self.value
# if value hasn't actually changed, ignore
# this often happens when linked to uis -
# less elegant, but way less cde
if val == oldValue:
#print("new value is old")
return
emitDelta = emitDelta if emitDelta is not None else self.trackingDeltas
if emitDelta:
delta = TreeValueDelta(
TreeReference(self, relParent=self.deltaTrackingRoot),
oldValue, val)
self.emitStackDelta(delta)
if self.readOnly:
return
# check for read only
if self.readOnly:
raise PermissionError(
f"tree {self.address()} is read only, cannot set value")
return super(Tree, self).setValue(val)
def setProxyTarget(self, proxyTargetObj: TreeBase):
self._treeRef = TreeReference(proxyTargetObj)
def getRef(self) -> TreeReference:
"""return a persistent reference to this branch"""
return TreeReference(self)