def run_engine_cmd(log, install_root, pipeline_config_root, context_items, command, using_cwd, args): """ Launches an engine and potentially executes a command. :param log: logger :param install_root: tank installation :param pipeline_config_root: PC config location :param context_items: list of strings to describe context. Either ["path"], ["entity_type", "entity_id"] or ["entity_type", "entity_name"] :param engine_name: engine to run :param command: command to run - None will display a list of commands :param using_cwd: Was the context passed based on the current work folder? """ log.debug("") log.debug("Context items: %s" % str(context_items)) log.debug("Command: %s" % command) log.debug("Command Arguments: %s" % args) log.debug("Code Location Root: %s" % install_root) log.debug("Sgtk Pipeline Config Location: %s" % pipeline_config_root) log.debug("Location of this script (__file__): %s" % os.path.abspath(__file__)) log.info("") log.info("Welcome to the Shotgun pipeline toolkit!") log.info("For documentation, see https://toolkit.shotgunsoftware.com/forums") # Now create a tk instance and a context if possible if len(context_items) == 1: ctx_path = context_items[0] if using_cwd: log.info("Starting the Sgtk for your current directory '%s'" % ctx_path) # context str is a path if pipeline_config_root is not None: # we are running a project specific tank command tk = tank.tank_from_path(pipeline_config_root) else: # we are running a studio wide command try: tk = tank.tank_from_path(ctx_path) except TankError, e: # this path was not valid. That's ok - we just wont have a tank instance # when we run our commands later. This may be if we for example have # just run tank setup_project from any random folder log.debug("Instantiating Sgtk raised: %s" % e) tk = None # now try to extract a context ctx = None if tk is not None: ctx = tk.context_from_path(ctx_path)
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ current_engine = tank.platform.current_engine() if not current_engine: # If we don't have an engine for some reason then we don't have # anything to do. return if pm.sceneName() == "": # This is a File->New call, so we just leave the engine in the current # context and move on. return # determine the tk instance and ctx to use: tk = current_engine.sgtk # loading a scene file new_path = pm.sceneName().abspath() # this file could be in another project altogether, so create a new # API instance. try: tk = tank.tank_from_path(new_path) except tank.TankError, e: OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e) # build disabled menu create_sgtk_disabled_menu(menu_name) return
def __tank_on_save_callback(): """ Callback that fires every time a file is saved. Carefully manage exceptions here so that a bug in Tank never interrupts the normal workflows in Nuke. """ # get the new file name file_name = nuke.root().name() try: # this file could be in another project altogether, so create a new Tank # API instance. try: tk = tank.tank_from_path(file_name) except tank.TankError, e: __create_tank_disabled_menu(e) return # try to get current ctx and inherit its values if possible curr_ctx = None if tank.platform.current_engine(): curr_ctx = tank.platform.current_engine().context # and now extract a new context based on the file new_ctx = tk.context_from_path(file_name, curr_ctx) # now restart the engine with the new context __engine_refresh(tk, new_ctx)
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ #import rpdb2;rpdb2.start_embedded_debugger("12345") current_engine = tank.platform.current_engine() # first make sure that the disabled menu is reset, if it exists... #if pm.menu("ShotgunMenuDisabled", exists=True): # pm.deleteUI("ShotgunMenuDisabled") # if the scene opened is actually a file->new, then maintain the current # context/engine. scene_name = lxtd.current_scene().filename if not scene_name: return current_engine new_path = scene_name # this file could be in another project altogether, so create a new Tank # API instance. try: tk = tank.tank_from_path(new_path) except tank.TankError, e: # render menu modoshotgunsupport.add_disabled_menu() # (AD) - this leaves the engine running - is this correct? return current_engine
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ current_engine = tank.platform.current_engine() # first make sure that the disabled menu is removed, if it exists... menu_was_disabled = remove_sgtk_disabled_menu() # determine the tk instance and ctx to use: tk = current_engine.sgtk ctx = prev_context if pm.sceneName() == "": # if the scene opened is actually a file->new, then maintain the current # context/engine. if not menu_was_disabled: # just return the current engine - no need to restart it! return current_engine else: # loading a scene file new_path = pm.sceneName().abspath() # this file could be in another project altogether, so create a new # API instance. try: tk = tank.tank_from_path(new_path) except tank.TankError, e: OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e) # build disabled menu create_sgtk_disabled_menu(menu_name) return current_engine # and construct the new context for this path: ctx = tk.context_from_path(new_path, prev_context)
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ current_engine = tank.platform.current_engine() # first make sure that the disabled menu is reset, if it exists... if pm.menu("ShotgunMenuDisabled", exists=True): pm.deleteUI("ShotgunMenuDisabled") # if the scene opened is actually a file->new, then maintain the current # context/engine. if pm.sceneName() == "": return current_engine new_path = pm.sceneName().abspath() # this file could be in another project altogether, so create a new Tank # API instance. try: tk = tank.tank_from_path(new_path) except tank.TankError, e: OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e) # render menu create_tank_disabled_menu(menu_name) # (AD) - this leaves the engine running - is this correct? return current_engine
def _on_project_load_callback(self, event): """ Callback executed after project load in Hiero and Nuke Studio. This triggers an attempt to change the SGTK context to that of the newly opened project file. :param event: The event object from Hiero/NS. """ import hiero.core project = hiero.core.projects()[-1] script_path = project.path() # We're going to just skip doing anything if this fails # for any reason. It would be nice to swap to the error # menu item, but unfortunately a project open event is # triggered on launch when Hiero/Nuke Studio loads the # "Untitled" project from the Nuke install location. There # isn't a way to distinguish between that and something the # user purposefully opened, and we don't want to hose the # toolkit context with that. try: tk = tank.tank_from_path(script_path) # Extract a new context based on the file and change to that # context. new_context = tk.context_from_path( script_path, previous_context=self.context, ) if new_context != self.context: tank.platform.change_context(new_context) except Exception: self.log_debug("Unable to determine context for file: %s" % script_path)
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ current_engine = tank.platform.current_engine() if not current_engine: # If we don't have an engine for some reason then we don't have # anything to do. return doc = c4d.documents.GetActiveDocument() scene_path = doc.GetDocumentPath() scene_name = doc.GetDocumentName() # This is a File->New call, so we just leave the engine in the current # context and move on. if scene_path == "": if prev_context != tank.platform.current_engine().context: current_engine.change_context(ctx) return # determine the tk instance and ctx to use: tk = current_engine.sgtk # loading a scene file new_path = os.path.abspath(os.path.join(scene_path, scene_name)) # this file could be in another project altogether, so create a new # API instance. try: tk = tank.tank_from_path(new_path) # and construct the new context for this path: ctx = tk.context_from_path(new_path, prev_context) except tank.TankError: try: ctx = current_engine.sgtk.context_from_entity_dictionary( current_engine.context.project) except tank.TankError: (exc_type, exc_value, exc_traceback) = sys.exc_info() message = "" message += "Shotgun Cinema Engine cannot be started:.\n" message += "Please contact you technical support team for more " message += "information.\n\n" message += "Exception: %s - %s\n" % (exc_type, exc_value) message += "Traceback (most recent call last):\n" message += "\n".join(traceback.format_tb(exc_traceback)) display_error(message) return # shotgun menu may have been removed, so add it back in if its not already # there. current_engine.create_shotgun_menu() if ctx != tank.platform.current_engine().context: current_engine.change_context(ctx)
def test_alternate_branch(self): """ Test path not from primary branch. """ os.mkdir(os.path.join(self.alt_root_1, "child_dir")) child_path = os.path.join(self.alt_root_1, "child_dir") result = tank.tank_from_path(child_path) self.assertIsInstance(result, Tank) self.assertEqual(result.project_path, self.project_root)
def get_tk_object(project): conf_data = ShotgunConfParser.sg_conf_data() api_script = conf_data.get("script_name") api_key = conf_data.get("api_key") root_pn = conf_data[project].get("root_pn") # connect to shotgun server tk_connect(api_script, api_key) # init a tk object return tank.tank_from_path(root_pn)
def test_primary_branch(self): """ Test path from primary branch. """ child_path = os.path.join(self.project_root, "child_dir") os.mkdir(os.path.join(self.project_root, "child_dir")) result = tank.tank_from_path(child_path) self.assertIsInstance(result, Tank) self.assertEquals(result.project_path, self.project_root)
def test_alternate_branch(self): """ Test path not from primary branch. """ os.mkdir(os.path.join(self.alt_root_1, "child_dir")) child_path = os.path.join(self.alt_root_1, "child_dir") result = tank.tank_from_path(child_path) self.assertIsInstance(result, Tank) self.assertEquals(result.project_path, self.project_root)
def test_from_path(self): """ Ensures tank_from_path will resolve site wide configs. """ os.environ["TANK_CURRENT_PC"] = self.pipeline_config_root try: result = tank.tank_from_path(self.project_root) self.assertEqual(result.project_path, self.project_root) self.assertEqual(result.pipeline_configuration.get_path(), self.pipeline_config_root) self._invalidate_pipeline_configuration_yml() with self.assertRaisesRegex( TankInitError, "however that is not associated with the pipeline configuration" ): tank.tank_from_path(self.project_root) finally: del os.environ["TANK_CURRENT_PC"]
def test_from_path(self): """ Ensures tank_from_path will resolve site wide configs. """ os.environ["TANK_CURRENT_PC"] = self.pipeline_config_root try: result = tank.tank_from_path(self.project_root) self.assertEquals(result.project_path, self.project_root) self.assertEquals(result.pipeline_configuration.get_path(), self.pipeline_config_root) self._invalidate_pipeline_configuration_yml() with self.assertRaisesRegexp( TankInitError, "however that is not associated with the pipeline configuration" ): tank.tank_from_path(self.project_root) finally: del os.environ["TANK_CURRENT_PC"]
def test_primary_branch(self): """ Test path from primary branch. """ child_path = os.path.join(self.project_root, "child_dir") os.mkdir(os.path.join(self.project_root, "child_dir")) result = tank.tank_from_path(child_path) self.assertIsInstance(result, Tank) self.assertEqual(result.project_path, self.project_root)
def get_tk_object( api_script="tank", api_key="f28b2d9918667f240426d33d3ce3ad4c9d589c9ccba6cc3db6c59aaa28403fb8", root_pn=r"Z:\Resource\Pipeline\app_config\settings\projects\df\sgtk\main" ): # connect to shotgun server tk_connect(api_script, api_key) # init a tk object return tank.tank_from_path(root_pn)
def test_from_path(self): """ Ensures tank_from_path will resolve site wide configs. """ os.environ["TANK_CURRENT_PC"] = self.pipeline_config_root try: result = tank.tank_from_path(self.project_root) self.assertEquals(result.project_path, self.project_root) self.assertEquals(result.pipeline_configuration.get_path(), self.pipeline_config_root) finally: del os.environ["TANK_CURRENT_PC"]
def getTankEntity(projPath): ''' Build a tank instance from project path :Params: projPath: str The path of project that tank defined :Returns: a tank instance ''' return tank.tank_from_path(projPath)
def __get_nuke_path(self): # Get the shotgun paths.yml file current_engine = sgtk.platform.current_engine() context = current_engine.context tk = tank.tank_from_path(context.tank.roots["primary"]) config_path = tk.pipeline_configuration.get_path() + "\\config\\env\\includes\\paths.yml" # use yaml to extract the path location with open(config_path, 'r') as yml_config_file: config_file = yaml.load(yml_config_file) nuke_path = config_file["nuke_windows"] return nuke_path
def __tank_startup_node_callback(): """ Callback that fires every time a node gets created. Carefully manage exceptions here so that a bug in Tank never interrupts the normal workflows in Nuke. """ try: # look for the root node - this is created only when a new or existing file is opened. tn = nuke.thisNode() if tn != nuke.root(): return if nuke.root().name() == "Root": # file->new # base it on the context we 'inherited' from the prev session # get the context from the previous session - this is helpful if user does file->new project_root = os.environ.get("TANK_NUKE_ENGINE_INIT_PROJECT_ROOT") tk = tank.Tank(project_root) ctx_yaml = os.environ.get("TANK_NUKE_ENGINE_INIT_CONTEXT") if ctx_yaml: try: new_ctx = yaml.load(ctx_yaml) except: new_ctx = tk.context_empty() else: new_ctx = tk.context_empty() else: # file->open file_name = nuke.root().name() try: tk = tank.tank_from_path(file_name) except tank.TankError, e: __create_tank_disabled_menu(e) return # try to get current ctx and inherit its values if possible curr_ctx = None if tank.platform.current_engine(): curr_ctx = tank.platform.current_engine().context new_ctx = tk.context_from_path(file_name, curr_ctx) # now restart the engine with the new context __engine_refresh(tk, new_ctx)
def __tank_startup_node_callback(): """ Callback that fires every time a node gets created. Carefully manage exceptions here so that a bug in Tank never interrupts the normal workflows in Nuke. """ try: # look for the root node - this is created only when a new or existing file is opened. tn = nuke.thisNode() if tn != nuke.root(): return if nuke.root().name() == "Root": # file->new # base it on the context we 'inherited' from the prev session # get the context from the previous session - this is helpful if user does file->new project_root = os.environ.get("TANK_NUKE_ENGINE_INIT_PROJECT_ROOT") tk = tank.Tank(project_root) ctx_str = os.environ.get("TANK_NUKE_ENGINE_INIT_CONTEXT") if ctx_str: try: new_ctx = tank.context.deserialize(ctx_str) except: new_ctx = tk.context_empty() else: new_ctx = tk.context_empty() else: # file->open file_name = nuke.root().name() try: tk = tank.tank_from_path(file_name) except tank.TankError, e: __create_tank_disabled_menu(e) return # try to get current ctx and inherit its values if possible curr_ctx = None if tank.platform.current_engine(): curr_ctx = tank.platform.current_engine().context new_ctx = tk.context_from_path(file_name, curr_ctx) # now restart the engine with the new context __engine_refresh(tk, new_ctx)
def __group_yeti_nodes(self, yetinodes): # define the group from the current shotgun ass scene_name = cmds.file(query=True, sn=True) tk = tank.tank_from_path(scene_name) templ = tk.template_from_path(scene_name) fields = templ.get_fields(scene_name) group_name = fields['Asset'] + "_yetiFurNodes_v" + str(fields['version']).zfill(3) # select the top group yeti nodes to maintain hierarchy nodes = [] for i in yetinodes: p = cmds.listRelatives(i, parent=True, fullPath=True) nodes.append(p[0].split('|')[1]) cmds.select(nodes) return cmds.group(cmds.ls(sl=True), name=group_name, relative=True)
def _get_context_from_script(self, script): """ Returns an sgtk.context.Context object from the given script path. :param script: The path to a script file on disk. """ tk = tank.tank_from_path(script) context = tk.context_from_path( script, previous_context=self.engine.context, ) if context.project is None: raise tank.TankError( "The Nuke engine needs at least a project " "context in order to start! Your context: %s" % context) else: return context
def shotgun_run_action(log, install_root, pipeline_config_root, is_localized, args): """ Executes the special shotgun run action command from inside of shotgun """ # we are talking to shotgun! First of all, make sure we switch on our html style logging log.handlers[0].formatter.enable_html_mode() log.debug("Running shotgun_run_action command") log.debug("Arguments passed: %s" % args) try: tk = tank.tank_from_path(pipeline_config_root) # attach our logger to the tank instance # this will be detected by the shotgun and shell engines # and used. tk.log = log except TankError, e: raise TankError("Could not instantiate an Sgtk API Object! Details: %s" % e )
def get_idA(objA=[]): """ Store asset ids :return: """ assetID_A = [] for x in objA: ass_path = cmds.getAttr(x + '.definition') tk_ref = tank.tank_from_path(ass_path) context_ref = tk_ref.context_from_path(ass_path) if context_ref: if context_ref.entity: if context_ref.entity.get('id'): assetID_A.append(int(context_ref.entity.get('id'))) return assetID_A
def _get_context_from_script(self, script): """ Returns an sgtk.context.Context object from the given script path. :param script: The path to a script file on disk. """ tk = tank.tank_from_path(script) context = tk.context_from_path( script, previous_context=self.engine.context, ) if context.project is None: raise tank.TankError( "The Nuke engine needs at least a project " "context in order to start! Your context: %s" % context ) else: return context
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ logger.debug("Refreshing the engine, previous context: '%r'", prev_context) current_engine = tank.platform.current_engine() if not current_engine: # If we don't have an engine for some reason then we don't have # anything to do. logger.debug( "No currently initialized engine found; aborting the refresh of the engine" ) return if pm.sceneName() == "": # This is a File->New call, so we just leave the engine in the current # context and move on. logger.debug("New file call, aborting the refresh of the engine.") return # determine the tk instance and ctx to use: tk = current_engine.sgtk # loading a scene file new_path = pm.sceneName().abspath() # this file could be in another project altogether, so create a new # API instance. try: tk = tank.tank_from_path(new_path) logger.debug("Extracted sgtk instance: '%r' from path: '%r'", tk, new_path) except tank.TankError, e: logger.exception("Could not execute tank_from_path('%s')" % new_path) OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e) # build disabled menu create_sgtk_disabled_menu(menu_name) return
def add_alembic_tag(): selection = libUtilities.get_selected() if selection: for node in selection: # Add the alembic Tag scene_name = cmds.file(query=True, sn=True) tk = tank.tank_from_path(scene_name) templ = tk.template_from_path(scene_name) fields = templ.get_fields(scene_name) asset_name = "assetNameOrShotStep" if "Asset" in fields: asset_name = fields["Asset"] elif "Shot" in fields: asset_name = fields["Step"] libUtilities.addStrAttr(node, 'Alembic') node.Alembic.set(asset_name) # Add the frame rate tag libUtilities.addAttr(node, "Step", 100, 0.0001, df=1) node.Step.setKeyable(False) node.Step.showInChannelBox(False) # Frame Relative Sample libUtilities.addBoolAttr(node, "RelativeFrameSample") node.RelativeFrameSample.setKeyable(False) node.RelativeFrameSample.showInChannelBox(False) libUtilities.addAttr(node, "RelativeLow", 100, -100, df=-.2) node.RelativeLow.setKeyable(False) node.RelativeLow.showInChannelBox(False) libUtilities.addAttr(node, "RelativeHigh", 100, -100, df=.2) node.RelativeHigh.setKeyable(False) node.RelativeHigh.showInChannelBox(False) libUtilities.addStrAttr(node, "WARNING") node.WARNING.set("DO NOT EDIT ANYTHING BELOW THIS ATTRIBUTE") node.WARNING.lock() libUtilities.addStrAttr(node, "ModelUsed") libUtilities.addStrAttr(node, "Namespace") else: libGUI.nothing_selected_box()
def _startup_node_callback(self): """ Callback that fires every time a node gets created. """ try: # Look for the root node. This is created only when a new or existing # file is opened. if nuke.thisNode() != nuke.root(): return if nuke.root().name() == "Root": # This is a file->new call, so base it on the context we # stored from the previous session. tk = tank.Tank(self.init_project_root) if self.init_context: new_ctx = self.init_context else: new_ctx = tk.context_empty() else: # This is a file->open call, so we can get the new context # from the file path that was opened. file_name = nuke.root().name() try: tk = tank.tank_from_path(file_name) except tank.TankError as e: self.engine.menu_generator.create_sgtk_disabled_menu(e) return new_ctx = tk.context_from_path( file_name, previous_context=self.context, ) # Now change the context for the engine and apps. self.change_context(new_ctx) except Exception: self.engine.menu_generator.create_sgtk_error_menu()
def _on_save_callback(self): """ Callback that fires every time a file is saved. """ try: # Get the new file name. file_name = nuke.root().name() try: # This file could be in another project altogether, so # create a new Tank instance. tk = tank.tank_from_path(file_name) except tank.TankError, e: self.engine.menu_generator.create_sgtk_disabled_menu(e) return # Extract a new context based on the file and change to that # context. new_context = tk.context_from_path( file_name, previous_context=self.context, ) self.change_context(new_context)
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ logger.debug("Refreshing the engine, previous context: '%r'", prev_context) current_engine = tank.platform.current_engine() if not current_engine: # If we don't have an engine for some reason then we don't have # anything to do. logger.debug("No currently initialized engine found; aborting the refresh of the engine") return if pm.sceneName() == "": # This is a File->New call, so we just leave the engine in the current # context and move on. logger.debug("New file call, aborting the refresh of the engine.") return # determine the tk instance and ctx to use: tk = current_engine.sgtk # loading a scene file new_path = pm.sceneName().abspath() # this file could be in another project altogether, so create a new # API instance. try: tk = tank.tank_from_path(new_path) logger.debug("Extracted sgtk instance: '%r' from path: '%r'", tk, new_path) except tank.TankError, e: logger.exception("Could not execute tank_from_path('%s')" % new_path) OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e) # build disabled menu create_sgtk_disabled_menu(menu_name) return
def _startup_node_callback(self): """ Callback that fires every time a node gets created. """ try: # Look for the root node. This is created only when a new or existing # file is opened. if nuke.thisNode() != nuke.root(): return if nuke.root().name() == "Root": # This is a file->new call, so base it on the context we # stored from the previous session. tk = tank.Tank(self.init_project_root) if self.init_context: new_ctx = self.init_context else: new_ctx = tk.context_empty() else: # This is a file->open call, so we can get the new context # from the file path that was opened. file_name = nuke.root().name() try: tk = tank.tank_from_path(file_name) except tank.TankError, e: self.engine.menu_generator.create_sgtk_disabled_menu(e) return new_ctx = tk.context_from_path( file_name, previous_context=self.context, ) # Now change the context for the engine and apps. self.change_context(new_ctx)
import os import sys sys.path.append('Z:/_CORE/Tank/tank/install/core/python') import tank import maya.cmds as cmds filePath = cmds.file(q=True, sn=True) dirPath = os.path.dirname(filePath) tk = tank.tank_from_path(dirPath) #ctx = tk.context_from_path(path) template_path = tk.templates['maya_shot_work'] data = template_path.get_fields(filePath) fields = { "Episode": "000_dummy", "Shot": "0000", "Step": "Track", "name": "awesomeTrack", "version": 1 } #print template_path.apply_fields(fields) #print tank.util.find_publish(tk,filePath) print tk.context_from_entity('TankPublishedFile', 32) #engine = tank.platform.start_engine('tk-maya', tk, ctx) #engine.init_app() #print tank.platform.current_engine()
def get_tk_object(api_script, api_key, root_pn): # connect to shotgun server tk_connect(api_script, api_key) # init a tk object return tank.tank_from_path(root_pn)
def run_engine_cmd(log, pipeline_config_root, context_items, command, using_cwd, args): """ Launches an engine and potentially executes a command. :param log: logger :param pipeline_config_root: PC config location :param context_items: list of strings to describe context. Either ["path"], ["entity_type", "entity_id"] or ["entity_type", "entity_name"] :param engine_name: engine to run :param command: command to run - None will display a list of commands :param using_cwd: Was the context passed based on the current work folder? """ log.debug("") log.debug("Context items: %s" % str(context_items)) log.debug("Command: %s" % command) log.debug("Command Arguments: %s" % args) log.debug("Sgtk Pipeline Config Location: %s" % pipeline_config_root) log.debug("Location of this script (__file__): %s" % os.path.abspath(__file__)) log.info("") log.info("Welcome to the Shotgun Pipeline Toolkit!") log.info("For documentation, see https://toolkit.shotgunsoftware.com") # Now create a tk instance and a context if possible ctx = None tk = None if len(context_items) == 1: # path mode: e.g. tank /foo/bar/baz # create a context given a path as the input ctx_path = context_items[0] if using_cwd: log.info("Starting Toolkit for your current path '%s'" % ctx_path) else: log.info("Starting toolkit for path '%s'" % ctx_path) # context str is a path if pipeline_config_root is not None: # we are running a project specific tank command tk = tank.tank_from_path(pipeline_config_root) else: # we are running a studio wide command try: tk = tank.tank_from_path(ctx_path) except TankError, e: # this path was not valid. That's ok - we just wont have a tank instance # when we run our commands later. This may be if we for example have # just run tank setup_project from any random folder log.debug("Instantiating Sgtk raised: %s" % e) if tk is not None: # # Right, there is a valid tk api handle, this means one of the following: # # - a project specific tank command guarantees a tk instance # # - a studio level tank command which is targetting a path # which belongs to a toolkit project # # It is possible that someone has launched a project specific # tank command with a path which is outside the project. # In this case, initialize this to have the project context. # We do this by attempting to construct a context and probing it ctx = tk.context_from_path(ctx_path) if ctx.project is None: # context could not be determined based on the path # revert back to the project context log.info("- The path is not associated with any Shotgun object.") log.info("- Falling back on default project settings.") project_id = tk.pipeline_configuration.get_project_id() ctx = tk.context_from_entity("Project", project_id)
elif context_items[1].isdigit(): # shotgun entity type and entity id! entity_type = context_items[0] entity_id = int(context_items[1]) # note - tank from path method will validate that we are launching # from the right tank command etc. tk = tank.tank_from_entity(entity_type, entity_id) ctx = tk.context_from_entity(entity_type, entity_id) elif pipeline_config_root is not None: # shotgun entity type and entity name and we are running a local tank command tk = tank.tank_from_path(pipeline_config_root) # now parse and resolve the entity name string entity_type = context_items[0] entity_search_token = context_items[1] project_id = tk.pipeline_configuration.get_project_id() entity_id = _resolve_shotgun_entity(log, entity_type, entity_search_token, project_id) ctx = tk.context_from_entity(entity_type, entity_id) else: # shotgun entity type and entity name and we are running a global tank command # now parse and resolve the entity name string entity_type = context_items[0] entity_search_token = context_items[1]
def test_project_setup(self, rw_dir, sg): # prepare the mock db - reuse the tank implementation as it's already what tank needs project = { 'type': 'Project', 'id': 1, 'sg_project_folder' : u'project_folder', 'sg_project_short_name' : 'testy', 'tank_name': None, # 'name': u'project_name_™äü' } // tank can't do unicode, but we can 'name': u'project_name' } local_storage = {'code' : constants.PRIMARY_STORAGE_NAME, 'mac_path' : str(rw_dir), 'linux_path' : str(rw_dir), 'windows_path' : str(rw_dir), 'id' : 1, 'type' : 'LocalStorage'} sg.set_entities([project, local_storage]) sg.set_server_info(version_tuple=(4, 3, 9)) for dummy in ('PublishedFile','PublishedFileType', 'PublishedFileDependency'): sg.set_entity_schema(dummy, dict()) # end for each dummmy sg.set_entity_schema('Project', dict((k, None) for k in project.keys())) stp = SetupTankProject() pb, wb = self._setup_bootstrapper_at(rw_dir, 'btank') config_uri = self._default_configuration_tree() patch_installer = SetupProjectPatcher() settings = DictObject({'bootstrapper' : {'host_path' : pb, # will work on all platforms in our case 'posix_symlink_path' : pb, 'windows_symlink_path' : wb, 'enforce_winlink_entry' : True, 'assume_smb_share' : False}, 'tank' : {'windows_python2_interpreter_path' : 'c:\\foo', 'configuration_uri': config_uri}}) location = stp.handle_project_setup(sg, log, DictObject(project), settings) assert location.isdir(), "expected a valid tank instance as return value" # If it's correct, folder structure should be doable. tk = tank.tank_from_path(location) tk.create_filesystem_structure(project['type'], project['id']) ############################## # Test Event Engine Plugin ## ############################ plugin = sgevents.TankProjectEventEnginePlugin(sg, log) ctx = bapp.main().context().push('project-setup-settings') ctx.settings().set_value_by_schema(setup_project_schema, settings) event = {'entity' : {'type' : 'Project', 'id' : project['id']}} event = DictObject(event) try: plugin.handle_event(sg, log, event) except OSError as err: assert err.errno == 17, "project directory can't be created as it exists"
# python import re import modo import tank scene = modo.scene.current() tk = tank.tank_from_path(r"w:\rts") temp = tk.template_from_path(scene.filename) assetName = temp.get_fields(scene.filename)['Asset'] matgrp = assetName + "(matgrp)" def createMatGrp(): allmats = [] groups = [] for shader in scene.items(itype="defaultShader"): if shader.parent.name == "Render": allmats.append(shader) for mat in scene.items(itype="mask"): if re.match(assetName, mat.name): allmats.append(mat) scene.deselect()
def refresh_engine(scene_name, prev_context): """ refresh the current engine """ engine = tank.platform.current_engine() if not engine: # If we don't have an engine for some reason then we don't have # anything to do. sys.stdout.write("refresh_engine | no engine!\n") return # This is a File->New call, so we just leave the engine in the current # context and move on. if scene_name in ("", "Untitled.spp"): if prev_context and prev_context != engine.context: engine.change_context(prev_context) # shotgun menu may have been removed, so add it back in if its not # already there. engine.create_shotgun_menu() return # determine the tk instance and ctx to use: tk = engine.sgtk # loading a scene file new_path = os.path.abspath(scene_name) # this file could be in another project altogether, so create a new # API instance. try: # and construct the new context for this path: tk = tank.tank_from_path(new_path) ctx = tk.context_from_path(new_path, prev_context) except tank.TankError, e: try: # could not detect context from path, will use the project context # for menus if it exists ctx = engine.sgtk.context_from_entity_dictionary( engine.context.project) message = ("Shotgun Substance Painter Engine could not detect " "the context\n from the project loaded. " "Shotgun menus will be reset \n" "to the project '%s' " "context." "\n" % engine.context.project.get('name')) engine.show_warning(message) except tank.TankError, e: (exc_type, exc_value, exc_traceback) = sys.exc_info() message = "" message += "Shotgun Substance Painter Engine cannot be started:.\n" message += "Please contact [email protected]\n\n" message += "Exception: %s - %s\n" % (exc_type, exc_value) message += "Traceback (most recent call last):\n" message += "\n".join(traceback.format_tb(exc_traceback)) # disabled menu, could not get project context engine.create_shotgun_menu(disabled=True) engine.show_error(message) return
elif context_items[1].isdigit(): # shotgun entity type and entity id! entity_type = context_items[0] entity_id = int(context_items[1]) # note - tank from path method will validate that we are launching # from the right tank command etc. tk = tank.tank_from_entity(entity_type, entity_id) ctx = tk.context_from_entity(entity_type, entity_id) elif pipeline_config_root is not None: # shotgun entity type and entity name and we are running a local tank command tk = tank.tank_from_path(pipeline_config_root) # now parse and resolve the entity name string entity_type = context_items[0] entity_search_token = context_items[1] project_id = tk.pipeline_configuration.get_project_id() entity_id = _resolve_shotgun_entity(log, entity_type, entity_search_token, project_id) ctx = tk.context_from_entity(entity_type, entity_id) else: # shotgun entity type and entity name and we are running a global tank command # now parse and resolve the entity name string entity_type = context_items[0]
def modoTk_AssetNameFromPath(): scene = modo.scene.current() tk = tank.tank_from_path(r"w:\rts") temp = tk.template_from_path(scene.filename) return temp.get_fields(scene.filename)['Asset']
import os import sys sys.path.append("Z:/_CORE/Tank/tank/install/core/python") import tank import maya.cmds as cmds filePath = cmds.file(q=True, sn=True) dirPath = os.path.dirname(filePath) tk = tank.tank_from_path(dirPath) # ctx = tk.context_from_path(path) template_path = tk.templates["maya_shot_work"] data = template_path.get_fields(filePath) fields = {"Episode": "000_dummy", "Shot": "0000", "Step": "Track", "name": "awesomeTrack", "version": 1} # print template_path.apply_fields(fields) # print tank.util.find_publish(tk,filePath) print tk.context_from_entity("TankPublishedFile", 32) # engine = tank.platform.start_engine('tk-maya', tk, ctx) # engine.init_app() # print tank.platform.current_engine()
import tank from maya import cmds path = cmds.file(q=True, sn=True) tk = tank.tank_from_path(path) ctx = tk.context_from_path(path) tank.platform.start_engine('tk-maya', tk, ctx)
def run_engine_cmd(log, pipeline_config_root, context_items, command, using_cwd, args): """ Launches an engine and potentially executes a command. :param log: logger :param pipeline_config_root: PC config location :param context_items: list of strings to describe context. Either ["path"], ["entity_type", "entity_id"] or ["entity_type", "entity_name"] :param engine_name: engine to run :param command: command to run - None will display a list of commands :param using_cwd: Was the context passed based on the current work folder? """ log.debug("") log.debug("Context items: %s" % str(context_items)) log.debug("Command: %s" % command) log.debug("Command Arguments: %s" % args) log.debug("Sgtk Pipeline Config Location: %s" % pipeline_config_root) log.debug("Location of this script (__file__): %s" % os.path.abspath(__file__)) log.info("") log.info("Welcome to the Shotgun Pipeline Toolkit!") log.info("For documentation, see https://toolkit.shotgunsoftware.com") # Now create a tk instance and a context if possible ctx = None tk = None if len(context_items) == 1: # path mode: e.g. tank /foo/bar/baz # create a context given a path as the input ctx_path = context_items[0] if using_cwd: log.info("Starting Toolkit for your current path '%s'" % ctx_path) else: log.info("Starting toolkit for path '%s'" % ctx_path) # context str is a path if pipeline_config_root is not None: # we are running a project specific tank command tk = tank.tank_from_path(pipeline_config_root) else: # we are running a studio wide command try: tk = tank.tank_from_path(ctx_path) except TankError, e: # this path was not valid. That's ok - we just wont have a tank instance # when we run our commands later. This may be if we for example have # just run tank setup_project from any random folder log.debug("Instantiating Sgtk raised: %s" % e) if tk is not None: # # Right, there is a valid tk api handle, this means one of the following: # # - a project specific tank command guarantees a tk instance # # - a studio level tank command which is targetting a path # which belongs to a toolkit project # # It is possible that someone has launched a project specific # tank command with a path which is outside the project. # In this case, initialize this to have the project context. # We do this by attempting to construct a context and probing it ctx = tk.context_from_path(ctx_path) if ctx.project is None: # context could not be determined based on the path # revert back to the project context log.info( "- The path is not associated with any Shotgun object.") log.info("- Falling back on default project settings.") project_id = tk.pipeline_configuration.get_project_id() ctx = tk.context_from_entity("Project", project_id)