def __init__(self, shot_only=False, asset_only=False, verbose=False): """Create an instance, (simple fast nothing important :param shot_only: if True will not load asset :param asset_only: if True will not load shot :param verbose: display query timing information to database """ if shot_only == True: log.info("*" * 20 + " running query for shot only " + "*" * 20) if asset_only == True: log.info("*" * 20 + " running query for asset only " + "*" * 20) super(DbCache, self).__init__() self._shot_only = shot_only self._asset_only = asset_only self.verbose = verbose self.reset() self._asset_type = list() self._group_perm = list() self._cache_group = dict( ) # to build temporary cache for pipeline config
def load_asset_if_not(self, db, asset_names): """Load none asset loaded into show :param: asset_names (list/str): a valid code name for asset """ from dsk.base.db_helper.db_helper_funct import ShotgunQuery as SQ if isinstance(asset_names, basestring): asset_names = [asset_names] assets = self.get_assets() in_all_ready = assets.childNames() to_query = list() all_ready_there = list() for s in asset_names: if s not in in_all_ready: to_query.append(s) else: ch = assets.getChildByName(s) if ch is None: log.error("cannot retrieve asset: %s", s) else: all_ready_there.append(ch) asset_list = list() if len(to_query) > 0: asset_list = SQ.assets_with_id(self.id, to_query, db.get_conn()) self.init_with_assets(asset_list) return asset_list + all_ready_there
def simple_clone(self, release_top_location, branch=""): """Clone an accessible remote git address to a top location :param release_top_location: (str existing branch) a place to install :param branch: (str) an optional existing branch :return ResultRepoInstall: success errors log atag """ if not os.path.isdir(release_top_location): log.error("release area needs to exist, %s doen't" % release_top_location) return False x = GitUtils(release_top_location) try: #The repo gets clone in this function x.clone_repo(self.src_repo, "", branch) except Exception as e: log.error(str(e)) return ResultRepoInstall(False, [str(e)], ['failed simple_clone'], None) return ResultRepoInstall(True, ["no error"], ['done simple_clone'], None)
def get_current_confpipe(self, showobj): SW.start() res = showobj.get_current_confpipe(self) SW.stop() if self.verbose: log.info("get_current_confpipe in {}".format(SW.elapsed())) return res
def addChild(self,ch,withRename = False): # be sure that that it's valid child import traceback if isinstance(ch,Tdata): if ch in self.getChildren(): return chname = self.findUniqueChildName(ch.getName()) if withRename == True: # be sure that the child name is unique ch.setName(chname) self.__Children.append(ch) else: if chname != ch.getName(): # an object of the same name # exist an need to be replace childN = self.childNames() try: index = childN.index(ch.getName()) self.__Children.pop(index) self.__Children.insert(index,ch) except: traceback.print_exc() self.error("addChild","big Trouble in addChild") sys.exit(1) else: self.__Children.append(ch) ch.setParent(self) else: MsgUtils.warning("addChild","Can't add %s to my children List" % ch)
def inspect_shot_depend(self, showobj, shotobj): """Load the needed filepublish :param showobj: a ShowInfoDb object :param shotobj: a ShotInfoDb object """ SW.start() # this needs to isolated typeList = getShotMapping(showobj.getName()) allready = shotobj.get_publishedType() allready = [x.getName() for x in allready] typeListMissing = OrderedDict() for i in typeList: if not typeList[i].short_name in allready: typeListMissing[i] = typeList[i].short_name if len(typeListMissing) > 0: file_type_obj_list = self._get_ft(typeListMissing) pf_list = self.shotid_filepubobj_query(showobj, shotobj, file_type_obj_list) for k, pf in zip(typeListMissing.keys(), pf_list): shotobj.set_plublished_type(typeListMissing[k], pf) SW.stop() if self.verbose: log.info("shotid_filepub_query in {}".format(SW.elapsed()))
def start_engine(engine_name="tk-shell"): """Start the given engine in the given context. If no context is provided, start the engine in the project context :param engine_name: Name of the engine to start :returns: The running engine """ import tank current_engine = tank.platform.current_engine() if current_engine: return current_engine pc_path = os.environ.get("TANK_CURRENT_PC") #--------------------------------------------------------------------------- try: tk = tank.sgtk_from_path(pc_path) ctx = tk.context_from_path(tk.project_path) current_engine = tank.platform.start_engine(engine_name, tk, ctx) return current_engine except Exception as e: log.error("Failed to start Engine - %s" % str(e)) traceback.print_exc() return None
def updateEnable(self, msg): if msg.widgetFrom() != self: log.error("updateEnable,should be not getting this update") return if msg.succeed(): for item in msg.getOptions(): item.updateEnable()
def inspect_shot_asset_depend(self, showobj, assetobj): """Load the needed filepublish :param showobj: a ShowInfoDb object :param assetobj: a AssetInfoDb object """ typeList = getAssetMapping(showobj.getName()) assets_name = assetobj.get_asset_names() asset_obj_list = showobj.load_asset_if_not(self, assets_name) SW.start() for assobj in asset_obj_list: allready = assobj.get_publishedType() allready = [x.getName() for x in allready] typeListMissing = OrderedDict() for i in typeList: if not typeList[i].short_name in allready: typeListMissing[i] = typeList[i].short_name if len(typeListMissing) == 0: continue file_type_obj_list = self._get_ft(typeListMissing) pf_list = self.assetid_filepubobj_query(showobj, assobj, file_type_obj_list) for k, pf in zip(typeListMissing.keys(), pf_list): # update data list assobj.set_plublished_type(typeListMissing[k], pf) SW.stop() if self.verbose: log.info("assetid_filepub_query in {}".format(SW.elapsed()))
def create_path(fullPath): try: os.mkdir(fullPath, 0o775) return True except: MsgUtils.msg("Cannot create %r" % fullPath) return False
def get_iconfile(self, db, location, base_res=64): """Return iconfile. if iconfile == "", use thumbnailurl - download thumbnailurl - convert and resize image to png of the needed res :param location: a directory to download the image :param conn: a shotgun connection :param base_res: resolution in x, keep aspect """ if self.iconfile != "" and os.path.isfile(self.iconfile): return self.iconfile if self.thumbnailurl != "": dest = os.path.join(location, self.getName() + ".jpg") # destpng = os.path.join(location, self.getName()+".png") destjpg = dest if not os.path.isfile(destjpg): try: db.download_icon(self.thumbnailurl, dest) except Exception as e: log.error(str(e)) return "" self.iconfile = destjpg return self.iconfile
def H_addSubOptionMenu(widgetApp, amenu, aname, dd): alreadyThere = [ x for x in [x for x in amenu.actions() if str(x.text()) == aname] ] if len(alreadyThere) == 0: if dd == None or len(dd) == 0: amenu.addAction(aname) else: subMenu = QtT.QtWidgets.QMenu(aname, amenu) subMenu.setObjectName(aname) amenu.addMenu(subMenu) for a in dd: if len(dd[a]) == 4: la = dd[a][BK.K_TOOL_LABEL] subMenu2 = QtT.QtWidgets.QMenu(la, widgetApp) subMenu2.setObjectName(a) subMenu.addMenu(subMenu2) for b in dd[a][BK.K_TOOL_EXTRA]: act = subMenu2.addAction(b) act.setObjectName(b) elif len(dd[a]) == 3: la = dd[a][BK.K_TOOL_LABEL] act = subMenu.addAction(la) act.setObjectName(a) if dd[a][BK.K_TOOL_CHECKABLE]: act.setCheckable(True) act.setChecked(dd[a][BK.K_TOOL_DEFAULT]) else: log.error( "in H_addSubOptionMenuwrong submenu description %s" % dd[a])
def inspect_asset_depend(self, showobj, assobj): typeList = getAssetMapping(showobj.getName()) SW.start() allready = assobj.get_publishedType() allready = [x.getName() for x in allready] typeListMissing = OrderedDict() for i in typeList: if not typeList[i].short_name in allready: typeListMissing[i] = typeList[i].short_name if len(typeListMissing) == 0: SW.stop() if self.verbose: log.info("assetid_filepub_query in {}".format(SW.elapsed())) return file_type_obj_list = self._get_ft(typeListMissing) pf_list = self.assetid_filepubobj_query(showobj, assobj, file_type_obj_list) for k, pf in zip(typeListMissing.keys(), pf_list): # update data list assobj.set_plublished_type(typeListMissing[k], pf) SW.stop() if self.verbose: log.info("assetid_filepub_query in {}".format(SW.elapsed()))
def OpenFile(self, afile, mode="r"): try: fFile = open(afile, mode) except: MsgUtils.error("Can't open %s" % afile) fFile = None return fFile
def end_log(self): if self._logger != None: self._logger.info("ENDLOG LOG AT: %s" % time.ctime()) self._logger.end_log() self._logger = None self._logF = "" MsgUtils.msg("doLog is off, print statement after this should be in the console") self._prefs['globalPreference']['DoLog'] = False
def checkAdminPath(): for path in DefaultPath.__ADMIN_CREATED__: if not DiskUtils.is_dir_exist(path): MsgUtils.warning("%r needed, creating" % path) if DiskUtils.create_path(path) == False: MsgUtils.error("can't create %r" % path) sys.exit(1) return True
def treeTextUpdate(self, msg): if msg.widgetFrom() != self: log.error("treeTextUpdate,should be not getting this update") return i = msg.getItem() if i: self.disconnectLocalSignal() # to avoid bouncing i.setText(msg.getWhich(), msg.getProposedName()) self.connectLocalSignal()
def buildDict(myTask, theDict): if JsonHelper.isContainerClass(myTask): dd = dict() myTask.getVariableMember( dd) # ask the class for what it need to save for ch in myTask.getChildrenForXml(): JsonHelper.buildDict(ch, dd) theDict[myTask.getName()] = dd else: MsgUtils.error("canno't builddict on this object")
def H_loadLayout(widgetApp, editor, aDefautPathMgr, nameLayout): if nameLayout == "": log.info("not layout file specified") widgetApp.resize(500, 500) widgetApp.move(100, 100) return afile = editor.layout_file(nameLayout) if not DiskUtils.is_file_exist(afile): afile = aDefautPathMgr.getDefaultLayoutFile() if not DiskUtils.is_file_exist(afile): log.debug("cannot find the layout file %s" % afile) widgetApp.resize(500, 500) widgetApp.move(100, 100) return settings = QtT.QtCore.QSettings(afile, QtT.QtCore.QSettings.IniFormat, None) if DO_PYQT4: widgetApp.resize(settings.value('MainWindow/size').toSize()) widgetApp.move(settings.value('MainWindow/pos').toPoint()) widgets = list( map(str, settings.value('MainWindow/widgets').toStringList())) for w in widgets: className = str(settings.value('%s/className' % w).toString()) widgetApp.toolInstanciate(className, w) widgetApp.restoreState( settings.value('MainWindow/state').toByteArray()) for w in widgets: if w in widgetApp._docksWidget: widgetApp._docksWidget[w].getCustomWidget().resize( settings.value('%s/size' % w).toSize()) isFloating = settings.value('%s/floating' % w).toBool() if isFloating: widgetApp._docksWidget[w].getCustomWidget().move( settings.value('%s/pos' % w).toPoint()) else: widgetApp.resize(settings.value('MainWindow/size')) widgetApp.move(settings.value('MainWindow/pos')) widgets = settings.value('MainWindow/widgets') if widgets != None: for w in widgets: className = str(settings.value('%s/className' % w)) widgetApp.toolInstanciate(className, w) widgetApp.restoreState(settings.value('MainWindow/state')) for w in widgets: if w in widgetApp._docksWidget: widgetApp._docksWidget[w].getCustomWidget().resize( settings.value('%s/size' % w)) isFloating = settings.value('%s/floating' % w) if isFloating: widgetApp._docksWidget[w].getCustomWidget().move( settings.value('%s/pos' % w))
def to_python(self, stream, acontext): super(GenMelTask, self).to_python(stream, acontext) # command command = GenMelTask._LockupMelAttr['command'].get(self, 'command') if command == None: log.error("'command' is required for a mel task") return # output output = GenMelTask._LockupMelAttr['output'].get(self, 'output') # source source = GenMelTask._LockupMelAttr['source'].get(self, 'source') module = "maya.mel" tab = acontext['tab'] GenTask.do_python_module(stream, acontext, tab, module) if source != None: stream.write(("%smaya.mel.eval('" % tab) + ('source "%s"' % source) + "')\n") res = do_clean_command(command) final = "" if res.success: if output == None: final = ("%smaya.mel.eval('" % tab) + res.newCommand + "'" + res.addOn + ")" else: final = ( "%s%s = maya.mel.eval('" % (tab, output)) + res.newCommand + "'" + res.addOn + ")" else: if output == None: final = ("%smaya.mel.eval('" % tab) + command + "')" else: final = ("%s%s = maya.mel.eval('" % (tab, output)) + command + "')" evalEcho = GenMelTask._LockupMelAttr['evalEcho'].get(self, 'evalEcho') if evalEcho == True: p = re.compile("\(.*\)", re.DOTALL) m = p.search(final) if m: stream.write("%sprint%s\n" % (tab, m.group())) stream.write(final + "\n") if output != None: stream.write("%sprint 'return value " % tab + "%s' % " + output + "\n") else: stream.write(final + "\n") return True
def update_with(self, atask, lockup=None, attribList=None): super(GenPyTask, self).update_with(atask, GenPyTask._LockupPyAttr, GenPyTask._attr_PyTask) if hasattr(atask, 'resolveArgValues'): self.resolveArgValues = atask.resolveArgValues if hasattr(atask, 'resolveKwArgValues'): self.resolveKwArgValues = atask.resolveKwArgValues if atask.resolveArgValues == False or atask.resolveKwArgValues == False: log.warning( "resolve argument set to false is not supported for now" )
def to_python(self,stream,acontext): super(GenPyImportTask, self).to_python(stream,acontext) # command command = GenPyImportTask._LockupImportAttr['command'].get(self,'command') if command == None: log.error("'import contents' is required for an import task") return False scommand = command.split("\n") for c in scommand: stream.write("%s%s\n" % (acontext['tab'],c)) return True
def instanciate(self, d): if (JsonHelper._CLASSKEY not in d or JsonHelper._MODULEKEY not in d): # this is a basic dict return d # create an instance aclass = d[JsonHelper._CLASSKEY] amodule = d[JsonHelper._MODULEKEY] if (amodule != '__builtin__'): cmd = "import %s" % amodule try: exec(cmd) except: traceback.print_exc() MsgUtils.warning("cannot import %r" % amodule) MsgUtils.msg("Creating a generic class container") amodule = "tdata" aclass = "container" cmd = "%s.%s()" % (amodule, aclass) newInstance = None try: newInstance = eval(cmd) except: traceback.print_exc() MsgUtils.error("COMMAND %r" % cmd) MsgUtils.msg("class definition %r not found in %r" % (aclass, amodule)) assert newInstance != None # name value and typevalue if JsonHelper._NAMEKEY in d: newInstance.setName(d[JsonHelper._NAMEKEY]) if JsonHelper._VALTYPEKEY in d: newInstance.setTypeValue(d[JsonHelper._VALTYPEKEY]) if JsonHelper._VALKEY in d: newInstance.setValue(d[JsonHelper._VALKEY]) if JsonHelper._PROPKEY in d: newInstance.setVariableMember(d[JsonHelper._PROPKEY]) if JsonHelper._CHKEY in d: assert type(d[JsonHelper._CHKEY]) == dict for k, vn in list(d[JsonHelper._CHKEY].items()): chInstance = self.instanciate(vn) if JsonHelper.isContainerClass(chInstance): chInstance.setName(str(k)) newInstance.addChild(chInstance, False) else: MsgUtils.error("trouble reading %r" % type(chInstance)) return newInstance
def getChildByName(self, key): """ from a name find a node in the task node ... the result is cache for futher query """ if key in self.__Cache: return self.__Cache[key] for cn in self.getChildren(): if cn.getName() == key: self.__Cache[key] = cn return cn log.debug("getChildByName: node %r not found" % key) return None
def findChildRec(self, parent, aPathAsList): if len(aPathAsList) == 0: return parent for i in range(self.childCount(parent)): item = self.childAt(parent, i) if not item: log.error("in base_tw: findChildRec") return None if item.text(0) == aPathAsList[0]: if len(aPathAsList) <= 1: return item return self.findChildRec(item,aPathAsList[1:]) return None
def loadRaw(self, elmt, pTask, maxLevel): # foreign xml creationList = [] nb = "n%d:" index = 0 while elmt != None: if elmt.nodeType == elmt.ELEMENT_NODE: if maxLevel == 0: return [] if maxLevel != -1: maxLevel -= 1 if elmt.nodeName != "#text": atask = tdata.container() atask.setName(nb % index + elmt.nodeName) pTask.addChild(atask) index += 1 adict = {} if self.getXmlAttr(elmt, adict): atask.__dict__.update(adict) result = self.getKidsRaw(elmt, atask, maxLevel) for r in result: if r[0] == "TexType": atask.setValue(r[1]) else: MsgUtils.error("not done %r %r t=%s v=%s n=%s" % (pTask.getName(), atask.getName(), r[0], r[1], r[2])) elif elmt.nodeType == elmt.TEXT_NODE: edata = self.getTextValue(elmt).strip() if edata != "": creationList.append(["TextType", edata, elmt.nodeName]) elif elmt.nodeType == elmt.COMMENT_NODE: edata = self.getTextValue(elmt).strip() if edata != "": creationList.append(["CommentType", edata, elmt.nodeName]) elif elmt.nodeType == elmt.CDATA_SECTION_NODE: data = self.getcData(elmt) if data != "" and len(data.strip()) > 0: creationList.append(["CdType", data, elmt.nodeName]) else: MsgUtils.warning("NOT YETXX %r %r" % (elmt.nodeName, elmt.nodeType)) elmt = elmt.nextSibling return creationList
def _do_users(self): """ query and cache step info """ SW.start() conn = self.get_conn() if self.verbose: log.warning("login to shotgun, to get user") step = SQ.user_info_with_id(conn=conn) parent = self['Users'] for s in step: parent.addChild(s, withRename=False) SW.stop() if self.verbose: log.info("user_query in {}".format(SW.elapsed()))
def run(self, with_log, run_dry): log_info = ['mxinfocreatedir'] if with_log: log_info.append("ensure_folder_exists {}".format(self.parm1)) try: if run_dry == False: FileSystemUtils.ensure_folder_exists(self.parm1, self.mode) success = True errors = [] except Exception as e: log.error(str(e)) success = False errors = [str(e)] return ResultFileProc(success, errors, log_info, None)
def run(self, with_log, run_dry): log_info = ['mxinfocopy'] if with_log: log_info.append("Copy File {} {}".format(self.parm1,self.parm2)) try: if run_dry == False: FileSystemUtils.copy_file(self.parm1, self.parm2, self.mode) success = True errors = [] except Exception as e: log.error(str(e)) success = False errors = [str(e)] return ResultFileProc(success, errors, log_info, None)
def _init_root_path(self): if self._userInfo == None: return False toCheck = [self._userInfo.local_area, self._userInfo.log_dir] checkLayout = False for d in toCheck: if not DiskUtils.is_dir_exist(d): checkLayout = True MsgUtils.warning("%r is needed, create..." % d) if DiskUtils.create_path_rec(d) == False: MsgUtils.error("can't create %r" % d) else: MsgUtils.info("%r created" % d) #only on creation,copy if exist the defaultLayoutFile from # from the module if checkLayout: import shutil fromlayout = os.path.join(self._resource.resource_path, initDefault.DEFAULT_LAYOUT_ROOT) tolayout = os.path.join(self._userInfo.local_area, initDefault.DEFAULT_LAYOUT_ROOT) fromlayout += ".lyt" tolayout += ".lyt" if os.path.exists(fromlayout) and not os.path.exists(tolayout): shutil.copyfile(fromlayout, tolayout) MsgUtils.info("found a defaut layout file %s" % fromlayout) self.valid_to_save = self.is_persistant()