def save(self, signal_dic): file = signal_dic[defaults._signal_file_key_] asset = asset_core.string_to_asset( signal_dic[defaults._signal_asset_key_]) filename = os.path.basename(file) filename = filename.split('.')[0] if filename == folder(asset).work_name_template: version = folder(asset).version_from_file(file) if version.isdigit(): asset.version = prefs.asset(asset).software.new_version( version=version) time.sleep(1) try: im_file = prefs.asset(asset).software.image screen_tools.screen_shot_current_screen(im_file) except: logger.critical(str(traceback.format_exc())) # Try refreshing the ui try: send_signal.refresh_signal() logger.info('{} saved ({})'.format(file, asset.software)) send_signal.save_signal() stats().add_xp(2) stats().add_version(asset) except: pass
def create_playblast(asset): # First read the project dictionnary project_dic = project.read_project() # Check if category, name, stage and variant exists if checker.check_category_existence(asset) and \ checker.check_name_existence(asset) and \ checker.check_stage_existence(asset) and \ checker.check_variant_existence(asset): # Get the playblast folder path path = folder(asset).playblast() # Create the folder tree if it doesn't exists if not os.path.isdir(path): os.makedirs(path) # Log it to the user logger.debug('Playblast folder created') # Init the asset software prefs using the wizard "prefs" module prefs.asset(asset).playblast.write() # Return the path return path
def create_export(asset, version = None): # First read the project dictionnary project_dic = project.read_project() # Check if category, name, stage and variant exists if checker.check_category_existence(asset) and \ checker.check_name_existence(asset) and \ checker.check_stage_existence(asset) and \ checker.check_variant_existence(asset): # Create the folder tree and get the path path = create_export_folder(asset, version) # Init the asset software prefs # Use the wizard "prefs" module if version: asset.export_version = version prefs.asset(asset).export.write() # If a version was specified, add it to the prefs file if version: prefs.asset(asset).export.new_version(version) # Log the success to user # And return the folder path logger.debug('Export folder created') return path
def create_export_root(asset): # First read the project dictionnary project_dic = project.read_project() print('current_task:Creating export_root folder') print('percent:78') sys.stdout.flush() # Check if category, name, stage and variant exists if checker.check_category_existence(asset) and \ checker.check_name_existence(asset) and \ checker.check_stage_existence(asset) and \ checker.check_variant_existence(asset): # Create the folder tree and return the path path = create_export_root_folder(asset) # Create the prefs file with the wizard "prefs" module prefs.asset(asset).export_root.write() # Log the success to user # And return the path logger.debug('Export root folder created') print('current_task:export_root folder created') print('percent:80') sys.stdout.flush() return path
def delete_version(self): widgets_list = self.get_selected_widgets() for widget in widgets_list: self.dialog_delete_asset = dialog_delete_asset.Main() if build.launch_dialog_as_child_frameless( self.dialog_delete_asset): prefs.asset(widget.asset).software.remove_version( widget.asset.version) self.update_all()
def unlock_all(self): locks_list = prefs.locks for lock in locks_list: asset = asset_core.string_to_asset(lock) if prefs.asset(asset).software.get_lock: prefs.asset(asset).software.unlock() prefs.remove_lock(utils.short_asset_to_string(asset)) self.locks = None self.setup_widget()
def create_softwares(asset): print('current_task:Creating software') print('percent:0') sys.stdout.flush() print('current_task:Updating project') print('percent:33') sys.stdout.flush() # Creates a new software with an "asset" object in arg # First read the project dictionnary project_dic = project.read_project() # Check if category, name, stage and variant exists if checker.check_category_existence(asset) and \ checker.check_name_existence(asset) and \ checker.check_stage_existence(asset) and \ checker.check_variant_existence(asset): percent_step = 33/len(prefs.asset(asset).stage.softwares) percent = 33 # Loop, add every softwares of the concerned stage for software in prefs.asset(asset).stage.softwares: # Assign the software from the loop to the "asset" object asset.software = software # Check if this software doesn't already exists if not checker.check_software_existence(asset): # Add the software to the project dictionnary project_dic[asset.domain] \ [asset.category] \ [asset.name] \ [asset.stage] \ [asset.variant] \ [asset.software] = {} # Write the project dictionnary to the tree.wd project.write_project(project_dic) percent+=percent_step print('current_task:Creating {} folders'.format(software)) print('percent:{}'.format(int(percent))) sys.stdout.flush() # Build the folders create_software_folder(asset) # Init the asset software prefs prefs.asset(asset).software.write() # Log the success to user logger.debug('Software {} added to asset.wd'.format(software))
def create_stage(asset): print('current_task:Creating {}'.format(asset.stage)) print('percent:0') sys.stdout.flush() print('current_task:Updating project') print('percent:33') sys.stdout.flush() # Creates a new stage with an "asset" object in arg # First read the project dictionnary project_dic = project.read_project() # Check if category and name exists # Check if stage doesn't exists if checker.check_category_existence(asset): if checker.check_name_existence(asset): if not checker.check_stage_existence(asset): # Add the stage to the project dictionnary project_dic[asset.domain] \ [asset.category] \ [asset.name] \ [asset.stage] = {} # Write the project dictionnary to the tree.wd project.write_project(project_dic) print('current_task:Creating folders') print('percent:66') sys.stdout.flush() # Build the folders create_folders(asset) # Init the asset stage prefs prefs.asset(asset).stage.write() print('current_task:Stage created') print('percent:100') sys.stdout.flush() # Return and log the success to user logger.debug('Stage {} added to asset.wd'.format(asset.stage)) return 1 else: # Return and log the fail to the user logger.warning('{} - {} already exists'.format(asset.name, asset.stage)) return 0 else: logger.warning("{} doesn't exists".format(asset.name)) return 0 else: logger.warning("{} doesn't exists".format(asset.category)) return 0
def refresh_exported_asset(self): self.ui.exported_asset_comboBox.clear() exported_assets_list = prefs.asset(self.asset).export_root.exported_assets_list if self.asset.export_asset not in exported_assets_list: self.asset.export_asset = prefs.asset(self.asset).export_root.default_export_asset for exported_asset in exported_assets_list: self.ui.exported_asset_comboBox.addItem(exported_asset) index = exported_assets_list.index(self.asset.export_asset) self.ui.exported_asset_comboBox.setCurrentIndex(index) self.export_asset_changed()
def playblast_event(self, asset): if asset.stage: message = 'playblasted {} - {} - {} - {} - {}'.format(asset.domain, asset.category, asset.name, asset.stage, asset.variant) id = defaults._wall_playblast_event_ key = util.id_based_time() if asset.name: prefs.asset(asset).add_event(key) prefs.add_event(key) self.event(message, id, key, asset)
def close_ticket_event(self, asset, creator): if asset.stage: message = 'closed a ticket from {} about {} - {} - {} - {} - {}'.format(creator, asset.domain, asset.category, asset.name, asset.stage, asset.variant) id = defaults._wall_close_ticket_event_ key = util.id_based_time() if asset.name: prefs.asset(asset).add_event(key) prefs.add_event(key) self.event(message, id, key, asset)
def set_f_range(preroll=0): asset = asset_core.string_to_asset(os.environ[defaults._asset_var_]) f_range = prefs.asset(asset).name.range if preroll: preroll = prefs.asset(asset).name.preroll postroll = prefs.asset(asset).name.postroll f_range[0] = f_range[0] - preroll f_range[1] = f_range[1] + postroll hou.playbar.setFrameRange(f_range[0], f_range[1])
def publish_event(self, asset): if asset.stage: message = 'published {} - {} - {} - {} - {} | version : {}'.format(asset.domain, asset.category, asset.name, asset.stage, asset.variant, asset.export_version) id = defaults._wall_publish_event_ key = util.id_based_time() if asset.name: prefs.asset(asset).add_event(key) prefs.add_event(key) self.event(message, id, key, asset)
def ticket_event(self, asset, adress): if asset.stage: message = 'adressed a ticket to {} about {} - {} - {} - {} - {}'.format(adress, asset.domain, asset.category, asset.name, asset.stage, asset.variant) id = defaults._wall_ticket_event_ key = util.id_based_time() if asset.name: prefs.asset(asset).add_event(key) prefs.add_event(key) self.event(message, id, key, asset)
def lock_clicked(self): if prefs.asset(self.asset).software.get_lock: prefs.asset(self.asset).software.unlock() prefs.remove_lock(utils.short_asset_to_string(self.asset)) self.set_unlocked_appearence() self.refresh_lock.emit('') if self.parent.lock: self.close() else: prefs.asset(self.asset).software.lock() prefs.add_lock(utils.short_asset_to_string(self.asset)) self.set_locked_appearence() self.refresh_lock.emit('')
def match_frame_range(preroll=0): asset = asset_core.string_to_asset(os.environ[defaults._asset_var_]) f_range = prefs.asset(asset).name.range print(f_range) # set timeline settings for all file scenes for s in list(bpy.data.scenes): if preroll: preroll = prefs.asset(asset).name.preroll postroll = prefs.asset(asset).name.postroll f_range[0] = f_range[0] - preroll f_range[1] = f_range[1] + postroll bpy.data.scenes[s.name].frame_start = f_range[0] bpy.data.scenes[s.name].frame_end = f_range[1]
def get_asset_list(): asset = asset_core.string_to_asset(os.environ[defaults._asset_var_]) references_list = prefs.asset(asset).software.references asset_list = [] for namespace in list(references_list.keys()): imported_asset = asset_core.string_to_asset(references_list[namespace][defaults._asset_key_]) folder = prefs.asset(imported_asset).export.version_folder from_software = prefs.asset(imported_asset).export.version_software imported_asset.software = from_software file = prefs.asset(imported_asset).export.file full_path = os.path.join(folder, file) asset_list.append([imported_asset, namespace, full_path]) return asset_list
def set_f_range(preroll=0): asset = asset_core.string_to_asset(os.environ[defaults._asset_var_]) f_range = prefs.asset(asset).name.range if preroll: preroll = prefs.asset(asset).name.preroll postroll = prefs.asset(asset).name.postroll f_range[0] = f_range[0] - preroll f_range[1] = f_range[1] + postroll cmds.playbackOptions(animationStartTime=f_range[0], minTime=f_range[0], animationEndTime=f_range[1], maxTime=f_range[1])
def update_sanity(self, sanity): if sanity: list_dir = os.listdir( prefs.asset(self.asset).export.version_folder) if list_dir == [] or not list_dir: icon = defaults._missing_file_export_list_icon_ else: if prefs.asset(self.asset).software.extension in list_dir[0]: icon = defaults._export_list_icon_ else: icon = defaults._missing_file_export_list_icon_ else: icon = defaults._export_list_neutral_icon_ self.set_icon(icon)
def remove_event(self, asset): if asset.category and not asset.name: message = 'removed {} - {}'.format(asset.domain, asset.category) elif asset.name and not asset.stage: message = 'removed {} - {} - {}'.format(asset.domain, asset.category, asset.name) elif asset.stage: message = 'removed {} - {} - {} - {} - {}'.format(asset.domain, asset.category, asset.name, asset.stage, asset.variant) id = defaults._wall_remove_event_ key = util.id_based_time() if asset.name: prefs.asset(asset).add_event(key) prefs.add_event(key) self.event(message, id, key, asset)
def startDrag(self, event): if not self.parent.pin: logger.warning( "Please 'pin' an asset before importing something...") elif not self.parent.selected_asset.stage: logger.warning("Must import a stage...") else: assets_list = [] asset = copy.deepcopy(self.parent.selected_asset) default_variant = prefs.asset(asset).stage.default_variant variants_list = prefs.asset(asset).stage.variants variants_list.remove(default_variant) asset.variant = default_variant exported_assets_list = prefs.asset( asset).export_root.exported_assets_list if exported_assets_list != []: for exported_asset in exported_assets_list: asset.export_asset = exported_asset asset.export_version = prefs.asset( asset).export.last_version asset.software = prefs.asset(asset).export.version_software if asset.export_version: string_asset = utils.asset_to_string(asset) assets_list.append(string_asset) if assets_list == []: for variant in variants_list: asset.variant = variant exported_assets_list = prefs.asset( asset).export_root.exported_assets_list if exported_assets_list != []: for exported_asset in exported_assets_list: asset.export_asset = exported_asset asset.export_version = prefs.asset( asset).export.last_version asset.software = prefs.asset( asset).export.version_software if asset.export_version: string_asset = utils.asset_to_string(asset) assets_list.append(string_asset) break if assets_list != []: mimeData = QtCore.QMimeData() mimeData.setText((pickle.dumps(assets_list, 0)).decode()) drag = QtGui.QDrag(self) drag.setMimeData(mimeData) icon = defaults._nodes_icons_dic_[ self.parent.selected_asset.stage] pixmap = QtGui.QPixmap(icon).scaled( 38, 38, QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation) drag.setPixmap(pixmap) drag.setHotSpot( QtCore.QPoint(pixmap.width() / 2, pixmap.height())) drag.setPixmap(pixmap) result = drag.exec_(QtCore.Qt.MoveAction) else: logger.warning("No publish found...")
def init_widget(self): icon = defaults._nodes_icons_dic_[self.asset.stage] self.refresh_reference_button = self.add_button( defaults._refresh_icon_) self.remove_reference_button = self.add_button( defaults._trash_large_icon_) self.parameters_button = self.add_button(defaults._settings_icon_) self.folder_button = self.add_button(defaults._folder_icon_) self.ticket_button = self.add_button(defaults._tickets_icon_) self.set_icon(icon) self.stage_label = self.add_label(self.asset.stage, 'stage_label') self.name_label = self.add_label(self.asset.name, 'name_label') self.variant_label = self.add_label( "{}.{}".format(self.asset.variant, self.asset.export_version), 'variant_label') self.ns_label = self.add_label(self.asset.export_asset, 'ns_label') if self.asset.export_version != prefs.asset( self.asset).export.last_version: self.variant_label.setStyleSheet( "#variant_label{color:rgb(255,153,51);}") else: self.variant_label.setStyleSheet( "#variant_label{color:rgb(153,255,102);}")
def import_asset_list(self, string_assets_list): for string_asset in string_assets_list: asset = asset_core.string_to_asset(string_asset) if self.asset.software == defaults._painter_: if prefs.asset(self.asset).software.references == {}: self.create_reference(asset) else: logger.warning( f"{defaults._painter_} accepts only 1 reference...") else: if self.asset.category == defaults._set_dress_ and prefs.asset( asset).export.is_proxy: proxy = 1 else: proxy = 0 self.create_reference(asset, proxy=proxy)
def refresh_variants(self): variants = prefs.asset(self.asset).stage.variants for variant in variants: self.ui.variant_comboBox.addItem(variant) index = variants.index(self.asset.variant) self.ui.variant_comboBox.setCurrentIndex(index) self.variant_changed()
def __init__(self, domain=None, category=None, name=None, stage=None, variant=None, software=None, version=None, export_asset=None, export_version=None): # Define the class variables # Uses the wizard "prefs" module to get the project path self.project = prefs.project_path self.domain = domain self.category = category self.name = name self.stage = stage self.variant = variant self.software = software self.version = version self.export_asset = export_asset self.export_version = export_version self.asset_prefs = prefs.asset(self)
def set_last_version(self): old_asset = copy.deepcopy(self.asset) old_namespace = reference.get_name_space(old_asset, self.count) self.asset.export_version = prefs.asset(self.asset).export.last_version self.add_name() self.node_editor.replace_reference(self, self.asset, self.count, old_namespace)
def export(self): items_list = self.ui.export_ma_assets_listWidget.selectedItems() if self.out_range: nspace_list = [] cam_nspace_list = [] for item in items_list: asset_item = asset_core.string_to_asset( self.references[item.text()][defaults._asset_key_]) if asset_item.stage == defaults._cam_rig_: cam_nspace_list.append(item.text()) elif asset_item.stage == defaults._rig_: nspace_list.append(item.text()) self.asset.version = prefs.asset(self.asset).software.last_version auto_hair = self.ui.export_auto_hair_checkBox.isChecked() refresh_assets = self.ui.export_m_refresh_assets_checkBox.isChecked( ) batch_export.sequence(self.asset, nspace_list, cam_nspace_list, self.out_range, refresh_assets, auto_hair) self.hide() else: logger.warning("Please enter a valid frame range")
def init_ui(self): self.export_widget_folder_pushButton = self.add_button( defaults._folder_icon_) self.export_widget_comment_pushButton = self.add_button( defaults._comment_icon_) self.export_widget_tx_pushButton = self.add_button(defaults._tx_icon_) icon = defaults._export_list_neutral_icon_ export_prefs = prefs.asset(self.asset).export self.export_widget_version_label = self.add_label( self.asset.export_version, "export_widget_version_label", 40) self.export_widget_user_label = self.add_label( export_prefs.version_user, "export_widget_user_label", 120) self.export_widget_date_label = self.add_label( export_prefs.version_date, "export_widget_date_label", 180) self.export_widget_comment_label = self.add_label( export_prefs.version_comment, "export_widget_comment_label", 230, QtCore.Qt.AlignLeft) try: self.ui.export_widget_software_label.setText( f'From {export_prefs.version_software}') except: pass if self.asset.stage != defaults._texturing_: self.export_widget_tx_pushButton.setVisible(0) self.update_sanity(self.sanity)
def save(): asset = asset_core.string_to_asset(os.environ[defaults._asset_var_]) asset.version = prefs.asset(asset).software.get_new_version() hou.hipFile.save(file_name=asset.file) string_asset = asset_core.asset_to_string(asset) os.environ[defaults._asset_var_] = string_asset send_signal.save_request_signal(asset.file, string_asset)
def delete_version(self): self.dialog_delete_asset = dialog_delete_asset.Main() if build.launch_dialog_as_child_frameless(self.dialog_delete_asset): if prefs.asset(self.asset).software.remove_version( self.asset.version): self.setParent(None) self.deleteLater()