def save_file(entity=None): """ save increment file to lock wip version """ errorMessage = [] if not entity: entity = path_info.PathInfo() if entity: logger.debug('start publishing ...') # get publish info publishFile, saveWorkFile, incrementSaveWorkFile, libFile = pub_utils.get_publish_info( entity) logger.debug('save work file %s' % saveWorkFile) logger.debug('publish version %s' % publishFile) logger.debug('save increment work file %s' % incrementSaveWorkFile) # start process files saveResult = None workResult = None # publish info pubEntity = path_info.PathInfo(publishFile) info = publish_info.TaskInfo(pubEntity) # save as saveResult = hook.save_file_as(incrementSaveWorkFile) info.set('work', 'incrementWorkFile', incrementSaveWorkFile) if saveResult: # copy to current work version (short cut for overwritten save) workResult = file_utils.copy(saveResult, saveWorkFile) info.set('work', 'workfile', saveWorkFile) if not saveResult: logger.error('Save to %s has failed' % incrementSaveWorkFile) errorMessage.append('Save to %s has failed' % incrementSaveWorkFile) if not workResult: logger.error('Overwrite work version %s has failed' % saveWorkFile) errorMessage.append('Overwrite work version %s has failed' % saveWorkFile) if errorMessage: return False, errorMessage else: return True, 'Success \n%s' % workResult
def publish_version(entity=None, publishFile=None): """ create version in shotgun """ userEntity = None message = str() processStatus = False # get publish info if not publishFile: if ui: publishFile = str(ui.publishVersionLabel.text()) userEntity = ui.userWidget.read() if publishFile: pubEntity = path_info.PathInfo(publishFile) info = publish_info.TaskInfo(pubEntity) taskName = info.get('taskName', '') # create_version project = entity.project assetName = entity.name # find key data assetEntity = sg_process.get_one_asset(project, assetName) info.set('shotgun', 'asset_entity', assetEntity) projectEntity = assetEntity.get('project', None) info.set('shotgun', 'project_entity', projectEntity) taskEntity = sg_process.get_one_task(assetEntity, taskName) info.set('shotgun', 'task_entity', taskEntity) # if key data found if assetEntity and projectEntity and taskEntity: versionName = pubEntity.basename(ext=False) status = ui.statusWidget.get_task_status() description = '' playlistEntity = None result = sg_process.publish_version(projectEntity, assetEntity, taskEntity, userEntity, versionName, status, description, playlistEntity) message = 'Version creation not success' if result: info.set('shotgun', 'version_entity', result) processStatus = True message = 'Success %s' % result else: message = 'Data missing %s %s %s' % (assetEntity, projectEntity, taskEntity) logger.warning(message) processStatus = False else: message = 'No Publish File input' logger.warning(message) processStatus = False return processStatus, message
def upload_media(entity=None, publishFile=None): """ upload mov file to version """ message = str() processStatus = False # get publish info if not publishFile: if ui: publishFile = str(ui.publishVersionLabel.text()) if publishFile: pubEntity = path_info.PathInfo(publishFile) info = publish_info.TaskInfo(pubEntity) heroMovFile = info.get('primaryOutput', 'heroMovFile') versionEntity = info.get('shotgun', 'version_entity') if os.path.exists(heroMovFile) and versionEntity: uploadFile = heroMovFile.replace('/', '\\') result = sg_process.upload_version_media(versionEntity, uploadFile) if result: message = 'Success %s' % result processStatus = True else: message = 'Failed to upload movie' logger.warning(message) else: message = 'Path %s not exists or versionEntity %s not found' % ( heroImgFile, versionEntity) logger.warning(message) return processStatus, message
def check_ad(entity=None): if ui: publishFile = str(ui.publishVersionLabel.text()) pubEntity = path_info.PathInfo(publishFile) libPath = pubEntity.libPath() adFile = pubEntity.libName('ad', '') steps = template.workSceneSteps templatePath = '%s/RFPROJECT' % template.templatePath src = '%s/%s/%s' % (templatePath, 'lib', 'asset_ad.ma') dst = '%s/%s' % (libPath, adFile) if not os.path.exists(dst): start = pub_utils.file_time(dst) result = file_utils.copy(src, dst) repathResult = pipeline_utils.repath_ad(pubEntity) # check file export success end = pub_utils.file_time(dst) exportResult = pub_utils.is_file_new(start, end) if exportResult: return True, 'Success \n%s' % dst else: return False, 'Failed repath ad %s' % exportResult else: return True, '%s exists' % adFile else: return False, 'no ui information'
def list_polytag(): meshes = mc.ls(type='mesh') info = dict() if meshes: meshTransforms = [mc.listRelatives(a, p=True, f=True)[0] for a in meshes if mc.listRelatives(a, p=True)] for mesh in meshTransforms: projectAttr = '%s.%s' % (mesh, 'project') assetAttr = '%s.%s' % (mesh, 'assetName') pathAttr = '%s.%s' % (mesh, 'path') if mc.objExists(projectAttr) and mc.objExists(assetAttr) and mc.objExists(pathAttr): project = mc.getAttr(projectAttr) assetName = mc.getAttr(assetAttr) path = mc.getAttr(pathAttr) asset = path_info.PathInfo(path=path) if not assetName in info.keys(): info[assetName] = [asset, [mesh]] else: if not mesh in info[assetName][1]: info[assetName][1].append(mesh) return info
def publish_geo(entity=None): """ copy publised model to lib """ if ui: publishFile = str(ui.publishVersionLabel.text()) pubEntity = path_info.PathInfo(publishFile) info = publish_info.TaskInfo(pubEntity) modelPublish = info.get('primaryOutput', 'publishFile') libPath = entity.libPath() libName = entity.libName(entity.step, entity.task_res(), ext=pubEntity.ext) dst = '{0}/{1}'.format(libPath, libName) # check file start = pub_utils.file_time(dst) result = file_utils.copy(modelPublish, dst) # check file export success end = pub_utils.file_time(dst) exportResult = pub_utils.is_file_new(start, end) if exportResult: return True, 'Success \n%s' % dst else: return False, 'Failed to copy \n%s' % dst else: return False, 'No ui information.'
def get_info(self): self.model = path_info.PathInfo(self.thisScene) self.asset_name = self.model.name self.department = self.model.step self.version_name = self.model.versionNoUser self.version = file_utils.find_version(self.thisScene) self.task_name = self.model.task self.resolution = self.task_name.split('_')[-1] self.prod_dir = self.model.entityPath(root='RFPROD') self.pre_gpu = self.prod_dir + '/cache/' + '_'.join( [self.asset_name, 'gpu', self.resolution]) + '.abc' self.pre_abc = self.prod_dir + '/cache/' + '_'.join( [self.asset_name, 'abc', self.resolution]) + '.abc' self.src_publ = self.prod_dir + '/srcPublish/' + self.version_name + '.ma' self.publ_dir = self.model.entityPath(root='RFPUBL') self.publ_path = self.publ_dir + '/publish/' + '_'.join([ self.asset_name, self.department, self.resolution, self.version ]) + '.ma' self.publ_lib = self.publ_dir + '/lib/' + '_'.join( [self.asset_name, self.department, self.resolution]) + '.ma' self.gpu_lib = self.publ_dir + '/lib/' + '_'.join( [self.asset_name, 'gpu', self.resolution]) + '.abc' self.abc_lib = self.publ_dir + '/lib/' + '_'.join( [self.asset_name, 'abc', self.resolution]) + '.abc' print self.publ_path print self.publ_lib
def summarized_info(*args): """ write published info from Task to Asset info """ # get publish info if ui: publishFile = str(ui.publishVersionLabel.text()) pubEntity = path_info.PathInfo(publishFile) taskInfo = publish_info.TaskInfo(pubEntity) assetInfo = publish_info.AssetInfo(pubEntity) data = assetInfo.read() taskDict = dict() # set # asset id assetEntity = taskInfo.get('shotgun', 'asset_entity') data.update({'assetID': assetEntity.get('id')}) # task id taskEntity = taskInfo.get('shotgun', 'task_entity') # publish file output = taskInfo.get('primaryOutput', 'publishFile') # hero file outputHero = taskInfo.get('primaryOutput', 'heroFile') # user versionEntity = taskInfo.get('shotgun', 'version_entity') user = str() if versionEntity: user = versionEntity.get('user', {}).get('name') # set dict taskDict = { pubEntity.taskName: { 'id': taskEntity.get('id'), 'output': output, 'user': user }, 'output': output, 'outputHero': outputHero, 'user': user } # set department if pubEntity.step in data.keys(): data[pubEntity.step].update(taskDict) else: data.update({pubEntity.step: taskDict}) assetInfo.setData(data) result = assetInfo.publish() return True, 'Success \npublish info %s' % result else: logger.warning('No ui information') return False, 'No ui information'
def set_publish_version(self): """ set publish version based on source input """ task = self.taskWidget.get_task() if task: logger.debug('set publish version') source = str(self.sourceFileWidget.widget.text()) entity = path_info.PathInfo(source) entity.task = task.get('content') publishFile, saveWorkFile, incrementSaveWorkFile, libFile = pub_utils.get_publish_info( entity) self.publishVersionLabel.setText(publishFile) # set entity from source ** self.pathInfo = path_info.PathInfo(source) logger.debug('version %s' % os.path.basename(publishFile))
def export_abc(entity=None): """ export alembic geo """ status = False exportGrp = config.geoGrp res = entity.task_res() libPath = entity.libPath() publishResult = False if res: abcModel = entity.libName(entity.step, res, ext='abc') exportPath = '{0}/{1}'.format(libPath, abcModel) exportExt = os.path.splitext(exportPath)[-1] # check file start = pub_utils.file_time(exportPath) # export command abc_utils.exportABC(exportGrp, exportPath) # check file export success end = pub_utils.file_time(exportPath) exportResult = pub_utils.is_file_new(start, end) # write info if ui: publishFile = str(ui.publishVersionLabel.text()) pubEntity = path_info.PathInfo(publishFile) # publish publishPath = pubEntity.publishPath(publish='output') publishName = pubEntity.basename(ext=False) publishFileName = '%s/%s%s' % (publishPath, publishName, exportExt) file_utils.copy(exportPath, publishFileName) if os.path.exists(publishFileName): publishResult = True # write info info = publish_info.TaskInfo(pubEntity) info.set('secondaryOutput', 'abc', publishFileName) info.set('secondaryOutput', 'abcHero', exportPath) # successPublishFile = info.get('primaryOutput', 'publishFile') if exportResult: if publishResult: return True, 'Success %s\n%s' % (exportPath, publishFileName) else: return False, 'Failed to publish %s' % publishFileName else: return False, 'Failed to export Alembic %s' % exportPath else: return False, 'No res found'
def list_asset(self): assetDict = self.get_assets() self.ui.tableWidget.blockSignals(True) ui_wrapper.clear_table(self.ui.tableWidget) project = str(self.ui.project_comboBox.currentText()) step = str(self.ui.dept_comboBox.currentText()) for row, value in assetDict.iteritems(): baseColor = [255, 255, 255] assetColor = [255, 255, 255] if isMaya: assetColor = [0, 0, 0] baseColor = [0, 0, 0] if value.get('duplicated'): assetColor = [255, 200, 200] if isMaya: assetColor = [100, 0, 0] # asset logger.debug(value.get('type')) logger.debug(value.get('subType')) logger.debug(value.get('asset')) asset = path_info.PathInfo(project=project, entity='asset', entitySub1=value.get('type'), entitySub2=value.get('subType'), name=value.get('asset'), step=step) ui_wrapper.insert_row(self.ui.tableWidget, row, height=20) ui_wrapper.fill_table(self.ui.tableWidget, row, self.columnName.index('Asset Name'), value.get('asset'), iconPath='', color=assetColor) ui_wrapper.fill_table(self.ui.tableWidget, row, self.columnName.index('Type'), value.get('type'), iconPath='', color=baseColor) ui_wrapper.fill_table(self.ui.tableWidget, row, self.columnName.index('SubType'), value.get('subType'), iconPath='', color=baseColor) ui_wrapper.fill_table(self.ui.tableWidget, row, self.columnName.index('Source'), '', iconPath='', color=baseColor) ui_wrapper.fill_table(self.ui.tableWidget, row, self.columnName.index('Status'), '', iconPath='', color=baseColor) # checkBox checkBox = QtWidgets.QCheckBox() self.ui.tableWidget.setCellWidget(row, self.columnName.index('Select'), checkBox) # res comboBox resComboBox = QtWidgets.QComboBox() resComboBox.addItems(self.res) resComboBox.setCurrentIndex(self.res.index(self.resDefault)) self.ui.tableWidget.setCellWidget(row, self.columnName.index('res'), resComboBox) resComboBox.currentIndexChanged.connect(partial(self.set_dst_status, row, asset)) # set file target status self.set_dst_status(row, asset) # resize to fit contents self.ui.tableWidget.resizeColumnToContents(self.columnName.index('Select')) self.ui.tableWidget.resizeColumnToContents(self.columnName.index('res')) self.ui.tableWidget.resizeColumnToContents(self.columnName.index('Target')) self.ui.tableWidget.blockSignals(False)
def get_info(self): self.scene = path_info.PathInfo(self.thisScene) self.file_name = self.scene.versionName self.user = self.scene.user self.version_name = '_'.join(self.scene.fileUser.split('_')[:-1]) self.version_num = file_utils.find_version(self.thisScene) self.prod_dir = self.scene.entityPath(root='RFPROD') self.prod_avi = self.prod_dir + '/movies/' + self.version_name + '.avi' self.prod_mov = self.prod_dir + '/movies/' + self.version_name + '.mov' self.prod_img = self.prod_dir + '/images/' + self.version_name + '.jpg'
def auto_fill2(*args): asset = path_info.PathInfo() if mc.objExists('Geo_Grp'): plys = maya_utils.find_ply('Geo_Grp') for ply in plys: mc.setAttr('%s.path' % ply, asset.path, type='string') mc.setAttr('%s.assetName' % ply, asset.name, type='string') mc.setAttr('%s.project' % ply, asset.project, type='string') if mc.objExists('Rig_Grp'): add('Rig_Grp') copy_attr(plys[0], 'Rig_Grp')
def __init__(self, path=None): super(SGEntity, self).__init__() self.pathInfo = None if type(path).__name__ == 'PathInfo': self.pathInfo = path elif type(path).__name__ == 'str': self.pathInfo = path_info.PathInfo(path) # cache self.cacheProject = None self.cacheEntity = None self.cacheTasks = None
def list_asset(): from rftool.utils import sg_process from rftool.utils import path_info res = 'md' fields = ['code', 'sg_asset_type', 'sg_subtype'] sgassets = sg_process.sg.find( 'Asset', [['project.Project.name', 'is', 'Two_Heroes'], ['sg_asset_type', 'is', 'setDress'], ['sg_subtype', 'is', 'garbage']], fields) for i, each in enumerate(sgassets): asset = path_info.PathInfo(project='Two_Heroes', entity='asset', entitySub1=each.get('sg_asset_type'), entitySub2=each.get('sg_subtype'), name=each.get('code')) libPath = asset.libPath() modelName = asset.libName(step='model', res=res, project=False) rigName = asset.libName(step='rig', res=res, project=False) modelPath = '%s/%s' % (libPath, modelName) rigPath = '%s/%s' % (libPath, rigName) print '==================' print '%s %s' % (i, libPath) if os.path.exists(modelPath): try: mc.file(modelPath, o=True, f=True, prompt=False) except Exception as e: print e clean_file() mc.file(rename=modelPath) mc.file(save=True, f=True) else: print 'missing %s' % modelPath if os.path.exists(rigPath): try: mc.file(rigPath, o=True, f=True, prompt=False) except Exception as e: print e clean_file() mc.file(rename=rigPath) mc.file(save=True, f=True) else: print 'missing %s' % rigPath print '========'
def get_asset_info(self, row): project = str(self.ui.project_comboBox.currentText()) step = str(self.ui.dept_comboBox.currentText()) assetName = ui_wrapper.get_tableWidget_item(self.ui.tableWidget, row, self.columnName.index('Asset Name'), widget=False) assetType = ui_wrapper.get_tableWidget_item(self.ui.tableWidget, row, self.columnName.index('Type'), widget=False) subType = ui_wrapper.get_tableWidget_item(self.ui.tableWidget, row, self.columnName.index('SubType'), widget=False) source = ui_wrapper.get_tableWidget_item(self.ui.tableWidget, row, self.columnName.index('Source'), widget=False) status = ui_wrapper.get_tableWidget_item(self.ui.tableWidget, row, self.columnName.index('Status'), widget=False) resWidget = ui_wrapper.get_tableWidget_item(self.ui.tableWidget, row, self.columnName.index('res'), widget=True) res = str(resWidget.currentText()) # {'project': 'project', 'entity'='asset', entitySub1='character', entitySub2='main', name='aiya', step=model, task='model_md'} asset = path_info.PathInfo(project=project, entity='asset', entitySub1=str(assetType.text()), entitySub2=str(subType.text()), name=str(assetName.text()), step=str(step)) return {'asset': asset, 'source': str(source.text()), 'status': str(status.text()), 'res': res}
def get_publish_info(entity=None): """ publish asset info """ # normal steps # save -> copy publish -> increment # short steps, save only once to save time # save increment -> copy publish (v-1) -> copy if not entity: entity = path_info.PathInfo() sourceFile = entity.path srcVersion = path_info.find_version(sourceFile) publishDir = entity.publishPath() publishName = entity.publishName(srcVersion, ext=True) publishFile = '{0}/{1}'.format(publishDir, publishName) saveWorkFile = sourceFile # condition 1 pub version exists if os.path.exists(publishFile): # find next available version pubDirMax = path_info.find_next_version(path_info.listFile(publishDir)) workDirMax = path_info.find_next_version(path_info.listFile(os.path.dirname(sourceFile))) # good both version if pubDirMax == workDirMax: maxVersion = pubDirMax # user higher else: maxVersion = 'v%03d' % max(int(pubDirMax.replace('v', '')), int(workDirMax.replace('v', ''))) publishFile = '{0}/{1}'.format(publishDir, entity.publishName(maxVersion, ext=True)) saveWorkFile = path_info.replace_file_version(sourceFile, maxVersion) # increment pubVersion = path_info.find_version(publishFile) workIncrementVersion = 'v%03d' % (int(pubVersion.replace('v', '')) + 1) incrementSaveWorkFile = path_info.replace_file_version(sourceFile, workIncrementVersion) # hero libPath = entity.libPath() libName = entity.libName(entity.step, entity.task_res(), ext=entity.ext) libFile = '{0}/{1}'.format(libPath, libName) return publishFile, saveWorkFile, incrementSaveWorkFile, libFile
def initial_UI(self): try: self.asset = path_info.PathInfo() self.this_path = self.asset.path self.project = self.asset.project self.version_name = self.asset.versionNoUser self.version = file_utils.find_version(self.this_path) self.type_name = self.asset.type self.subtype_name = self.asset.subtype self.asset_name = self.asset.name self.task_name = self.asset.taskName self.department = self.asset.step # self.user_name = self.scene.user self.src_pub_path = self.asset.entityPath( root='RFPUBL') + '/srcPublish/' + self.version_name # self.pub_path = self.asset.entityPath(root='RFPUBL') + '/srcPublish/' + self.version_name self.prod_dir = self.asset.entityPath(root='RFPROD') self.image_prod = self.asset.entityPath( root='RFPROD' ) + '/images/' + self.department + '/' + self.version_name self.image_publ = self.asset.entityPath( root='RFPUBL' ) + '/images/' + self.department + '/' + self.version_name self.image_path_no_ext = self.image_prod + '/' + self.version_name self.movie_prod = self.asset.entityPath( root='RFPROD' ) + '/movies/' + self.department + '/' + self.version_name self.movie_publ = self.asset.entityPath( root='RFPUBL' ) + '/movies/' + self.department + '/' + self.version_name self.thumbnail = '' self.movie = '' self.hide_progressBar() self.set_ui_information() self.get_thumbnail_version() self.get_sg_data() except AttributeError as attrErr: print attrErr, ',', self.this_path QtGui.QMessageBox.warning(self, 'Warning', 'No Maya Scene Open')
def create_asset_template(root, project, assetType, assetSubType, assetName): scriptServer = os.environ['RFSCRIPT'] templatePath = '' rootValid = False if root == config.RFPROJECT: steps = template.workAssetSteps templatePath = '%s/RFPROJECT' % template.templatePath rootValid = True if root == config.RFPUBL: steps = template.publAssetSteps templatePath = '%s/RFPUBL' % template.templatePath rootValid = True if root == config.RFPROD: steps = template.prodAssetSteps templatePath = '%s/RFPROD' % template.templatePath rootValid = True if rootValid: asset = path_info.PathInfo(project=project, entity=config.asset, entitySub1=assetType, entitySub2=assetSubType, name=assetName) assetPath = asset.entityPath(root) if not os.path.exists(assetPath): os.makedirs(assetPath) for step in steps: src = '%s/%s' % (templatePath, step) dst = '%s/%s' % (assetPath, step) if not os.path.exists(dst): result = file_utils.copyTree(src, dst) logger.debug('Copy %s -> %s success' % (src, dst)) create_standin(asset) repath_ad(asset) return True
def list_asset(project='Two_Heroes', assetTypes=['setDress']): listFilter = [["sg_asset_type", "is", a] for a in assetTypes] print listFilter advancedFilter = {"filter_operator": "any", "filters": listFilter} filters = [['project.Project.name', 'is', project], advancedFilter] fields = ['sg_asset_type', 'sg_subtype', 'code'] result = sg_process.sg.find('Asset', filters, fields) assets = [] for entity in result: asset = path_info.PathInfo(project=project, entity='asset', entitySub1=entity.get('sg_asset_type'), entitySub2=entity.get('sg_subtype'), name=entity.get('code')) assets.append(asset) return assets
def quick_export(): sels = mc.ls(sl=True) res = 'md' geoGrp = 'Geo_Grp' rigGrp = 'Rig_Grp' for obj in sels: assetName = str() libPath = str() assetAttr = '%s.assetName' % obj libAttr = '%s.path' % obj if mc.objExists(assetAttr): assetName = mc.getAttr(assetAttr) if mc.objExists(libAttr): libPath = mc.getAttr(libAttr) if assetName and libPath: asset = path_info.PathInfo(path=libPath) refPath = asset.libPath() rigName = asset.libName(step='rig', res=res, project=False) exportPath = '%s/%s' % (refPath, rigName) gpuName = os.path.splitext( asset.libName(step='gpu', res=res, project=False, ext='abc'))[0] adName = asset.libName('', 'ad', project=False) modelName = asset.libName(step='model', res=res, project=False) print exportPath print refPath, gpuName print refPath, modelName sgResult = sg_process.create_asset(project=projectEntity, assetType=entitySub1, assetSubType=entitySub2, assetName=entityName, episode=episodeEntity, taskTemplate=taskTemplate) if sgResult: dirResult = pipeline_utils.create_asset_template( root, projectEntity['name'], entitySub1, entitySub2, entityName)
def get_scene_info(self): self.scene = path_info.PathInfo() self.this_path = self.scene.path self.project = self.scene.project self.version = file_utils.find_version(self.this_path) # self.version_name = self.scene.name + self.episode = self.scene.episode self.sequence = self.scene.sequence self.shot = self.scene.shot self.department = self.scene.step self.version_name = '_'.join(self.scene.fileUser.split('_')[:-1]) self.user_name = self.scene.user self.prod_dir = self.scene.entityPath(root='RFPROD') self.prod_avi = self.prod_dir + '/movies/' + self.version_name + '.avi' self.prod_mov = self.prod_dir + '/movies/' + self.version_name + '.mov' self.prod_img = self.prod_dir + '/images/' + self.version_name + '.jpg' self.thumbnails = None self.movies = None
def create_lib_template(root, project, assetType, assetSubType, assetName): scriptServer = os.environ['RFSCRIPT'] templateLibPath = '' templateLibPath = '%s/RFPROJECT/%s' % (template.templatePath, config.ref) asset = path_info.PathInfo(project=project, entity=config.asset, entitySub1=assetType, entitySub2=assetSubType, name=assetName) assetLibPath = '%s/%s' % (asset.entityPath(root), config.ref) libFiles = file_utils.listFile(templateLibPath) if not os.path.exists(assetLibPath): os.makedirs(assetLibPath) for libFile in libFiles: src = '%s/%s' % (templateLibPath, libFile) dst = '%s/%s' % (assetLibPath, libFile) if not os.path.exists(dst): result = file_utils.copy(src, dst) logger.debug('Copy %s -> %s success' % (src, dst)) if config.libFileReplaceKw in libFile: newName = libFile.replace(config.libFileReplaceKw, asset.name) renSrc = dst renDst = '%s/%s' % (assetLibPath, newName) if not os.path.exists(renDst): os.rename(renSrc, renDst) logger.debug('Rename %s -> %s' % (renSrc, renDst)) else: os.remove(renSrc) logger.debug('Remove existing template %s' % renSrc) create_standin(asset) repath_ad(asset) return True
def create_scene_template(root, project, episodeName, sequenceName, shotName): scriptServer = os.environ['RFSCRIPT'] templatePath = '' rootValid = False if root == config.RFPROJECT: steps = template.workSceneSteps templatePath = '%s/RFPROJECT' % template.templatePath rootValid = True if root == config.RFPUBL: steps = template.publSceneSteps templatePath = '%s/RFPUBL' % template.templatePath rootValid = True if root == config.RFPROD: steps = template.prodSceneSteps templatePath = '%s/RFPROD' % template.templatePath rootValid = True if rootValid: shot = path_info.PathInfo(project=project, entity=config.scene, entitySub1=episodeName, entitySub2=sequenceName, name=shotName) shotPath = shot.entityPath(root) if not os.path.exists(shotPath): os.makedirs(shotPath) for step in steps: src = '%s/%s' % (templatePath, step) dst = '%s/%s' % (shotPath, step) if not os.path.exists(dst): result = file_utils.copyTree(src, dst) logger.debug('Copy %s -> %s success' % (src, dst)) return True
def set_task(entity=None, publishFile=None): """ change task status """ message = str() processStatus = False # get publish info if not publishFile: if ui: publishFile = str(ui.publishVersionLabel.text()) if publishFile: pubEntity = path_info.PathInfo(publishFile) info = publish_info.TaskInfo(pubEntity) taskEntity = info.get('shotgun', 'task_entity') taskName = info.get('taskName', '') # if no data in publish_info, query from shotgun if not taskEntity: logger.debug('taskEntity not found in publish_info') project = pubEntity.project assetName = pubEntity.name assetEntity = sg_process.get_one_asset(project, assetName) info.set('shotgun', 'asset_entity', assetEntity) taskEntity = sg_process.get_one_task(assetEntity, taskName) info.set('shotgun', 'task_entity', taskEntity) if taskEntity: status = ui.statusWidget.get_task_status() data = {'sg_status_list': status} result = sg_process.set_task_data(taskEntity.get('id'), data) processStatus = True message = 'Success %s' % result else: message = 'Failed to get taskEntity' return processStatus, message
def auto_fill(*args): from rftool.utils import sg_process sels = mc.ls(sl=True) caches = dict() if sels: for ply in sels: project = mc.getAttr('%s.project' % ply) assetName = mc.getAttr('%s.assetName' % ply) entity = caches.get(project, {}).get(assetName) if not entity: entity = sg_process.sg.find_one('Asset', [['project.Project.name', 'is', project], ['code', 'is', assetName]], ['code', 'sg_asset_type', 'sg_subtype', 'id']) print entity if entity: if not project in caches.keys(): caches.update({project: {assetName: entity}}) if entity: asset = path_info.PathInfo(project=project, entity='asset', entitySub1=entity.get('sg_asset_type'), entitySub2=entity.get('sg_subtype'), name=assetName) libPath = asset.libPath() mc.setAttr('%s.id' % ply, entity.get('id')) mc.setAttr('%s.path' % ply, libPath, type='string') mc.rename(ply, assetName)
def import_assets(): from rftool.utils import sg_process from rftool.utils import path_info res = 'md' fields = ['code', 'sg_asset_type', 'sg_subtype'] sgassets = sg_process.sg.find( 'Asset', [['project.Project.name', 'is', 'Two_Heroes'], ['sg_asset_type', 'is', 'setDress'], ['sg_subtype', 'is', 'garbage']], fields) for i, each in enumerate(sgassets): asset = path_info.PathInfo(project='Two_Heroes', entity='asset', entitySub1=each.get('sg_asset_type'), entitySub2=each.get('sg_subtype'), name=each.get('code')) libPath = asset.libPath() modelName = asset.libName(step='model', res=res, project=False) rigName = asset.libName(step='rig', res=res, project=False) rigPath = '%s/%s' % (libPath, rigName) if os.path.exists(rigPath): mc.file(rigPath, i=True, ns=asset.name)
def relink_texture(): fileNodes = mc.ls(type='file') asset = path_info.PathInfo() texturePath = asset.texturePath() res = asset.file_res() assetTexturePath = '%s/%s' % (texturePath, res) for node in fileNodes: path = mc.getAttr('%s.fileTextureName' % node) if not assetTexturePath in path: # path not valid filename = os.path.basename(path) newPath = '%s/%s' % (assetTexturePath, filename) if not os.path.exists(newPath): file_utils.copy(path, newPath) # link mc.setAttr('%s.fileTextureName' % node, newPath, type='string') logger.info('link success %s' % newPath) else: logger.info('texture already in pipeline %s' % path)
def __init__(self, parent=None): #Setup Window super(RFStillPublish, self).__init__(parent) # ui read uiFile = '%s/ui.ui' % moduleDir if isMaya: self.ui = load.loadUIMaya(uiFile, self) else: self.ui = load.loadUI(uiFile, self) self.ui.show() self.ui.setWindowTitle('RF Still Publish v.0.1.0') self.pathInfo = path_info.PathInfo() self.imageFormat = ['.jpg', '.png', '.jpeg'] self.snapFormat = 'png' publish_core.ui = self self.set_ui() self.init_signals() self.init_functions()
def switch(ply, level, srcPly=None): assetAttr = '%s.%s' % (ply, 'assetName') pathAttr = '%s.%s' % (ply, 'path') assetDataAttr = '%s.%s' % (ply, 'assetData') parent = mc.listRelatives(ply, p=True) if mc.objExists(assetAttr) and mc.objExists(pathAttr): assetName = mc.getAttr(assetAttr) path = mc.getAttr(pathAttr) data = eval(mc.getAttr(assetDataAttr)) data.update({'original': path}) asset = path_info.PathInfo(path=path) refPath = '%s/%s_%s.ma' % (asset.libPath(), asset.name, level) if os.path.exists(refPath): assetPlc = place_asset(refPath, srcPly=srcPly) transfer_attr(ply, assetPlc, level) mc.delete(mc.parentConstraint(ply, assetPlc)) mc.delete(ply) assetPlc = mc.rename(assetPlc, ply) mc.parent(assetPlc, parent) return assetPlc