def contains(self, sAbsPath):
sLibPath = normCase(self.absPath())
sPathDirs = pathSplitDirs(normCase(sAbsPath))
numDirs = len(pathSplitDirs(sLibPath))
sAlignedPath = pathJoin(*sPathDirs[:numDirs])
return sAlignedPath == sLibPath
def projectNameFromPath(p):
sConfPkg = os.environ.get("DAVOS_CONF_PACKAGE", "davos.config")
pkg = importModule(sConfPkg)
sPkgDirPath = os.path.dirname(pkg.__file__)
sDirList = pathSplitDirs(p)
for sFilename in os.listdir(sPkgDirPath):
bIgnored = False
for sPatrn in ("__*", ".*", "*.pyc"):
if fnmatch(sFilename, sPatrn):
bIgnored = True
break
if bIgnored:
continue
sModName = os.path.splitext(sFilename)[0]
m = importModule(sConfPkg + "." + sModName)
sProjDir = m.project.dir_name
if sProjDir in sDirList:
return sModName
return ""
def _belowPack(p):
p = osp.dirname(p)
for sDirName in pathSplitDirs(p):
if _isPack(sDirName):
return True
return False
def sectionFromPath(self, sEntryPath, library=None):
sEntryPath = normCase(sEntryPath)
sEntryPathDirs = pathSplitDirs(normCase(sEntryPath))
sectionDataList = sorted(self.iterSectionPaths(library=library),
key=lambda x: len(x[2]),
reverse=True)
for sSpace, sSection, sSectionPath in sectionDataList:
if pathStartsWith(sEntryPath, sSectionPath, pathSplits=sEntryPathDirs):
return sSpace, sSection
return "", ""
def fromPaths(cls, paths):
tree = cls()
for p in paths:
dirs = pathSplitDirs(p)
children = tree
for d in dirs:
if d not in children:
nxtChilds = cls()
children[d] = nxtChilds
else:
nxtChilds = children[d]
children = nxtChilds
return tree
def fromPaths(cls, paths):
tree = cls()
for p in paths:
dirs = pathSplitDirs(p)
children = tree
for d in dirs:
if d not in children:
nxtChilds = cls()
children[d] = nxtChilds
else:
nxtChilds = children[d]
children = nxtChilds
return tree
def launch_old(entityType="", dryRun=True, project="", dialogParent=None):
global TREE_ITEM_DCT
TREE_ITEM_DCT = {}
app = qtGuiApp()
if not app:
app = QtGui.QApplication(sys.argv)
sProject = os.environ["DAVOS_INIT_PROJECT"] if not project else project
proj = DamProject(sProject)
print sProject.center(80, "-")
dlg = QuickTreeDialog(dialogParent)
treeWdg = dlg.treeWidget
treeWdg.setHeaderLabels(("Entity Name", "Infos"))
dlg.show()
missingPathItems = listMissingPathItems(proj, entityType)
badEntityItems = []
for damEntity, sMissingPaths in missingPathItems:
if isinstance(damEntity, basestring):
badEntityItems.append((damEntity, sMissingPaths))
continue
drcLib = proj.getLibrary("public", damEntity.libraryName)
sLibPath = drcLib.absPath()
sEntityTitle = damEntity.sgEntityType + 's'
sEntityPath = damEntity.getPath("public")
sEntityPath = re.sub("^" + sLibPath, sEntityTitle, sEntityPath)
sEntityPathDirs = pathSplitDirs(sEntityPath)
for sAbsPath in sMissingPaths:
sTreePath = re.sub("^" + sLibPath, sEntityTitle, sAbsPath)
sParentPath, sFilename = osp.split(pathNorm(sTreePath))
parentItem = TREE_ITEM_DCT.get(sParentPath)
if not parentItem:
sDirList = pathSplitDirs(sParentPath)
curParentItem = treeWdg
for i, sDirName in enumerate(sDirList):
if i == 0:
sItemPath = sDirName
else:
sItemPath = pathJoin(*sDirList[:i + 1])
item = TREE_ITEM_DCT.get(sItemPath)
if not item:
flags = None
if sItemPath.startswith(sEntityPath):
if len(pathSplitDirs(sItemPath)) > len(sEntityPathDirs):
flags = Qt.NoItemFlags
userData = None
if sItemPath == sEntityPath:
userData = damEntity
item = loadTreeItem(curParentItem, sItemPath, [sDirName],
flags=flags, userData=userData)
curParentItem = item
parentItem = curParentItem
flags = None
if sTreePath.startswith(sEntityPath):
if len(pathSplitDirs(sTreePath)) > len(sEntityPathDirs):
flags = Qt.NoItemFlags
userData = None
if sTreePath == sEntityPath:
userData = damEntity
loadTreeItem(parentItem, sTreePath, [sFilename], flags=flags, userData=userData)
if badEntityItems:
errorsItem = loadTreeItem(None, "Errors", ["ERRORS"])
treeWdg.insertTopLevelItem(0, errorsItem)
for sEntityName, sError in badEntityItems:
loadTreeItem(errorsItem, sEntityName, [sEntityName, sError],
checkable=False)
for i in xrange(treeWdg.topLevelItemCount()):
treeWdg.topLevelItem(i).setExpanded(True)
while True:
bOk = dlg.exec_()
if not bOk:
return
bApply = False
flags = (QTreeWidgetItemIterator.Checked | QTreeWidgetItemIterator.Enabled)
treeIter = QTreeWidgetItemIterator(treeWdg, flags)
damEntities = tuple(it.value().data(0, Qt.UserRole) for it in treeIter)
damAssets = tuple(e for e in damEntities if isinstance(e, DamAsset))
damShots = tuple(e for e in damEntities if isinstance(e, DamShot))
if damAssets or damShots:
sMsg = "Create directories and files for:\n"
if damAssets:
sMsg += "\n - {} Assets".format(len(damAssets))
if damShots:
sMsg += "\n - {} Shots".format(len(damShots))
sConfirm = confirmDialog(title="WARNING !",
message=sMsg,
button=("Yes", "No"),
defaultButton="No",
cancelButton="No",
dismissString="No",
icon="warning",
)
if sConfirm == "Yes":
bApply = True
break
if bApply:
for damEntity in damEntities:
if not damEntity:
continue
damEntity.createDirsAndFiles(dryRun=dryRun)
def sortValue(sRcPath):
n = len(pathSplitDirs(sRcPath))
if n == numPubDirs:
return sys.maxint
else:
return n
def contextFromPath(self, entryObjOrPath, library=None, warn=True):
if isinstance(entryObjOrPath, DrcEntry):
drcEntry = entryObjOrPath
library = drcEntry.library
else:
drcEntry = self.entryFromPath(entryObjOrPath, library=library,
dbNode=False, weak=True, warn=warn)
if not drcEntry:
logMsg("no entry found for '{}'".format(entryObjOrPath), log="debug")
return {"abs_path":entryObjOrPath, "rc_entry":None}
elif not library:
library = drcEntry.library
sAbsPath = drcEntry.absPath()
ctxData = {"abs_path":sAbsPath, "rc_entry":drcEntry}
sFoundRcName = ""
bExactRc = False
if drcEntry == library:
sSection = library.sectionName
sSpace = library.space
else:
sSpace, sSection = self.sectionFromPath(sAbsPath, library=library)
if not sSection:
logMsg("no section found for '{}'".format(sAbsPath), log="debug")
return ctxData
bIsFile = isinstance(drcEntry, DrcFile)
if not drcEntry.isPublic():
if bIsFile:
pubEntry = drcEntry.getPublicFile(fail=True, weak=True, dbNode=False)
else:
pubEntry = drcEntry.getHomonym("public", weak=True)
else:
pubEntry = drcEntry
pubLib = pubEntry.library
if bIsFile and pubEntry.isVersionFile():
ctxData["version"] = pubEntry.versionFromName()
pubEntry = pubEntry.getHeadFile(fail=True, dbNode=False)
sPublicPath = pubEntry.absPath()
sPubPathDirs = pathSplitDirs(sPublicPath)
numPubDirs = len(sPubPathDirs)
def sortValue(sRcPath):
n = len(pathSplitDirs(sRcPath))
if n == numPubDirs:
return sys.maxint
else:
return n
sRcPathList = sorted(self.iterRcPaths("public", sSection, resVars=True),
key=lambda x: sortValue(x[1]), reverse=True)
sSectionPath = self.getPath("public", sSection, default="", resVars=False)
if sSectionPath:
sRcPathList.append(("", sSectionPath))
parseRes = None
sCurPubPath = sPublicPath
numCurPubDirs = numPubDirs
while (not sFoundRcName) and (not pathEqual(sCurPubPath, pubLib.absPath())):
for sRcName, sRcPath in sRcPathList:
numRcDirs = len(pathSplitDirs(sRcPath))
if numRcDirs != numCurPubDirs:
continue
parseRes = pathParse(sRcPath, sCurPubPath)
#print "\n", sRcPath, sCurPubPath, parseRes, sRcName
if parseRes and parseRes.named:
sFoundRcName = sRcName
if numRcDirs == numPubDirs:
bExactRc = True
#print sRcName
break
sCurPubPath = osp.dirname(sCurPubPath)
numCurPubDirs = len(pathSplitDirs(sCurPubPath))
if not parseRes:
logMsg("no parsing results for '{}'".format(sCurPubPath), log="debug")
return ctxData
ctxData.update(parseRes.named)
ctxData["section"] = sSection
ctxData["space"] = sSpace
ctxData["library"] = library
if sFoundRcName:
sRawRcPath = self.getPath("public", sSection, sFoundRcName, resVars=False)
parseRes = pathParse(sRawRcPath, sPublicPath)
ctxData.update((k, v) for k, v in parseRes.named.iteritems()
if k not in ctxData)
if bExactRc:
ctxData["resource"] = sFoundRcName
sStepDir = ctxData.get("step", "")
if sStepDir:
sSgStepDct = self.getVar(sSection, "sg_step_map", default={})
if sStepDir in sSgStepDct:
ctxData['sg_step'] = sSgStepDct[sStepDir]
damEntity = None
if "name" in ctxData:
damEntity = self._entityFromContext(ctxData, fail=False)
ctxData["dam_entity"] = damEntity
return ctxData
