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()
