def _TestRemapping(fieldName):
layer = Sdf.Layer.CreateAnonymous()
srcPrimSpec = Sdf.CreatePrimInLayer(layer, "/Root/Instance")
listOp = Sdf.PathListOp()
listOp.explicitItems = ["/GlobalClass", "/Root/LocalClass"]
srcPrimSpec.SetInfo(fieldName, listOp)
# Copy the root prim spec. The paths in the listOp on the child
# prim that are beneath the root will be remapped to the new
# destination.
self.assertTrue(Sdf.CopySpec(layer, "/Root", layer, "/RootCopy"))
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
["/GlobalClass", "/RootCopy/LocalClass"]
self.assertEqual(
layer.GetPrimAtPath("/RootCopy/Instance").GetInfo(fieldName),
expectedListOp)
# Copy the child prim spec on which the inherit or specializes
# list is authored. Since the paths in the listOp are outside the
# root of the copy operation, none of them will be remapped.
self.assertTrue(
Sdf.CopySpec(layer, "/Root/Instance", layer, "/InstanceCopy"))
expectedListOp = listOp
self.assertEqual(
layer.GetPrimAtPath("/InstanceCopy").GetInfo(fieldName),
expectedListOp)
def main():
"""Run the main execution of the current script."""
source = Sdf.Layer.CreateAnonymous()
root = source.pseudoRoot
prim = Sdf.PrimSpec(root, "SomePrim", Sdf.SpecifierDef)
variant_set = Sdf.VariantSetSpec(prim, "SomeVariantSet")
variant = Sdf.VariantSpec(variant_set, "SomeVariant")
Sdf.PrimSpec(variant.primSpec, "InnerPrim", Sdf.SpecifierDef)
destination = Sdf.Layer.CreateAnonymous()
Sdf.CopySpec(source, "/SomePrim{SomeVariantSet=SomeVariant}", destination,
"/DestinationPrim")
# XXX : Notice that we have to call `CreatePrimInLayer` here but
# we didn't need to run it in the last example. That's because
# in this example, the parent Prim path "/Another" doesn't
# exist yet and has to be created before data can be copied to
# "/Another/DestinationPrim".
#
# In the previous example, "/" is the parent of "/DestinationPrim".
# And "/" always exists. So we didn't need to call
# `CreatePrimInLayer`. But generally, you usually should.
#
destination_prim = "/Another/DestinationPrim"
Sdf.CreatePrimInLayer(destination, destination_prim)
Sdf.CopySpec(
source,
"/SomePrim{SomeVariantSet=SomeVariant}",
destination,
destination_prim,
)
print(destination.ExportToString())
def test_ReferenceRemapping(self):
layer = Sdf.Layer.CreateAnonymous()
srcPrimSpec = Sdf.CreatePrimInLayer(layer, "/Root/Child")
srcPrimSpec.referenceList.explicitItems = [
# External reference
Sdf.Reference("./test.sdf", "/Ref"),
# External sub-root reference
Sdf.Reference("./test.sdf", "/Root/Ref"),
# Internal reference
Sdf.Reference("", "/Ref"),
# Internal sub-root reference
Sdf.Reference("", "/Root/Ref")
]
# Copy the root prim spec and verify that the internal sub-root
# references on the child prim that target a prim beneath /Root are
# remapped to /RootCopy.
self.assertTrue(Sdf.CopySpec(layer, "/Root", layer, "/RootCopy"))
expectedListOp = Sdf.ReferenceListOp()
expectedListOp.explicitItems = [
Sdf.Reference("./test.sdf", "/Ref"),
Sdf.Reference("./test.sdf", "/Root/Ref"),
Sdf.Reference("", "/Ref"),
Sdf.Reference("", "/RootCopy/Ref")
]
self.assertEqual(
layer.GetPrimAtPath("/RootCopy/Child").GetInfo("references"),
expectedListOp)
# Copy the child prim spec. Since all of the internal sub-root
# references point outside the root of the copy operation, none
# of them will be remapped.
self.assertTrue(Sdf.CopySpec(layer, "/Root/Child", layer,
"/ChildCopy"))
expectedListOp = Sdf.ReferenceListOp()
expectedListOp.explicitItems = [
Sdf.Reference("./test.sdf", "/Ref"),
Sdf.Reference("./test.sdf", "/Root/Ref"),
Sdf.Reference("", "/Ref"),
Sdf.Reference("", "/Root/Ref")
]
self.assertEqual(
layer.GetPrimAtPath("/ChildCopy").GetInfo("references"),
expectedListOp)
def copySpecToLayer(self, primPath, layer, destPrimPath):
"""Copies the specs of primPath and all children to a prim in another layer
Args:
primPath (`Sdf.Path`):
The path of the prims to copy
destPrimPath (`Sdf.Path`):
The destination path on the destination layer
layer (`Sdf.Layer`):
destination layer
"""
Sdf.CopySpec(self._layer, primPath, layer, destPrimPath)
def test_Relocates(self):
"""Tests that relocates are remapped to destination prim on copy"""
layer = Sdf.Layer.CreateAnonymous()
srcPrimSpec = Sdf.PrimSpec(layer, "Root", Sdf.SpecifierOver)
srcPrimSpec.relocates = { Sdf.Path("/Root/A") : Sdf.Path("/Root/B") }
self.assertTrue(Sdf.CopySpec(layer, "/Root", layer, "/Copy"))
self._VerifyExpectedData(
layer, expected = {
"/Copy" : {
"relocates" : { Sdf.Path("/Copy/A") : Sdf.Path("/Copy/B") },
"specifier" : Sdf.SpecifierOver
}
})
def test_Advanced(self):
"""Test using callbacks to control spec copying via
advanced API"""
l = Sdf.Layer.CreateAnonymous()
primSpec = Sdf.PrimSpec(l, "Root", Sdf.SpecifierOver)
primSpec.documentation = "prim docs"
primSpec.kind = "model"
# If callbacks just return True, all values and children are copied.
self.assertTrue(
Sdf.CopySpec(l,
"/Root",
l,
"/Copy",
shouldCopyValueFn=lambda *args: True,
shouldCopyChildrenFn=lambda *args: True))
dstPrimSpec = l.GetPrimAtPath("/Copy")
self._VerifyExpectedData(l,
expected={
"/Copy": {
"specifier": Sdf.SpecifierOver,
"documentation": "prim docs",
"kind": "model"
}
})
# Set up a value callback that skips copying a field and replaces
# the value of another field during the copy.
def shouldCopyValue(*args):
if args[1] == "documentation":
return False
elif args[1] == "kind":
return (True, "prop")
return True
self.assertTrue(
Sdf.CopySpec(l,
"/Root",
l,
"/Copy2",
shouldCopyValueFn=shouldCopyValue,
shouldCopyChildrenFn=lambda *args: True))
dstPrimSpec = l.GetPrimAtPath("/Copy2")
self._VerifyExpectedData(l,
expected={
"/Copy2": {
"specifier": Sdf.SpecifierOver,
"kind": "prop"
}
})
# Set up a children callback that skips copying properties.
attrSpecA = Sdf.AttributeSpec(primSpec, "A", Sdf.ValueTypeNames.Float)
attrSpecA.custom = True
attrSpecA.default = 1.0
attrSpecB = Sdf.AttributeSpec(primSpec, "B", Sdf.ValueTypeNames.Float)
attrSpecB.custom = True
attrSpecB.default = 2.0
def shouldCopyChildren(*args):
if args[0] == "properties":
return False
return True
self.assertTrue(
Sdf.CopySpec(l,
"/Root",
l,
"/Copy3",
shouldCopyValueFn=lambda *args: True,
shouldCopyChildrenFn=shouldCopyChildren))
dstPrimSpec = l.GetPrimAtPath("/Copy3")
self.assertEqual(list(dstPrimSpec.properties), [])
# Set up a children callback that copies the property named "A"
# to a property named "C" under the destination spec.
def shouldCopyChildren(*args):
if args[0] == "properties":
return (True, ["A"], ["C"])
return True
self.assertTrue(
Sdf.CopySpec(l,
"/Root",
l,
"/Copy4",
shouldCopyValueFn=lambda *args: True,
shouldCopyChildrenFn=shouldCopyChildren))
dstPrimSpec = l.GetPrimAtPath("/Copy4")
self.assertEqual(list(dstPrimSpec.properties),
[l.GetAttributeAtPath("/Copy4.C")])
self._VerifyExpectedData(l,
expected={
"/Copy4.C": {
"custom": True,
"default": 1.0,
"typeName": Sdf.ValueTypeNames.Float,
"variability": Sdf.VariabilityVarying
}
})
def test_Basic(self):
"""Tests basic spec copying functionality"""
srcLayer = Sdf.Layer.CreateAnonymous()
srcLayerStr = '''\
#sdf 1.4.32
def Scope "Root"
{
custom string attr = "root_attr"
custom rel rel
over "Child"
{
}
variantSet "vset" = {
"x" (documentation = "testing") {
over "VariantChild"
{
}
}
}
}
'''
srcLayer.ImportFromString(textwrap.dedent(srcLayerStr))
dstLayer = Sdf.Layer.CreateAnonymous()
# Copy the entire /Root prim spec.
self.assertTrue(Sdf.CopySpec(srcLayer, "/Root", dstLayer, "/RootCopy"))
self._VerifyExpectedData(dstLayer,
expected={
"/RootCopy": {
"specifier": Sdf.SpecifierDef,
"typeName": "Scope"
},
"/RootCopy.attr": {
"custom": True,
"typeName": Sdf.ValueTypeNames.String,
"default": "root_attr",
"variability": Sdf.VariabilityVarying
},
"/RootCopy.rel": {
"custom": True,
"variability": Sdf.VariabilityUniform
},
"/RootCopy/Child": {
"specifier": Sdf.SpecifierOver
},
"/RootCopy{vset=}": {},
"/RootCopy{vset=x}": {
"specifier": Sdf.SpecifierOver,
"documentation": "testing"
},
"/RootCopy{vset=x}VariantChild": {
"specifier": Sdf.SpecifierOver
},
})
# Create a parent prim spec to test copying property and variant specs.
Sdf.CreatePrimInLayer(dstLayer, "/NewRoot")
# Copy the /Root.attr attribute spec.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root.attr", dstLayer, "/NewRoot.attr2"))
self._VerifyExpectedData(dstLayer,
expected={
"/NewRoot.attr2": {
"custom": True,
"typeName": Sdf.ValueTypeNames.String,
"default": "root_attr",
"variability": Sdf.VariabilityVarying
}
})
# Copy the /Root.rel relationship spec.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root.rel", dstLayer, "/NewRoot.rel2"))
self._VerifyExpectedData(dstLayer,
expected={
"/NewRoot.rel2": {
"custom": True,
"variability": Sdf.VariabilityUniform
}
})
# Copy the /Root{vset=} variant set spec.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root{vset=}", dstLayer,
"/NewRoot{zset=}"))
self._VerifyExpectedData(dstLayer,
expected={
"/NewRoot{zset=}": {},
"/NewRoot{zset=x}": {
"specifier": Sdf.SpecifierOver,
"documentation": "testing"
},
"/NewRoot{zset=x}VariantChild": {
"specifier": Sdf.SpecifierOver
},
})
# Copy the /Root{vset=x} variant spec.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root{vset=x}", dstLayer,
"/NewRoot{zset=y}"))
self._VerifyExpectedData(dstLayer,
expected={
"/NewRoot{zset=y}": {
"specifier": Sdf.SpecifierOver,
"documentation": "testing"
},
"/NewRoot{zset=y}VariantChild": {
"specifier": Sdf.SpecifierOver
},
})
def test_RelationshipTargetRemapping(self):
"""Tests that relationship targets that point to a child of the
source path are remapped to the destination path."""
layer = Sdf.Layer.CreateAnonymous()
primSpec = Sdf.CreatePrimInLayer(layer, "/Test/Child")
relSpec = Sdf.RelationshipSpec(primSpec, "rel")
relSpec.targetPathList.explicitItems = \
[ "/Test/Child.attr2", "/Test/Child/Subchild.attr3",
"/Test/Sibling.attr" ]
relSpec.SetTargetMarker("/Test/Child.attr2", "final")
# Copy root prim and verify that targets on the child prim that
# point to objects beneath /Test are remapped to /TestCopy.
self.assertTrue(Sdf.CopySpec(layer, "/Test", layer, "/TestCopy"))
dstRelSpec = layer.GetRelationshipAtPath("/TestCopy/Child.rel")
self.assertTrue(dstRelSpec)
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
[ "/TestCopy/Child.attr2", "/TestCopy/Child/Subchild.attr3",
"/TestCopy/Sibling.attr" ]
self.assertEqual(dstRelSpec.GetInfo("targetPaths"), expectedListOp)
self.assertEqual(dstRelSpec.targetMarkers["/TestCopy/Child.attr2"],
"final")
# Copy prim with relationship and verify that targets that point
# to objects beneath the source /Test/Child prim are remapped to
# /Dest.
self.assertTrue(Sdf.CopySpec(layer, "/Test/Child", layer, "/Dest"))
dstRelSpec = layer.GetRelationshipAtPath("/Dest.rel")
self.assertTrue(dstRelSpec)
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
[ "/Dest.attr2", "/Dest/Subchild.attr3", "/Test/Sibling.attr" ]
self.assertEqual(dstRelSpec.GetInfo("targetPaths"), expectedListOp)
self.assertEqual(dstRelSpec.targetMarkers["/Dest.attr2"], "final")
# Same as above, but copy to variant to ensure that variant selection
# paths aren't authored into the connection list.
varSpec = Sdf.CreateVariantInLayer(layer, "/Variant", "version", "a")
self.assertTrue(
Sdf.CopySpec(layer, "/Test/Child", layer, "/Variant{version=a}"))
dstRelSpec = layer.GetRelationshipAtPath("/Variant{version=a}.rel")
self.assertTrue(dstRelSpec)
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
[ "/Variant.attr2", "/Variant/Subchild.attr3", "/Test/Sibling.attr" ]
self.assertEqual(dstRelSpec.GetInfo("targetPaths"), expectedListOp)
self.assertEqual(dstRelSpec.targetMarkers["/Variant.attr2"], "final")
# Copy from variant to variant, again to ensure that variant selection
# paths aren't authored into the connection list.
varSpec2 = Sdf.CreateVariantInLayer(layer, "/Variant", "version", "b")
self.assertTrue(
Sdf.CopySpec(layer, "/Variant{version=a}", layer,
"/Variant{version=b}"))
dstRelSpec = layer.GetRelationshipAtPath("/Variant{version=b}.rel")
self.assertTrue(dstRelSpec)
self.assertEqual(dstRelSpec.GetInfo("targetPaths"), expectedListOp)
self.assertEqual(dstRelSpec.targetMarkers["/Variant.attr2"], "final")
def test_AttributeConnectionRemapping(self):
"""Tests that attribute connections that point to a child of the
source path are remapped to the destination path."""
layer = Sdf.Layer.CreateAnonymous()
primSpec = Sdf.CreatePrimInLayer(layer, "/Test/Child")
attrSpec = Sdf.AttributeSpec(primSpec, "attr",
Sdf.ValueTypeNames.Float)
attrSpec.connectionPathList.explicitItems = \
[ "/Test/Child.attr2", "/Test/Child/Subchild.attr3",
"/Test/Sibling.attr" ]
attrSpec.SetConnectionMarker("/Test/Child.attr2", "final")
Sdf.MapperSpec(attrSpec, "/Test/Child.attr2", "mapper")
# Copy root prim and verify that connections on the child prim that
# point to objects beneath /Test are remapped to /TestCopy.
self.assertTrue(Sdf.CopySpec(layer, "/Test", layer, "/TestCopy"))
dstAttrSpec = layer.GetAttributeAtPath("/TestCopy/Child.attr")
self.assertTrue(dstAttrSpec)
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
[ "/TestCopy/Child.attr2", "/TestCopy/Child/Subchild.attr3",
"/TestCopy/Sibling.attr" ]
self.assertEqual(dstAttrSpec.GetInfo("connectionPaths"),
expectedListOp)
self.assertEqual(
dstAttrSpec.connectionMarkers["/TestCopy/Child.attr2"], "final")
# Copy prim with attribute and verify that connections that point
# to objects beneath the source /Test/Child prim are remapped to
# /Dest.
self.assertTrue(Sdf.CopySpec(layer, "/Test/Child", layer, "/Dest"))
dstAttrSpec = layer.GetAttributeAtPath("/Dest.attr")
self.assertTrue(dstAttrSpec)
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
[ "/Dest.attr2", "/Dest/Subchild.attr3", "/Test/Sibling.attr" ]
self.assertEqual(dstAttrSpec.GetInfo("connectionPaths"),
expectedListOp)
self.assertEqual(dstAttrSpec.connectionMarkers["/Dest.attr2"], "final")
self.assertTrue(dstAttrSpec.connectionMappers["/Dest.attr2"].typeName,
"mapper")
# Same as above, but copy to variant to ensure that variant selection
# paths aren't authored into the connection list.
varSpec = Sdf.CreateVariantInLayer(layer, "/Variant", "version", "a")
self.assertTrue(
Sdf.CopySpec(layer, "/Test/Child", layer, "/Variant{version=a}"))
dstAttrSpec = layer.GetAttributeAtPath("/Variant{version=a}.attr")
self.assertTrue(dstAttrSpec)
expectedListOp = Sdf.PathListOp()
expectedListOp.explicitItems = \
[ "/Variant.attr2", "/Variant/Subchild.attr3", "/Test/Sibling.attr" ]
self.assertEqual(dstAttrSpec.GetInfo("connectionPaths"),
expectedListOp)
self.assertEqual(dstAttrSpec.connectionMarkers["/Variant.attr2"],
"final")
self.assertTrue(
dstAttrSpec.connectionMappers["/Variant.attr2"].typeName, "mapper")
# Copy from variant to variant, again to ensure that variant selection
# paths aren't authored into the connection list.
varSpec2 = Sdf.CreateVariantInLayer(layer, "/Variant", "version", "b")
self.assertTrue(
Sdf.CopySpec(layer, "/Variant{version=a}", layer,
"/Variant{version=b}"))
dstAttrSpec = layer.GetAttributeAtPath("/Variant{version=b}.attr")
self.assertTrue(dstAttrSpec)
self.assertEqual(dstAttrSpec.GetInfo("connectionPaths"),
expectedListOp)
self.assertEqual(dstAttrSpec.connectionMarkers["/Variant.attr2"],
"final")
self.assertTrue(
dstAttrSpec.connectionMappers["/Variant.attr2"].typeName, "mapper")
def test_Overwrite(self):
"""Tests that copying a spec will overwrite a pre-existing spec
completely."""
srcLayer = Sdf.Layer.CreateAnonymous()
srcLayerStr = '''\
#sdf 1.4.32
def "Empty"
{
}
def Scope "Root"
{
custom string attr = "root_attr"
custom rel rel
over "Child"
{
}
variantSet "vset" = {
"x" (documentation = "root") {
over "RootVariantChild"
{
}
}
}
}
def Scope "Copy"
{
double attr = 1.0
rel rel
over "Child"
{
}
variantSet "vset" = {
"y" (kind = "model") {
over "CopyVariantChild"
{
}
}
}
}
'''
srcLayer.ImportFromString(textwrap.dedent(srcLayerStr))
# Copy the /Root{vset=x} variant spec over /Copy{vset=y}
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root{vset=x}", srcLayer, "/Copy{vset=y}"))
self._VerifyExpectedData(srcLayer,
expected={
"/Copy{vset=y}": {
"specifier": Sdf.SpecifierOver,
"documentation": "root"
},
"/Copy{vset=y}RootVariantChild": {
"specifier": Sdf.SpecifierOver
}
})
self.assertFalse(
srcLayer.GetObjectAtPath("/Copy{vset=y}CopyVariantChild"))
# Copy the /Root{vset=} variant set spec over /Copy{vset=}
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root{vset=}", srcLayer, "/Copy{vset=}"))
self._VerifyExpectedData(srcLayer,
expected={
"/Copy{vset=}": {},
"/Copy{vset=x}": {
"specifier": Sdf.SpecifierOver,
"documentation": "root"
},
"/Copy{vset=x}RootVariantChild": {
"specifier": Sdf.SpecifierOver
}
})
self.assertFalse(srcLayer.GetObjectAtPath("/Copy{vset=y}"))
# Copy the /Root.attr attribute spec over /Copy.attr
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root.attr", srcLayer, "/Copy.attr"))
self._VerifyExpectedData(srcLayer,
expected={
"/Copy.attr": {
"custom": True,
"typeName": Sdf.ValueTypeNames.String,
"default": "root_attr",
"variability": Sdf.VariabilityVarying
}
})
# Copy the /Root.rel relationship spec over /Copy.rel
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Root.rel", srcLayer, "/Copy.rel"))
self._VerifyExpectedData(srcLayer,
expected={
"/Copy.rel": {
"custom": True,
"variability": Sdf.VariabilityUniform
}
})
# Copy the /Empty relationship spec over /Copy
self.assertTrue(Sdf.CopySpec(srcLayer, "/Empty", srcLayer, "/Copy"))
self._VerifyExpectedData(
srcLayer, expected={"/Copy": {
"specifier": Sdf.SpecifierDef
}})
dstSpec = srcLayer.GetPrimAtPath("/Copy")
self.assertEqual(list(dstSpec.nameChildren), [])
self.assertEqual(list(dstSpec.properties), [])
def test_CopyPrimsAndVariant(self):
"""Tests that a prim spec can be copied to a variant and vice-versa."""
srcLayer = Sdf.Layer.CreateAnonymous()
srcLayerStr = '''\
#sdf 1.4.32
def SourceType "Source"
{
double attr = 1.0
def "Child"
{
}
variantSet "y" = {
"a" {
double attr = 1.0
def "Child"
{
}
}
}
}
over "OverSource"
{
variantSet "x" = {
"a" {
def "Child"
{
}
}
}
}
def "Dest"
{
variantSet "x" = {
"a" {
}
}
}
def "Dest2"
{
}
'''
srcLayer.ImportFromString(textwrap.dedent(srcLayerStr))
# Copy the /Source prim over /Dest{x=a}
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Source", srcLayer, "/Dest{x=a}"))
self._VerifyExpectedData(srcLayer,
expected={
"/Dest{x=a}": {
"specifier": Sdf.SpecifierOver,
},
"/Dest{x=a}.attr": {
"typeName": Sdf.ValueTypeNames.Double,
"default": 1.0,
"variability": Sdf.VariabilityVarying,
"custom": False
},
"/Dest{x=a}Child": {
"specifier": Sdf.SpecifierDef
},
"/Dest{x=a}{y=a}": {
"specifier": Sdf.SpecifierOver
},
"/Dest{x=a}{y=a}.attr": {
"typeName": Sdf.ValueTypeNames.Double,
"default": 1.0,
"variability": Sdf.VariabilityVarying,
"custom": False
},
"/Dest{x=a}{y=a}Child": {
"specifier": Sdf.SpecifierDef
}
})
# Copy the /Source prim into a new variant /Dest{x=b}
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Source", srcLayer, "/Dest{x=b}"))
self._VerifyExpectedData(srcLayer,
expected={
"/Dest{x=b}": {
"specifier": Sdf.SpecifierOver,
},
"/Dest{x=b}.attr": {
"typeName": Sdf.ValueTypeNames.Double,
"default": 1.0,
"variability": Sdf.VariabilityVarying,
"custom": False
},
"/Dest{x=b}Child": {
"specifier": Sdf.SpecifierDef
},
"/Dest{x=b}{y=a}": {
"specifier": Sdf.SpecifierOver
},
"/Dest{x=b}{y=a}.attr": {
"typeName": Sdf.ValueTypeNames.Double,
"default": 1.0,
"variability": Sdf.VariabilityVarying,
"custom": False
},
"/Dest{x=b}{y=a}Child": {
"specifier": Sdf.SpecifierDef
}
})
# Copy the /Source{y=a} variant over /Dest2
# Note the specifier and typename from the source variant's owning
# prim are copied over to the destination prim.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Source{y=a}", srcLayer, "/Dest2"))
self._VerifyExpectedData(srcLayer,
expected={
"/Dest2": {
"specifier": Sdf.SpecifierDef,
"typeName": "SourceType"
},
"/Dest2.attr": {
"typeName": Sdf.ValueTypeNames.Double,
"default": 1.0,
"variability": Sdf.VariabilityVarying,
"custom": False
},
"/Dest2/Child": {
"specifier": Sdf.SpecifierDef
}
})
# Copy the /Source{y=a} variant into a new prim /Dest3
# Note the specifier and typename from the source variant's owning
# prim are copied over to the to the destination prim.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/Source{y=a}", srcLayer, "/Dest3"))
self._VerifyExpectedData(srcLayer,
expected={
"/Dest3": {
"specifier": Sdf.SpecifierDef,
"typeName": "SourceType"
},
"/Dest3.attr": {
"typeName": Sdf.ValueTypeNames.Double,
"default": 1.0,
"variability": Sdf.VariabilityVarying,
"custom": False
},
"/Dest3/Child": {
"specifier": Sdf.SpecifierDef
}
})
# Copy the /OverSource variant into a new prim /Dest4.
# Note the specifier and typename from the source variant's owning
# prim are copied over to the to the destination prim.
self.assertTrue(
Sdf.CopySpec(srcLayer, "/OverSource{x=a}", srcLayer, "/Dest4"))
self._VerifyExpectedData(srcLayer,
expected={
"/Dest4": {
"specifier": Sdf.SpecifierOver,
},
"/Dest4/Child": {
"specifier": Sdf.SpecifierDef
}
})
def pushCopySpecs(self, srcStage, srcLayer, srcSdfPath, dstStage, dstLayer,
dstSdfPath):
newPrimDstSdfPath = "{}_cache".format(dstSdfPath)
Sdf.CopySpec(srcLayer, srcSdfPath, dstLayer, newPrimDstSdfPath)
return customRigPrimUpdater.PushCopySpecs.Prune
