def _CheckDependencies(self, usdStage, layerDeps, assetDeps,
unresolvedPaths):
from pxr import Ar
def _IsPackageOrPackagedLayer(layer):
return layer.GetFileFormat().IsPackage() or \
Ar.IsPackageRelativePath(layer.identifier)
# Process every package just once by storing them all in a set.
packages = set()
for layer in layerDeps:
if _IsPackageOrPackagedLayer(layer):
packagePath = Ar.SplitPackageRelativePathInner(
layer.identifier)[0]
packages.add(packagePath)
self._CheckLayer(layer)
for package in packages:
self._CheckPackage(package)
# If the root layer is a package, validate that all the loaded layers
# belong to the package.
rootLayer = usdStage.GetRootLayer()
if self._arkit and _IsPackageOrPackagedLayer(rootLayer):
packagePath = usdStage.GetRootLayer().realPath
if packagePath:
if Ar.IsPackageRelativePath(packagePath):
packagePath = Ar.SplitPackageRelativePathOuter(
packagePath)[0]
for layer in layerDeps:
# In-memoery layers that session layers won't have a real
# path. We can skip them.
if layer.realPath:
if not layer.realPath.startswith(packagePath):
self._AddFailedCheck(
"Found loaded layer '%s' that "
"does not belong to the package '%s'." %
(layer.identifier, packagePath),
ruleNum=4)
for asset in assetDeps:
if not asset.startswith(packagePath):
self._AddFailedCheck(
"Found asset reference '%s' that "
"does not belong to the package '%s'." %
(asset, packagePath),
ruleNum=4)
for unresolvedPath in unresolvedPaths:
self._AddFailedCheck(
"Found unresolvable external dependency '%s'." %
unresolvedPath,
ruleNum=4)
def GetAssetCreationTime(primStack, assetIdentifier):
"""Finds the weakest layer in which assetInfo.identifier is set to
'assetIdentifier', and considers that an "asset-defining layer". We then
retrieve the creation time for the asset by stat'ing the layer's
real path.
Returns a triple of strings: (fileDisplayName, creationTime, owner)"""
definingLayer = None
for spec in reversed(primStack):
if spec.HasInfo('assetInfo'):
identifier = spec.GetInfo('assetInfo')['identifier']
if identifier == assetIdentifier:
definingLayer = spec.layer
break
if definingLayer:
definingFile = definingLayer.realPath
else:
definingFile = primStack[-1].layer.realPath
print "Warning: Could not find expected asset-defining layer for %s" %\
assetIdentifier
if Ar.IsPackageRelativePath(definingFile):
definingFile = Ar.SplitPackageRelativePathOuter(definingFile)[0]
if not definingFile:
displayName = (definingLayer.GetDisplayName()
if definingLayer and definingLayer.anonymous else
"<in-memory layer>")
creationTime = "<unknown>"
owner = "<unknown>"
else:
displayName = definingFile.split('/')[-1]
try:
creationTime = time.ctime(os.stat(definingFile).st_ctime)
except:
creationTime = "<unknown>"
owner = GetFileOwner(definingFile)
return (displayName, creationTime, owner)
def CheckDependencies(self, usdStage, layerDeps, assetDeps):
rootLayer = usdStage.GetRootLayer()
if not _IsPackageOrPackagedLayer(rootLayer):
return
packagePath = usdStage.GetRootLayer().realPath
if packagePath:
if Ar.IsPackageRelativePath(packagePath):
packagePath = Ar.SplitPackageRelativePathOuter(
packagePath)[0]
for layer in layerDeps:
# In-memory layers like session layers (which we must skip when
# doing this check) won't have a real path.
if layer.realPath:
if not layer.realPath.startswith(packagePath):
self._AddFailedCheck("Found loaded layer '%s' that "
"does not belong to the package '%s'." %
(layer.identifier, packagePath))
for asset in assetDeps:
if not asset.startswith(packagePath):
self._AddFailedCheck("Found asset reference '%s' that "
"does not belong to the package '%s'." %
(asset, packagePath))
def test_SplitPackageRelativePathOuter(self):
"""Test Ar.SplitPackageRelativePathOuter"""
self.assertEqual(Ar.SplitPackageRelativePathOuter(""), ("", ""))
self.assertEqual(Ar.SplitPackageRelativePathOuter("foo.file"),
("foo.file", ""))
self.assertEqual(
Ar.SplitPackageRelativePathOuter("foo.pack[bar.file]"),
("foo.pack", "bar.file"))
self.assertEqual(
Ar.SplitPackageRelativePathOuter("foo.pack[bar.pack[baz.file]]"),
("foo.pack", "bar.pack[baz.file]"))
self.assertEqual(
Ar.SplitPackageRelativePathOuter("foo[0].pack[bar.file]"),
("foo[0].pack", "bar.file"))
# Corner case: ensure delimiter characters in paths are unescaped
# when removed from delimiters by Ar.SplitPackageRelativePathOuter.
self.assertEqual(
Ar.SplitPackageRelativePathOuter(
"foo]a.pack[bar\\[b.pack[baz\\]c.file]]"),
("foo]a.pack", "bar[b.pack[baz\\]c.file]"))
def main():
import argparse
parser = argparse.ArgumentParser(
prog=os.path.basename(sys.argv[0]),
description='Convert a usd-readable file to the usd ascii format in \n'
'a temporary location and invoke an editor on it. After \n'
'saving and quitting the editor, the edited file will be \n'
'converted back to the original format and OVERWRITE the \n'
'original file, unless you supply the "-n" (--noeffect) flag, \n'
'in which case no changes will be saved back to the original '
'file. \n'
'The editor to use will be looked up as follows: \n'
' - USD_EDITOR environment variable \n'
' - EDITOR environment variable \n'
' - emacs in PATH \n'
' - vim in PATH \n'
' - notepad in PATH \n'
'\n\n')
parser.add_argument('-n',
'--noeffect',
dest='readOnly',
action='store_true',
help='Do not edit the file.')
parser.add_argument('-f',
'--forcewrite',
dest='forceWrite',
action='store_true',
help='Override file permissions to allow writing.')
parser.add_argument('-p',
'--prefix',
dest='prefix',
action='store',
type=str,
default=None,
help='Provide a prefix for the temporary file name.')
parser.add_argument('usdFileName', help='The usd file to edit.')
results = parser.parse_args()
# pull args from result map so we don't need to write result. for each
readOnly, forceWrite, usdFileName, prefix = (results.readOnly,
results.forceWrite,
results.usdFileName,
results.prefix)
# verify our usd file exists, and permissions args are sane
if readOnly and forceWrite:
sys.exit("Error: Cannot set read only(-n) and force "
" write(-f) together.")
from pxr import Ar
resolvedPath = Ar.GetResolver().Resolve(usdFileName)
if not resolvedPath:
sys.exit("Error: Cannot find file %s" % usdFileName)
# Layers in packages cannot be written using the Sdf API.
from pxr import Ar, Sdf
(package, packaged) = Ar.SplitPackageRelativePathOuter(resolvedPath)
extension = Sdf.FileFormat.GetFileExtension(package)
fileFormat = Sdf.FileFormat.FindByExtension(extension)
if not fileFormat:
sys.exit("Error: Unknown file format")
if fileFormat.IsPackage():
print("Warning: Edits cannot be saved to layers in %s files. "
"Starting in no-effect mode." % extension)
readOnly = True
forceWrite = False
writable = os.path.isfile(usdFileName) and os.access(usdFileName, os.W_OK)
if not (writable or readOnly or forceWrite):
sys.exit("Error: File isn't writable, and "
"readOnly(-n)/forceWrite(-f) haven't been marked.")
# ensure we have both a text editor and usdcat available
usdcatCmd, editorCmd = _findEditorTools(usdFileName, readOnly)
# generate our temporary file with proper permissions and edit.
usdaFile, usdaFileName = _generateTemporaryFile(usdcatCmd, usdFileName,
readOnly, prefix)
tempFileChanged = _editTemporaryFile(editorCmd, usdaFileName)
if (not readOnly or forceWrite) and tempFileChanged:
# note that we need not overwrite usdFileName's write permissions
# because we will be creating a new layer at that path.
if not _writeOutChanges(temporaryFileName=usdaFileName,
permanentFileName=usdFileName):
sys.exit("Error: Unable to save edits back to the original file %s"
". Your edits can be found in %s. " \
%(usdFileName, usdaFileName))
os.close(usdaFile)
os.remove(usdaFileName)
