def do_backup(): """ Saves script into BACKUP_DIR folder after each save. If more then KEEP_VERSIONS files are present, deletes them Returns: None """ if not os.path.isdir(BACKUP_DIR): try: os.mkdir(BACKUP_DIR) except: nuke.message("Cannot create backup folder {}".format(BACKUP_DIR)) current_time_str = time.strftime("%Y%m%d_%H%M") backup_file_url = "{}/bckp_{}_{}.nknc".format(BACKUP_DIR, get_script_name(), current_time_str) try: import shutil nuke.removeOnScriptSave(do_backup) #remove call on save to limit recursion nuke.scriptSave(backup_file_url) nuke.addOnScriptSave(do_backup) delete_old_version() except IOError as e: nuke.message("Cannot write file {}, {}".format(backup_file_url,e))
def registerNukePanel(): '''Register widget as a Nuke panel and add callback for saveing scripts''' import nuke import nukescripts nukescripts.registerWidgetAsPanel('ToDoList.MainWindow', 'To Do List', MainWindow.appName) nuke.addOnScriptSave(findAndReload) nuke.addOnScriptLoad(findAndReload)
def standard_setup(): """Non-standalone user setup.""" import traceback import os import nuke import metatools.imports import sgfs.nuke.menu def callback(): try: metatools.imports.autoreload(sgfs.nuke.menu) sgfs.nuke.menu.build_for_path(nuke.root().name()) except Exception: traceback.print_exc() nuke.addOnScriptSave(callback) nuke.addOnScriptLoad(callback) try: sgfs.nuke.menu.build_for_path(os.getcwd()) except Exception: traceback.print_exc()
def makeBackup(): ''' make backup of script ''' #get script name and make folder if not exist script = nuke.root().name() scriptName = (nuke.root().name().split("/")[-1]).replace(".nk","") operation=blackboxHelper.getBackupSettings("@operation", backupSettings) backupPath=blackboxHelper.getBackupSettings("@backupPath", backupSettings) numberOfBackups=int(blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings)) if backupMinute == True: t = time.strftime("%y%m%d-%H%M") else: t = time.strftime("%y%m%d-%H%M%S") # global dir if operation=="0.0": if not os.path.isdir(backupPath+"/"+scriptName): os.makedirs(backupPath+"/"+scriptName) try: nuke.removeOnScriptSave(makeBackup) nuke.scriptSave(backupPath+"/"+scriptName+"/bckp_"+t+"_"+scriptName+".nk") nuke.addOnScriptSave(makeBackup) except Exception, e: nuke.message("couldn't write a backup file") deleteOlderBackupVersions(backupPath+"/"+scriptName)
def makeBackup(): ''' make backup of script ''' #get script name and make folder if not exist script = nuke.root().name() scriptName = (nuke.root().name().split("/")[-1]).replace(".nk", "") operation = blackboxHelper.getBackupSettings("@operation", backupSettings) backupPath = blackboxHelper.getBackupSettings("@backupPath", backupSettings) numberOfBackups = int( blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings)) if backupMinute == True: t = time.strftime("%y%m%d-%H%M") else: t = time.strftime("%y%m%d-%H%M%S") # global dir if operation == "0.0": if not os.path.isdir(backupPath + "/" + scriptName): os.makedirs(backupPath + "/" + scriptName) try: nuke.removeOnScriptSave(makeBackup) nuke.scriptSave(backupPath + "/" + scriptName + "/bckp_" + t + "_" + scriptName + ".nk") nuke.addOnScriptSave(makeBackup) except Exception, e: nuke.message("couldn't write a backup file") deleteOlderBackupVersions(backupPath + "/" + scriptName)
def init_app(self): """ Called as the application is being initialized """ # first, we use the special import_module command to access the app module # that resides inside the python folder in the app. This is where the actual UI # and business logic of the app is kept. By using the import_module command, # toolkit's code reload mechanism will work properly. #app_payload = self.import_module("app") # now register a *command*, which is normally a menu entry of some kind on a Shotgun # menu (but it depends on the engine). The engine will manage this command and # whenever the user requests the command, it will call out to the callback. # Get Current Shotgun Toolkit path #tk = sgtk.sgtk_from_entity(context.project["type"], context.project["id"]) #sgtk_path = str(tk).split(" ")[-1] sgtk_python_path = sgtk.get_sgtk_module_path() sgtk_config_path = os.path.join( sgtk_python_path.split("install")[0], "config") # Check if hook folder exists, this app will not work without making a bespoke lut gizmo and script. app_hook_path = os.path.join(sgtk_config_path, "hooks", "tk-nuke", "tk-nuke-lut-app") if not os.path.exists(app_hook_path): os.makedirs(app_hook_path) self.logger.info("Created Hooks folder: tk-nuke/tk-nuke-lut-app") # # Copy over the update_lut.py # callback_script = "update_lut.py" # src = os.path.join(os.path.dirname(__file__), "resources", callback_script) # dst = os.path.join(app_hook_path, callback_script) # if not os.path.exists(dst): # shutil.copy2(src, dst) # self.logger.info("Copied "+callback_script+" script to hooks folder because it did not exist yet.") # # Copy over the example init.py # resource = "init.py" # src = os.path.join(os.path.dirname(__file__), "resources", resource) # dst = os.path.join(app_hook_path, resource) # if not os.path.exists(dst): # shutil.copy2(src, dst) # self.logger.info("Copied "+resource+" script to hooks folder because it did not exist yet.") # Adding hook folder to Nuke Path so the custom gizmo and script can be picked up nuke.pluginAddPath(app_hook_path) self.logger.error("Adding " + app_hook_path + " to nuke plugin path") # first, set up our callback, calling out to a method inside the app module contained # in the python folder of the app menu_callback = lambda: loadLut() # now register the command with the engine self.engine.register_command("Load Viewer LUT...", menu_callback) # Callbacks nuke.addOnScriptSave(loadLut()) nuke.addOnScriptLoad(loadLut())
def registerNukePanel(): """Register widget as a Nuke panel and add callback for saveing scripts""" import nuke import nukescripts nukescripts.registerWidgetAsPanel("ToDoList.MainWindow", "To Do List", MainWindow.appName) nuke.addOnScriptSave(findAndReload) nuke.addOnScriptLoad(findAndReload)
def set_open_file_callback(self, func=None): """ set_open_file_callback will set a callback function for when a file is opened """ if func: nuke.addOnScriptSave(func) nuke.addOnScriptLoad(func)
def tank_ensure_callbacks_registered(): """ Make sure that we have callbacks tracking context state changes. """ global g_tank_callbacks_registered if not g_tank_callbacks_registered: nuke.addOnCreate(__tank_startup_node_callback) nuke.addOnScriptSave(__tank_on_save_callback) g_tank_callbacks_registered = True
def addCallbackOnScriptSave(self, func, nodeClass=None, group=None): """Executed when the user tries to save a script.""" self._addNukeCallbackGroup(group) self.windowInstance()['callback'][group]['onScriptSave'][func].add(nodeClass) if not self.__windowHidden: if nodeClass is None: nuke.addOnScriptSave(func) else: nuke.addOnScriptSave(func, nodeClass=nodeClass)
def savebackup(): save = backupfolder() + '/' + time.strftime( '%Y_%m_%d_%H_%M', time.localtime( time.time())) + '_' + os.path.basename( nuke.root().name()).split('.')[0] + '.nk' try: nuke.removeOnScriptSave(savebackup) nuke.scriptSave(save) nuke.addOnScriptSave(savebackup) except: nuke.message('Backup failed!(Pr_ToolKit)')
def setup(): nuke.addBeforeRender(CALLBACKS_BEFORE_RENDER.execute) nuke.addOnScriptLoad(CALLBACKS_ON_SCRIPT_LOAD.execute) nuke.addOnScriptSave(CALLBACKS_ON_SCRIPT_SAVE.execute) nuke.addOnScriptClose(CALLBACKS_ON_SCRIPT_CLOSE.execute) nuke.addOnCreate(CALLBACKS_ON_CREATE.execute) nuke.addUpdateUI(CALLBACKS_UPDATE_UI.execute) if nuke.GUI: import nukescripts nukescripts.addDropDataCallback(CALLBACKS_ON_DROP_DATA.execute)
def toggleBackupProcess(): ''' enable/disable blackbox - set by value in blackbox.set ''' #reload settings enableBackup=blackboxHelper.getBackupSettings("@enableBackup", backupSettings) backupPath=blackboxHelper.getBackupSettings("@backupPath", backupSettings) operation=blackboxHelper.getBackupSettings("@operation", backupSettings) numberOfBackups=blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings) if enableBackup == "1.0": nuke.addOnScriptSave(makeBackup) else: nuke.removeOnScriptSave(makeBackup)
def tank_ensure_callbacks_registered(): """ Make sure that we have callbacks tracking context state changes. """ import sgtk engine = sgtk.platform.current_engine() # Register only if we're missing an engine (to allow going from disabled to something else) # or if the engine specifically requests for it. if not engine or engine.get_setting("automatic_context_switch"): global g_tank_callbacks_registered if not g_tank_callbacks_registered: nuke.addOnScriptLoad(tank_startup_node_callback) nuke.addOnScriptSave(__tank_on_save_callback) g_tank_callbacks_registered = True
def make_backup(): script_name = get_script_name() script_backup_dir = "{}/{}".format(backup_dir, script_name) current_time = time.strftime("%y%m%d-%H%M") if not os.path.isdir(script_backup_dir): os.makedirs(script_backup_dir) try: nuke.removeOnScriptSave(make_backup) nuke.scriptSave("{}/backup_{}_{}.nk".format(script_backup_dir, current_time, script_name)) nuke.addOnScriptSave(make_backup) except: nuke.message("Could't write a backup file!!") delete_older_backup_versions(script_backup_dir)
def toggleBackupProcess(): ''' enable/disable blackbox - set by value in blackbox.set ''' #reload settings enableBackup = blackboxHelper.getBackupSettings("@enableBackup", backupSettings) backupPath = blackboxHelper.getBackupSettings("@backupPath", backupSettings) operation = blackboxHelper.getBackupSettings("@operation", backupSettings) numberOfBackups = blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings) if enableBackup == "1.0": nuke.addOnScriptSave(makeBackup) else: nuke.removeOnScriptSave(makeBackup)
def make_save(): """ 保存备份文件 """ script_name = get_script_name() project_name = script_name.split("_")[0] shot_name = "_".join(script_name.split("_")[1:-3]) script_backup_dir = "{}/{}/{}".format(backup_dir, project_name, shot_name) current_time = time.strftime("%m%d_%H%M") if not os.path.isdir(script_backup_dir): os.makedirs(script_backup_dir) try: nuke.removeOnScriptSave(make_save) nuke.scriptSave("{}/{}_{}.nk".format(script_backup_dir, script_name, current_time)) nuke.addOnScriptSave(make_save) except: nuke.message(u"没有需要备份的文件") del_older_backup_version(script_backup_dir)
def make_backup(): """ make backup of script :returns: none """ script_name = get_current_script_name() script_backup_dir = "{}/{}".format(BACKUP_DIR, script_name) current_time = time.strftime("%Y%m%d-%H%M") if not os.path.isdir(script_backup_dir): os.makedirs(script_backup_dir) try: nuke.removeOnScriptSave(make_backup) nuke.scriptSave("{}/bckp_{}_{}.nk".format(script_backup_dir, current_time, script_name)) nuke.addOnScriptSave(make_backup) except: nuke.message("Couldn't write a backup file") delete_older_backup_versions(script_backup_dir)
def tank_ensure_callbacks_registered(engine=None): """ Make sure that we have callbacks tracking context state changes. The OnScriptLoad callback really only comes into play when you're opening a file or creating a new script, when there is no current script open in your Nuke session. If there is a script currently open then this will spawn a new Nuke instance and the callback won't be called. """ global g_tank_callbacks_registered # Register only if we're missing an engine (to allow going from disabled to something else) # or if the engine specifically requests for it. if not engine or engine.get_setting("automatic_context_switch"): if not g_tank_callbacks_registered: nuke.addOnScriptLoad(sgtk_on_load_callback) nuke.addOnScriptSave(__sgtk_on_save_callback) g_tank_callbacks_registered = True elif engine and not engine.get_setting("automatic_context_switch"): # we have an engine but the automatic context switching has been disabled, we should ensure the callbacks # are removed. if g_tank_callbacks_registered: nuke.removeOnScriptLoad(sgtk_on_load_callback) nuke.removeOnScriptSave(__sgtk_on_save_callback) g_tank_callbacks_registered = False
def tank_ensure_callbacks_registered(engine=None): """ Make sure that we have callbacks tracking context state changes. The OnScriptLoad callback really only comes into play when you're opening a file or creating a new script, when there is no current script open in your Nuke session. If there is a script currently open then this will spawn a new Nuke instance and the callback won't be called. """ # Register only if we're missing an engine (to allow going from disabled to something else) # or if the engine specifically requests for it. if not engine or engine.get_setting("automatic_context_switch"): global g_tank_callbacks_registered if not g_tank_callbacks_registered: nuke.addOnScriptLoad(sgtk_on_load_callback) nuke.addOnScriptSave(__sgtk_on_save_callback) g_tank_callbacks_registered = True elif engine and not engine.get_setting("automatic_context_switch"): # we have an engine but the automatic context switching has been disabled, we should ensure the callbacks # are removed. global g_tank_callbacks_registered if g_tank_callbacks_registered: nuke.removeOnScriptLoad(sgtk_on_load_callback) nuke.removeOnScriptSave(__sgtk_on_save_callback) g_tank_callbacks_registered = False
shot_folder + custom_folder + version + "/" + show_filename + scene_filename + shot_filename + custom_filename + version + number + "." + extension) node['proxy'].setValue(path + show_folder + scene_folder + shot_folder + custom_folder + version + "/" + show_filename + scene_filename + shot_filename + custom_filename + version + "_proxy" + number + "." + extension) if extension == "sgi": node['datatype'].setValue("16 Bit") except: print("No AutoFillWrites found.") def createOutputDir(): file = nuke.filename(nuke.thisNode()) dir = os.path.dirname(file) osdir = nuke.callbacks.filenameFilter(dir) if not os.path.isdir(osdir): os.makedirs(osdir) # register functions nuke.addOnScriptSave(updateAutoFillWrite) nuke.addUpdateUI(updateAutoFillWrite, nodeClass='Write') nuke.addBeforeRender(createOutputDir)
try: import re regex = re.compile("v[0-9]{3}") fileVers = regex.findall(nuke.root().name())[0] for w in nuke.allNodes('Write'): renderPath = w['file'].value() renderVers = regex.findall(renderPath) if len(renderVers) > 0: for v in renderVers: renderPath = renderPath.replace(v, fileVers) w['file'].setValue(renderPath) except: pass nuke.addOnScriptSave(matchWriteVersionToFilename) def setLightingStatusComplete(): import tank PROJECT_ID = tank.platform.current_engine().context.project['id'] import shotgun_api3 as shotgun SERVER_PATH = "https://psyop.shotgunstudio.com" SCRIPT_USER = "******" SCRIPT_KEY = "e0078c0e80f09ee7a76de2c25afce6bd34a5bc601f598d446daf6a8e848d9089" sg = shotgun.Shotgun(SERVER_PATH, SCRIPT_USER, SCRIPT_KEY) try: shotName = nuke.root().name().split('/')[-1].split('_')[0] #get shot fields = ['id', 'code', 'sg_status_list']
#THIS LINE WILL ADD THE NEW ENTRY TO THE PANE MENU nuke.menu('Pane').addCommand('SearchReplace', addSRPanel) # CREATE A READ NODE AND OPEN THE "DB" TAB def customRead(): n = nuke.createNode( 'Read' ) n['PipeL'].setFlag( 0 ) return n nuke.menu( 'Nodes' ).addCommand( 'Image/ReadPipel', customRead, 'Shift+r' ) nuke.addOnUserCreate( nuk.general.read.createVersionKnobs, nodeClass='Read' ) nuke.addKnobChanged( nuk.general.read.updateVersionKnob, nodeClass='Read' ) nuke.addOnScriptLoad( nuk.general.read.checkVersions ) nuke.addOnScriptSave( nuk.general.read.checkVersions ) """ import nuk.general.read import nuke nuke.removeOnScriptLoad(nuk.general.read.checkVersions) nuke.removeOnScriptSave(nuk.general.read.checkVersions) """ def mergeColor(): n = nuke.thisNode() k = nuke.thisKnob() if k.name() == "mix": v = k.value() green = v red = 1 - int(v) r = red
import os import sys import KnobScripter from pype.nuke.lib import (writes_version_sync, on_script_load, check_inventory_versions) import nuke from pypeapp import Logger log = Logger().get_logger(__name__, "nuke") # nuke.addOnScriptSave(writes_version_sync) nuke.addOnScriptSave(on_script_load) nuke.addOnScriptLoad(check_inventory_versions) nuke.addOnScriptSave(check_inventory_versions) # nuke.addOnScriptSave(writes_version_sync) log.info('Automatic syncing of write file knob to script version')
def start(): nuke.addOnScriptSave(backup_autosave_file)
nuke.removeOnScriptSave(makeBackup) nuke.scriptSave(backupPath+"/"+scriptName+"/bckp_"+t+"_"+scriptName+".nk") nuke.addOnScriptSave(makeBackup) except Exception, e: nuke.message("couldn't write a backup file") deleteOlderBackupVersions(backupPath+"/"+scriptName) # per script else: backupPath = "/".join(nuke.root().name().split("/")[:-1])+"/_backups_%s" % scriptName if not os.path.isdir(backupPath): os.makedirs(backupPath) try: nuke.removeOnScriptSave(makeBackup) nuke.scriptSave(backupPath+"/bckp_"+t+"_"+scriptName+".nk") nuke.addOnScriptSave(makeBackup) except Exception, e: nuke.message("couldn't write a backup file") deleteOlderBackupVersions(backupPath) def toggleBackupProcess(): ''' enable/disable blackbox - set by value in blackbox.set ''' #reload settings enableBackup=blackboxHelper.getBackupSettings("@enableBackup", backupSettings) backupPath=blackboxHelper.getBackupSettings("@backupPath", backupSettings) operation=blackboxHelper.getBackupSettings("@operation", backupSettings) numberOfBackups=blackboxHelper.getBackupSettings("@numberOfBackups", backupSettings)
# Animation Menu animation = nuke.menu("Animation") # Viewer Menu viewer = nuke.menu("Viewer") # Preferences Condition if os.path.exists(platform_pref_path()): # Preferences Available import Bc_ToolSet_preferences as pref gizmoColor = pref.gizmo_color if pref.save_log is True: from PrPy.SaveLog import save_log, lock_save_log nuke.addOnScriptSave(save_log) nuke.addOnScriptLoad(lock_save_log) # Gizmos - Nodes Menu if pref.Bc_ShuffleMatte is True: Bc_ShuffleMatte = "nuke.createNode('Bc_ShuffleMatte', 'tile_color %d')" % gizmoColor nodes.addCommand("Bc_ShuffleMatte", Bc_ShuffleMatte, "", icon="Bc_ShuffleMatte_v01.png") if pref.Bc_LBGrain is True: Bc_LBGrain = "nuke.createNode('Bc_LBGrain', 'tile_color %d')" % gizmoColor nodes.addCommand("Bc_LBGrain", Bc_LBGrain, "", icon="Bc_LBGrain_v01.png")
# -*- coding:utf-8 -*- __date__ = '2017/3/10 16:00' __author__ = 'liaokong' import nuke import AutoSave nuke.menu("Nuke").addCommand("pipeline/open backup dir", "AutoSave.open_backup_dir()") nuke.addOnScriptSave(autoSave.make_save)
(pName, pExt) = os.path.splitext(os.path.basename(root['name'].value())) pData = etree.fromstring(root['tri_project_xml_formats'].value()) for group in nuke.allNodes("Group", nuke.root()): if 'triwrite_gizmo' not in group.knobs(): continue resultNode = group.node('result') dailiesNode = group.node('dailies') #--- update results params filename = pName + pData.find('result').find('file').get('numbers') + pData.find('result').find('file').get('file_type') filename = nukenormpath(filename) oldfilename = os.path.basename(resultNode['file'].value()) resultNode['file'].setValue(resultNode['file'].value().replace(oldfilename, filename)) #--- update dailies params filename = pName + pData.find('dailies').find('file').get('numbers') + pData.find('dailies').find('file').get('file_type') filename = nukenormpath(filename) oldfilename = os.path.basename(dailiesNode['file'].value()) dailiesNode['file'].setValue(dailiesNode['file'].value().replace(oldfilename, filename)) pData = None nuke.addOnUserCreate(tri_project_init, nodeClass="Root") nuke.addOnUserCreate(tri_writeGizmo_init, nodeClass="Group") nuke.addOnScriptSave(tri_writeGizmo_update, nodeClass="Root") nuke.addOnScriptLoad(tri_project_init, nodeClass="Root")
import os import sys import KnobScripter from pype.nuke.lib import (writes_version_sync, onScriptLoad, checkInventoryVersions) import nuke from pypeapp import Logger log = Logger().get_logger(__name__, "nuke") # nuke.addOnScriptSave(writes_version_sync) nuke.addOnScriptSave(onScriptLoad) nuke.addOnScriptLoad(checkInventoryVersions) nuke.addOnScriptSave(checkInventoryVersions) # nuke.addOnScriptSave(writes_version_sync) log.info('Automatic syncing of write file knob to script version')
nkScripts = assetManager.getNukeScripts() if not nkScripts: # IF THERE ARE NONE DON'T DO ANYTHING return # CREATE PANEL p = assetManager.NkPanel( nkScripts ) # ADJUST SIZE p.setMinimumSize( 200, 200 ) # IF PANEL WAS CONFIRMED AND A NUKE SCRIPT WAS SELECTED, OPEN IT if p.showModalDialog(): if p.selectedScript: nuke.scriptOpen( p.selectedScript ) # ADD CALLBACKS nuke.addOnScriptSave( assetManager.checkScriptName ) nuke.addOnUserCreate( nkPanelHelper, nodeClass='Root') nuke.addOnUserCreate( assetManager.createVersionKnobs, nodeClass='Read' ) nuke.addKnobChanged( assetManager.updateVersionKnob, nodeClass='Read' ) nuke.addBeforeRender( assetManager.createOutDirs, nodeClass='Write' ) nuke.knobDefault( 'Write.beforeRender', 'assetManager.createOutDirs()') ### END ASSET MANAGEMENT SETUP ### ### BEGIN RENDER SETUP ### m = menubar.addMenu("Render") m.addCommand("Create Paths", "createPaths()") #m.addCommand("Fix Paths", "fixPath.fixPath()") ## Uncomment this if RUSH is used #m.addCommand("Send2Rush", "s2r.Nuke2Rush()")
menu = nuke.menu("Nuke") menu.addCommand( "Tools/Ada/Remove Ada Tab", "__import__('ada.nuke.utils', " "fromlist=['remove_ada_tab']).remove_ada_tab(nuke.selectedNodes())", shortcut="Shift+Alt+t", ) menu.addCommand( "Tools/Ada/Bake Selected", "__import__('ada.nuke.context', " "fromlist=['Engine']).Engine.run(nodes=nuke.selectedNodes())", shortcut="Shift+b", ) menu.addCommand( "Tools/Ada/Add Knobs To Bake", "__import__('ada.nuke.node', " "fromlist=['add_knob_to_bake']).add_knob_to_bake(nuke.selectedNode())", shortcut="Shift+t", ) # add ada file loader nuke.addOnScriptLoad(load_ada_context_from_file) # add ada file loader nuke.addOnScriptSave(save_ada_context_to_file) # add on destroy callback to remove any context information that nodes are associated with.
#/Pr_Tools/Python/autobackup/menu.py, v1.0.1, 2020.01.08 import nuke import autoback nuke.addOnScriptSave(autoback.savebackup)
1] + "_" + fileNameSplit[2] projectName = path fileVersion = fileNameSplit[3].replace(".nk", "") print dirname print projectPath nuke.addFavoriteDir("Project", projectPath) nuke.addFavoriteDir("Inputs", projectPath + "\\input\\" + dirname + "\\") nuke.addFavoriteDir("Write", writeRootDir + "\\" + projectName + "\\" + dirname) def scriptSaved(): loadScriptVars() checkWriteNodes() #checkInputNodes() def scriptLoaded(): loadScriptVars() checkWriteNodes() #checkInputNodes() nuke.addOnScriptLoad(scriptLoaded) nuke.addOnScriptSave(scriptSaved)
import nuke import script_backup nuke.menu('Nuke').addCommand("utilities/auto_backup/open backup dir", "script_backup.open_backup_dir()") nuke.addOnScriptSave(script_backup.do_backup)
nuke.addOnScriptSave(makeBackup) except Exception, e: nuke.message("couldn't write a backup file") deleteOlderBackupVersions(backupPath + "/" + scriptName) # per script else: backupPath = "/".join( nuke.root().name().split("/")[:-1]) + "/_backups_%s" % scriptName if not os.path.isdir(backupPath): os.makedirs(backupPath) try: nuke.removeOnScriptSave(makeBackup) nuke.scriptSave(backupPath + "/bckp_" + t + "_" + scriptName + ".nk") nuke.addOnScriptSave(makeBackup) except Exception, e: nuke.message("couldn't write a backup file") deleteOlderBackupVersions(backupPath) def toggleBackupProcess(): ''' enable/disable blackbox - set by value in blackbox.set ''' #reload settings enableBackup = blackboxHelper.getBackupSettings("@enableBackup", backupSettings) backupPath = blackboxHelper.getBackupSettings("@backupPath", backupSettings)
import atom_server from pype.nuke.lib import (writes_version_sync, onScriptLoad, checkInventoryVersions) import nuke from pypeapp import Logger log = Logger().get_logger(__name__, "nuke") # nuke.addOnScriptSave(writes_version_sync) nuke.addOnScriptSave(onScriptLoad) nuke.addOnScriptLoad(checkInventoryVersions) nuke.addOnScriptSave(checkInventoryVersions) nuke.addOnScriptSave(writes_version_sync) log.info('Automatic syncing of write file knob to script version')
continue # SAVE NUKE SCRIPT nuke.scriptSaveAs( nkPath ) fileSaved = True return nkPath # ADD EASY SAVE TO SHOT MENU shotMenu = '%s - %s' % ( os.getenv('SCENE'), os.getenv('SHOT') ) nuke.menu( 'Nuke' ).addCommand( shotMenu+'/Easy Save', easySave, 'Ctrl+S' ) nuke.menu('Nuke').addCommand( shotMenu+'/Write Assets', 'nuke.createNode("WriteAssets")', 'W', icon='Write.png') # REQUIRE VERSIONING IN SCRIPT NAME def checkScriptName(): if not re.search( r'[vV]\d+', nuke.root().name() ): raise NameError, 'Please include a version number and save script again.' nuke.addOnScriptSave( checkScriptName ) # GET ALL NUKE SCRIPTS FOR CURRENT SHOT def getNukeScripts(): nkFiles = glob( os.path.join( nukeDir(), '*.nk' ) ) return nkFiles # PANEL TO SHOW NUKE SCRIPTS FOR CURRENT SHOT class NkPanel( nukescripts.PythonPanel ): def __init__( self, nkScripts ): nukescripts.PythonPanel.__init__( self, 'Open NUKE Script' ) self.checkboxes = [] self.nkScripts = nkScripts self.selectedScript = '' for i, n in enumerate( self.nkScripts ):
moduleName = os.path.basename( os.path.normpath(os.path.join(currentFile, "..", "..", ".."))) if not main_folder in sys.path: sys.path.append(main_folder) ### Registering Callback ### exec("from {0} import config as wsconfig".format(moduleName)) def store_recent(): wsconfig.add_recent(nuke.Root().knob("name").value()) nuke.addOnScriptLoad(store_recent) nuke.addOnScriptSave(store_recent) if nuke.env['NukeVersionMajor'] < 11: execfile(os.path.join(main_folder, moduleName, "main.py")) ### Import Required Modules ### def WelcomeScreen_start(): ws = WelcomeScreen() ws.start() ### Registering Menu ### menu = nuke.menu('Nuke') menu.addCommand('General/Welcome Screen', lambda f=WelcomeScreen_start: nuke.executeInMainThread(f), 'ctrl+shift+w')