def post_rollback():
filepath = rollback_window.result
if filepath is not None:
nuke.scriptClose()
print "open file " + filepath
nuke.scriptOpen(filepath)
def main():
"""
sys.argv[0]: current file
sys.argv[1]: nuke file path
sys.argv[2]: write node
sys.argv[3]: frame range 1001-1002
sys.argv[4]: output path
:return:
"""
file_name = sys.argv[1]
nuke.scriptOpen(file_name.replace('\\', '/'))
if not os.path.isdir(os.path.dirname(sys.argv[4])):
os.makedirs(os.path.dirname(sys.argv[4]))
nuke.toNode(sys.argv[2])['file'].setValue(sys.argv[4])
nuke.toNode(sys.argv[2])['disable'].setValue(False)
frames = sys.argv[3].split('-')
first_frame, last_frame = int(frames[0]), int(frames[1])
switch_path()
#nuke.scriptSave()
nuke.execute(sys.argv[2], first_frame, last_frame, continueOnError=True)
nuke.scriptClose(file_name)
def reopen_scene():
"""
:return:
"""
scene_name = nuke.root().name()
nuke.scriptClose(scene_name)
nuke.scriptOpen(scene_name)
def buildCompScript(layerOrderFile, compScriptFile, isRunningFromScript):
# kept here if script is run from the comp itself
if not os.path.isfile(layerOrderFile):
print "Could not find layer_order.yml in " + shotDir
sys.exit()
if not isRunningFromScript:
nuke.scriptClear()
# get nuke script to build
nuke.scriptOpen(compScriptFile)
nuke.selectAll()
[nuke.delete(node) for node in nuke.selectedNodes()]
# arrange templates in the given nuke script in vertical order
templates = getTemplateList(layerOrderFile)
for i, template in enumerate(templates):
nuke.nodePaste(template)
bdNodes = nuke.selectedNodes()
node = nuke.selectedNodes("BackdropNode")[0]
dotNode = nuke.selectedNodes('Dot')[0]
if i > 0:
bdNodes.remove(node)
nodePrevX = node.xpos()
nodePrevY = node.ypos()
node.setYpos(previousNode.ypos() + 500)
node.setXpos(previousNode.xpos())
for n in bdNodes:
if n.ypos() > nodePrevY:
n.setYpos(node.ypos() + (n.ypos() - nodePrevY))
else:
n.setYpos(node.ypos() + (n.ypos() + nodePrevY))
if n.xpos() > nodePrevX:
n.setXpos(node.xpos() + (n.xpos() - nodePrevX))
else:
n.setXpos(node.xpos() + (n.xpos() + nodePrevX))
if i > 1:
dotNode.setInput(0, previousDotNode.dependent()[0])
else:
dotNode.setInput(0, previousDotNode)
previousNode = node
previousDotNode = dotNode
if not isRunningFromScript:
# save nuke script
nuke.scriptSave(compScriptFile)
# avoid opening GUI and getting extra nodes from previous script
nuke.scriptClose()
# remove temp files
[os.remove(template) for template in templates if "temp" in template]
def checkin():
save = nuke.scriptSave()
if save==True:
toCheckin = get_checkin_path()
if can_checkin():
amu.setComment(toCheckin, 'comment')
dest = amu.checkin(toCheckin)
nuke.message('Checkin Successful!')
nuke.scriptClose()
else:
nuke.message('Can not check in')
def quick_launch_shot_in_nuke(self, _link):
try:
#nuke.scriptClear()
nuke.scriptClose()
nuke.scriptOpen(_link)
except:
pass
#print self.task_items
#nuke.scriptClear()
#nuke.scriptOpen(nk)
return
def checkin():
filePath = nuke.callbacks.filenameFilter( nuke.root().name() )
save = nuke.scriptSave()
if save==True:
toCheckin = os.path.join(amu.getUserCheckoutDir(), os.path.basename(os.path.dirname(filePath)))
if amu.canCheckin(toCheckin):
dest = amu.checkin(toCheckin, False)
nuke.message('Checkin Successful!')
nuke.scriptClose()
else:
nuke.message('Can not check in')
def checkin():
filePath = nuke.callbacks.filenameFilter(nuke.root().name())
save = nuke.scriptSave()
if save == True:
toCheckin = os.path.join(amu.getUserCheckoutDir(),
os.path.basename(os.path.dirname(filePath)))
if amu.canCheckin(toCheckin):
dest = amu.checkin(toCheckin, False)
nuke.message('Checkin Successful!')
nuke.scriptClose()
else:
nuke.message('Can not check in')
def smartSetter():
p = createPanel()
if p.show():
inp = open(smartSettingsInputPath, 'r')
smartOn = p.value("enable smart on start")
projectPath = p.value("project path: ")
#delete last /
if projectPath != "" and projectPath[-1] == "/":
projectPath = projectPath[:-1]
artist = p.value("default artist: ")
scriptPath = p.value("script path inside a project: ")
renderPath = p.value("render path inside a project: ")
overwirteSaveWithSmartSave = p.value("always smartSave")
showRecentFiles = p.value("show recent files")
#read in settingsdocument and save per line
settingsCont = []
for line in inp:
settingsCont.append(line)
#change settings
updateSettings(settingsCont, "smartOn", smartOn)
updateSettings(settingsCont, "projectPath", projectPath)
updateSettings(settingsCont, "artist", artist)
updateSettings(settingsCont, "scriptPath", scriptPath)
updateSettings(settingsCont, "renderPath", renderPath)
updateSettings(settingsCont, "overwirteSaveWithSmartSave",
overwirteSaveWithSmartSave)
updateSettings(settingsCont, "showRecentFiles", showRecentFiles)
#write settings in string for output
outputSettings = ""
i = 0
for i in range(0, len(settingsCont)):
outputSettings = outputSettings + settingsCont[i]
#update smartSettings
outp = open(smartSettingsOutputPath, 'w')
outp.write(outputSettings)
outp.close()
#rename to original in order to overwrite
os.rename('/Users/%s/.nuke/smart/smartSettings_w.txt' % User,
'/Users/%s/.nuke/smart/smartSettings.txt' % User)
if nuke.ask(
"Your nuke must be restarted before the updated settings work. restart now?"
):
nuke.scriptClose()
def main():
folder = sys.argv[1]
folder = folder.replace('\\', '/')
#create read node
if get_frame_range(folder):
start_frame, end_frame = get_frame_range(folder)
read_node = create_read_node(folder, start_frame, end_frame)
#create write node
write_node = create_write_node(folder)
write_node.setInput(0, read_node)
#execute
nuke.execute(write_node, start_frame, end_frame, continueOnError=True)
nuke.scriptClose()
def smartSetter():
p=createPanel()
if p.show():
inp = open(smartSettingsInputPath,'r')
smartOn=p.value("enable smart on start")
projectPath=p.value("project path: ")
#delete last /
if projectPath!="" and projectPath[-1]=="/":
projectPath = projectPath[:-1]
artist=p.value("default artist: ")
scriptPath=p.value("script path inside a project: ")
renderPath=p.value("render path inside a project: ")
overwirteSaveWithSmartSave=p.value("always smartSave")
showRecentFiles=p.value("show recent files")
#read in settingsdocument and save per line
settingsCont=[]
for line in inp:
settingsCont.append(line)
#change settings
updateSettings(settingsCont,"smartOn",smartOn)
updateSettings(settingsCont,"projectPath",projectPath)
updateSettings(settingsCont,"artist",artist)
updateSettings(settingsCont,"scriptPath",scriptPath)
updateSettings(settingsCont,"renderPath",renderPath)
updateSettings(settingsCont,"overwirteSaveWithSmartSave",overwirteSaveWithSmartSave)
updateSettings(settingsCont,"showRecentFiles",showRecentFiles)
#write settings in string for output
outputSettings=""
i=0
for i in range(0,len(settingsCont)):
outputSettings=outputSettings+ settingsCont[i]
#update smartSettings
outp = open(smartSettingsOutputPath,'w')
outp.write(outputSettings)
outp.close()
#rename to original in order to overwrite
os.rename('/Users/%s/.nuke/smart/smartSettings_w.txt'%User, '/Users/%s/.nuke/smart/smartSettings.txt'%User)
if nuke.ask("Your nuke must be restarted before the updated settings work. restart now?"):
nuke.scriptClose()
def main():
import nuke
folder, fps_value = get_input()
folder = folder.replace('\\', '/')
# create read node
if get_frame_range(folder):
start_frame, end_frame = get_frame_range(folder)
# set_fps
set_fps(int(fps_value))
# create read node
read_node = create_read_node(folder, start_frame, end_frame)
# create write node
write_node = create_write_node(folder)
write_node.setInput(0, read_node)
# execute
nuke.execute(write_node, start_frame, end_frame, continueOnError=True)
nuke.scriptClose()
def save_query(log):
cancel = False
if HOST == STANDALONE:
from tentaculo.api import standalone
cancel = standalone.message_function("save_query")[0]
elif HOST == MAYA or HOST == MAYA2:
file_name = mc.file(query=True, sceneName=True)
need_save = mc.file(query=True, modified=True)
if len(file_name) > 0 and need_save:
ret = mc.confirmDialog(title='Closing file',
message='Save current file?',
messageAlign='center',
button=['Yes', 'No', 'Cancel'],
defaultButton='Yes',
cancelButton='Cancel',
dismissString='Cancel')
if ret == "Yes":
mc.file(save=True, type="mayaAscii")
elif ret == "Cancel":
cancel = True
elif HOST == NUKE:
cancel = not nuke.scriptClose()
elif HOST == HOUDINI:
need_save = hou.hipFile.hasUnsavedChanges()
if need_save:
hou.hipFile.clear()
cancel = hou.hipFile.hasUnsavedChanges()
elif HOST == MAX:
cancel = not MaxPlus.FileManager.CheckForSave()
elif HOST == C4D:
doc = c4d.documents.GetActiveDocument()
if doc is not None and doc.GetChanged():
cancel = not c4d.documents.SaveDocument(
doc,
doc.GetDocumentPath() + "/" + doc.GetDocumentName(),
c4d.SAVEDOCUMENTFLAGS_DIALOGSALLOWED, c4d.FORMAT_C4DEXPORT)
elif HOST == BLENDER:
if bpy.data.is_dirty:
bpy.ops.wm.save_mainfile(check_existing=True)
cancel = bpy.data.is_dirty
elif HOST == KATANA:
if KatanaFile.IsFileDirty():
mb = UI4.App.Application.QtGui.QMessageBox(app_window())
mb.setText("Closing file")
mb.setInformativeText("Save current file?")
mb.setStandardButtons(
UI4.App.Application.QtGui.QMessageBox.Yes
| UI4.App.Application.QtGui.QMessageBox.No
| UI4.App.Application.QtGui.QMessageBox.Cancel)
ret = mb.exec_()
if ret == UI4.App.Application.QtGui.QMessageBox.Yes:
KatanaFile.Save(
NodegraphAPI.NodegraphGlobals.GetProjectAssetID())
cancel = ret == UI4.App.Application.QtGui.QMessageBox.Cancel
return not cancel
def latestBigHugBKP():
try:
name = nuke.toNode("root")['name'].value()
path = name.rpartition("/")[0]
content = os.listdir(path)
low = 0
for item in content:
if "comp_v" in item and "autosave" not in item and "~" not in item:
version = int(
item.rpartition('_')[2].rpartition('.')[0].rpartition('v')
[2])
if version > low:
low = version
low = "%03d" % low
latest = name.rpartition('_')[0] + "_comp_v" + str(low) + ".nk"
nuke.scriptOpen(latest)
nuke.scriptClose()
except:
print "hallo"
def main():
file_name = sys.argv[1]
nuke.scriptOpen(file_name.replace('\\', '/'))
if not os.path.isdir(os.path.dirname(sys.argv[4])):
os.makedirs(os.path.dirname(sys.argv[4]))
nuke.toNode(sys.argv[2])['file'].setValue(sys.argv[4])
nuke.toNode(sys.argv[2])['disable'].setValue(False)
frames = sys.argv[3].split('-')
first_frame, last_frame = int(frames[0]), int(frames[1])
switch_path()
#nuke.scriptSave()
nuke.execute(sys.argv[2], first_frame, last_frame, continueOnError=True)
nuke.scriptClose(file_name)
def launchProject(self, filePath):
if nuke.scriptClose():
nuke.scriptOpen(filePath)
super(NukeProjectLauncher,
self).save_recents(write_local_config=True)
# self.nuke_tools.reset_environment()
self.nuke_tools.set_environment(self.configReader, self.template,
self.get_token_dict())
return True
else:
return False
if eachWrite["use_limit"].value() is True:
writeFirst = eachWrite["first"].value()
writeLast = eachWrite["last"].value()
print "Starting render job for: File - %s, Write Node - %s\n" % (
basename, writeName)
nuke.execute(writeName, int(writeFirst), int(writeLast))
print "-----------------------------------------------------------------------------------------" \
"-------------------------------"
renderedJobs.append(writeName)
else:
print "Please set 'limit to range' in '%s' Write node of file '%s', skipping to next render job." \
% (writeName, basename)
print "-----------------------------------------------------------------------------------------" \
"-------------------------------"
setLimit.append([basename, writeName])
nuke.scriptClose(eachFile)
elif len(allWrite) < 1:
print "No Write node found in '%s', skipping to next render job" % basename
nuke.scriptClose(eachFile)
print "-----------------------------------------------------------------------------------------" \
"-------------------------------"
noWrite.append(basename)
continue
print "\nRender jobs completed at %s" % time.strftime("%I:%M %p %d/%m/%Y")
print "\nTotal render jobs completed: %d" % len(renderedJobs)
print "\nTotal render jobs skipped: %d" % len(noWrite + setLimit)
if len(noWrite + setLimit) >= 1:
print "\nSkipped render jobs log:"
for skipped in noWrite:
print " *" + skipped, "- No Write node exists"
def main():
st = StrackGlobals.st
# find current task info
project_id = StrackGlobals.current_project.get("id")
step_name = StrackGlobals.selected_task.get("step").get("code")
task_id = StrackGlobals.selected_task.get("id")
task_code = StrackGlobals.selected_task.get("code")
type_t = StrackGlobals.selected_task.get("item").get("type")
shot_id = StrackGlobals.selected_task.get("item").get("item_id")
root = st.disk.find("project_id={}".format(project_id), ["setting"])
project_name = st.project.find("id={}".format(project_id),
['code']).get("code")
user_id = StrackGlobals.st.task.find(
"id={}".format(task_id)).get("assignee")
user_name = str(
StrackGlobals.st.user.find("id={}".format(user_id)).get("name"))
shot = getattr(st, type_t).find("id=%s" % shot_id, ["json"])
print(shot)
if sys.platform == "win32":
root_dir = root.get("setting").get("win_path")
else:
root_dir = root.get("setting").get("mac_path") \
if sys.platform == "darwin" \
else root.get("setting").get("linux_path")
item = st.shot.find("id=%s" % shot_id)
shot_name = item.get("code", None)
seq_id = item.get("sequence_id", None)
epi_name = ""
if seq_id:
sequence = st.sequence.find("id={}".format(seq_id))
seq_name = sequence.get("code")
epi_id = StrackGlobals.st.sequence.find(
"id={}".format(seq_id), ["episode_id"]).get("episode_id")
if epi_id:
epi_name = StrackGlobals.st.episode.find("id=%s" %
epi_id).get("code")
else:
seq_name = ""
epi_name = ""
nuke_path = os.path.join(root_dir, project_name, epi_name, "sequences",
seq_name, shot_name, "work", step_name, task_code,
"nuke")
# get nuke file in the dir
nukefile_list = [
nuke_file for nuke_file in os.listdir(nuke_path)
if nuke_file.endswith(".nk")
]
nukefile_list.sort(key=lambda x: x.split("_v")[-1])
# get the lastest version
# max_version = max(nukefile_list)
max_version = nukefile_list[-1]
# get new file name ,file path,renderpath
new_v = max_version.split("_v")[-1].split("_e")[0]
new_e = "%03d" % (int(max_version.split("_e")[-1].replace(".nk", "")) + 1)
new_filename = "{0}_{1}_{2}_v{3}_e{4}.nk".format(shot_name, step_name,
user_name, new_v, new_e)
new_filepath = os.path.join(nuke_path, new_filename)
rendername = "{0}_{1}_{2}_v{3}_e{4}".format(shot_name, step_name,
user_name, new_v, new_e)
render_dir = os.path.join(root_dir, project_name, epi_name, "sequences",
seq_name, shot_name, "work", step_name,
task_code, "renders")
outname = rendername + ".%04d.dpx"
outpath = os.path.join(render_dir, rendername, outname).replace("\\", '/')
# get file path and import
max_file_path = os.path.join(nuke_path, max_version)
nuke.scriptOpen(max_file_path)
# change the render path and render setting
writenode = nuke.allNodes("Write")
if writenode:
if len(writenode) > 1:
nuke.message("more then one write node exist")
writenode = [
write for write in writenode
if write["name"].getValue() == "Strack"
][0]
if not writenode:
writenode = writenode[0]
else:
writenode = nuke.createNode("Write")
writenode["file"].setValue(outpath)
writenode["file_type"].setValue("dpx")
writenode["name"].setValue("Strack")
writenode["tile_color"].setValue(255)
# save file
nuke.scriptSave(new_filepath)
nuke.scriptClose()
nuke.scriptOpen(new_filepath)
nuke.message("last file is %s" % max_version)
def new_file(force=True):
nuke.scriptClose(ignoreUnsavedChanges=force)
def latestBigHug():
name = nuke.toNode("root")['name'].value()
if '.nk' not in name:
latest = name.rpartition('/')[0]
nuke.scriptOpen()
nuke.scriptClose()
def run_in_nuke(self):
import nuke
nuke.scriptClose(ignoreUnsavedChanges=True)
nuke.scriptOpen(self.path)
def _convert(fromScript, toScript, overwrite):
import nuke
nuke.scriptOpen(fromScript)
nuke.scriptSaveAs(toScript, overwrite)
nuke.scriptClose()
following = first + size
yield first, min(following - 1, last)
first = following
nukeFile = sys.argv[1]
fileName = os.path.splitext(os.path.basename(nukeFile))[0]
nuke.scriptOpen(nukeFile)
allWrite = nuke.allNodes("Write")
while len(allWrite) != 1:
if len(allWrite) == 0:
print "\nNo Write node found in current Nuke file, please keep one Write node in your Nuke file."
nuke.scriptClose(nukeFile)
break
elif len(allWrite) > 1:
print "\nMultiple Write nodes found, please keep only one Write node in your Nuke file."
nuke.scriptClose(nukeFile)
break
else:
if allWrite[0]["use_limit"].value() is True:
writeFirst = allWrite[0]["first"].value()
writeLast = allWrite[0]["last"].value()
writeName = allWrite[0]["name"].value()
nuke.scriptClose(nukeFile)
print "\nYour frame range is: %s-%s" % (str(
int(writeFirst)), str(int(writeLast)))
out['file'].setValue(vid)
# out['file_type'].setValue(6)
# out['meta_codec'].setValue('avc1')
# out['mov32_fps'].setValue(30)
audio = settings[
'audio'] + '/' '%s_%s.wav' % (
course, fairway_loop)
out['mov64_audiofile'].setValue(audio)
out['create_directories'].setValue(1)
node['file'].setValue(path)
node['first'].setValue(frame_range[0])
node['last'].setValue(frame_range[1])
#####################################################################
nuke.scriptSave(comp)
# nuke.execute('OUT', frame_range[0], frame_range[1])
nuke.scriptClose()
rpcmd = '"' + os.environ['RP_CMDRC_DIR'] + 'RpRcCmd.exe"'
cmd = rpcmd
cmd += ' -nj_name "%s"' % ('GOLF : ' + fairway_loop +
'.nk')
cmd += ' -nj_tags "VSE"'
cmd += ' -nj_priority 5'
cmd += ' -nj_renderer "Nuke v11.2v4/Default version"'
cmd += ' -nj_preset "H:\\_distros\\_lumatools\\lumatools\\_NEILL\\src\\nuke\\golf\\golf_convert.rnjprs"'
cmd += ' -nj_pools "nuke"'
cmd += ' -nj_paused'
cmd += ' -frames "%s-%s"' % (frame_range[0],
frame_range[1])
cmd += ' -outfile "%s"' % vid
cmd += ' %s' % comp
print cmd
def processScript(scriptFile,folders):
### goes through the nuke script and prep's it for transfer.
fileList = []
preComps = []
blastList =[]
nuke.scriptOpen(scriptFile)
for a in nuke.allNodes():
if isinstance(a, nuke.Gizmo):
replaceGizmoWithGroup(a)
if isinstance(a,nuke.Viewer):
nuke.delete(a)
for n in nuke.allNodes():
if "Write" not in n.Class() and "SmartVector" not in n.Class():
for k in n.knobs():
if isinstance(n[k],nuke.File_Knob):
#print n,n[k]
dep=n.dependent()
if n[k].getValue():
if len(n.dependent())>0:
filePath=n[k].getValue()
if not "/elements/grain_plates/" in filePath:
#print fixName(filePath)
rePathFolder=sortOutput(fixName(filePath),folders)
#print rePathFolder
newValue=os.path.join(rePathFolder,os.path.basename(fixName(filePath))).replace(folders['project'],".")
#print newValue
n[k].setValue(newValue)
if n.Class()=='Precomp':
preComps.append(filePath)
else:
fileList.append(filePath)
else:
blastList.append(n)
nuke.root()['project_directory'].setValue('[file dirname [python {nuke.script_directory()}]]')
for b in blastList:
#print "INFO: deleting unused node %s" %b.name()
nuke.delete(b)
saveScriptToOutput(folders)
nuke.scriptClose()
preCompsSet=set(preComps)
for pk in preCompsSet:
fileList.extend(processScript(pk,folders))
return fileList
def tearDown(self):
nuke.scriptClose()
def open_file(file_name):
nuke.scriptClose(ignoreUnsavedChanges=True)
nuke.scriptOpen(file_name)
def _new(self, force=True, fps=None):
nuke.scriptClose(ignoreUnsavedChanges=force)
if fps:
pass
