def test_multiple_primaries(self): """ Ensures that a site-level primary is not considered for a shared-core for a project. """ self.mockgun.create( "PipelineConfiguration", { "code": "Primary", "mac_path": "/a/b/c", "windows_path": "C:\\b\\a", "linux_path": "/a/b/c" }) sgtk.sgtk_from_path(self.project_root) sgtk.sgtk_from_entity(self.project["type"], self.project["id"])
def test_multiple_primaries(self): """ Ensures that a site-level primary is not considered for a shared-core for a project. """ self.mockgun.create( "PipelineConfiguration", { "code": "Primary", "mac_path": "/a/b/c", "windows_path": "C:\\b\\a", "linux_path": "/a/b/c" } ) sgtk.sgtk_from_path(self.project_root) sgtk.sgtk_from_entity(self.project["type"], self.project["id"])
def create(sg, project_id, log, **kwargs): """ Insert post-project code here """ import sgtk tk = sgtk.sgtk_from_entity("Project", project_id) tk.create_filesystem_structure("Project", project_id)
def test_with_mixed_slashes(self): """ Check that a sgtk init works for this path """ # only run this test on windows if sys.platform == "win32": self.sg_pc_entity["windows_path"] = self.pipeline_config_root.replace("\\", "/") self.add_to_sg_mock_db(self.sg_pc_entity) self.add_to_sg_mock_db(self.project) self.add_to_sg_mock_db({ "type": "Shot", "id": 1, "project": self.project }) os.environ["TANK_CURRENT_PC"] = self.pipeline_config_root try: sgtk.sgtk_from_entity("Shot", 1) finally: del os.environ["TANK_CURRENT_PC"]
def execute(): try: step = sgtk.platform.current_bundle().get_setting("pipeline_step") context = sgtk.platform.current_engine().context currentShot = context.entity filters = [["project", "is", context.project], ["step", "name_contains", step], ['entity', 'is', currentShot]] fields = ['id'] result = sgtk.platform.current_engine().shotgun.find("Task", filters, fields) tk = sgtk.sgtk_from_entity("Task",result[0]["id"]) ctx = tk.context_from_entity("Task", result[0]["id"]) print "Changing context to " +str(ctx) sgtk.platform.change_context(ctx) except: #QtGui.QMessageBox.warning(None,"Force Shot-Step Context","tk-nuke-forceshotstep Could not switch context! Check to be sure that the nuke script is named correctly and that the current shot has a task in the work area defined in the configuration.") raise TankError("tk-nuke-forceshotstep Could not switch context! Check to be sure that the nuke script is named correctly and that the current shot has a task in the work area definted in the configuration.")
def execute(): try: step = sgtk.platform.current_bundle().get_setting("pipeline_step") context = sgtk.platform.current_engine().context currentShot = context.entity filters = [["project", "is", context.project], ["step", "name_contains", step], ['entity', 'is', currentShot]] fields = ['id'] result = sgtk.platform.current_engine().shotgun.find( "Task", filters, fields) tk = sgtk.sgtk_from_entity("Task", result[0]["id"]) ctx = tk.context_from_entity("Task", result[0]["id"]) print "Changing context to " + str(ctx) sgtk.platform.change_context(ctx) except: #QtGui.QMessageBox.warning(None,"Force Shot-Step Context","tk-nuke-forceshotstep Could not switch context! Check to be sure that the nuke script is named correctly and that the current shot has a task in the work area defined in the configuration.") raise TankError( "tk-nuke-forceshotstep Could not switch context! Check to be sure that the nuke script is named correctly and that the current shot has a task in the work area definted in the configuration." )
def test_task_id_list(sgwi): """query owner task assign """ import sgtk sg = sgwi.shotgun atk = sgtk.sgtk_from_entity("Project",cf.get_project_id()) user = sgtk.util.get_current_user(atk) filters = list() #["step.Step.code", "is", "Shading"] filters.append(['project', 'is', {'type': 'Project', 'id':cf.get_project_id() }]) #filters.append(["sg_status_list", "is", "ip"]) #filters.append(["task_assignees", 'is', {"type": "HumanUser", "id": 660, "name": "Texier Eric"}]) filters.append(["task_assignees", 'is', user]) fields = list(['code','task_assignees','sg_status_list']) sg_task = sg.find("Task",filters=filters,fields=fields) print len(sg_task) pprint(sg_task) for x in sg_task: if 'task_assignees' in x: for y in x['task_assignees']: print "INFO user", y['name'],y['id']
def _create(sg, project_id, log, **kwargs): """ Insert post-project code here - the default config does not require any post-session stuff. """ # create a folder structure for the project import sgtk tk = None try: tk = sgtk.sgtk_from_entity("Project", project_id) if tk: tk.create_filesystem_structure("Project", project_id) log.info("Created folder structure for the project") else: log.error("Could not create folder structure for the project") except TankError as e: log.error("Error creating folders for project: %s" % e) # query shotgun database for any shots or assets already created # create file structure for each entity if sg and tk: entities = [] assets = find_assets_or_spots(sg, project_id, "Assets") entities.extend(assets) spots = find_assets_or_spots(sg, project_id, "Spots") for spot in spots: shots = find_shots(sg, project_id, spot["id"]) entities.extend(shots) for entity in entities: print entity["type"], entity["code"], entity["id"] try: tk.create_filesystem_structure(entity["type"], entity["id"]) log.info("Created folders for %s %s %s" % (str(entity["type"]), str(entity["code"]), str(entity["id"]))) except TankError as e: log.error( "Error creating folders for %s %s %s - %s" % (str(entity["type"]), str(entity["code"]), str(entity["id"]), e) )
def _create(sg, project_id, log, **kwargs): """ Insert post-project code here - the default config does not require any post-session stuff. """ # create a folder structure for the project import sgtk tk = None try: tk = sgtk.sgtk_from_entity("Project", project_id) if tk: tk.create_filesystem_structure("Project", project_id) log.info("Created folder structure for the project") else: log.error("Could not create folder structure for the project") except TankError as e: log.error("Error creating folders for project: %s" % e) # query shotgun database for any shots or assets already created # create file structure for each entity if sg and tk: entities = [] assets = find_assets_or_spots(sg, project_id, "Assets") entities.extend(assets) spots = find_assets_or_spots(sg, project_id, "Spots") for spot in spots: shots = find_shots(sg, project_id, spot["id"]) entities.extend(shots) for entity in entities: print entity['type'], entity['code'], entity['id'] try: tk.create_filesystem_structure(entity['type'], entity['id']) log.info("Created folders for %s %s %s" % (str( entity['type']), str(entity['code']), str(entity['id']))) except TankError as e: log.error("Error creating folders for %s %s %s - %s" % (str(entity['type']), str( entity['code']), str(entity['id']), e))
ihdb.create_sequence(dbseq) print "INFO: Got sequence %s object from database with ID of %s."%(dbseq.g_seq_code, dbseq.g_dbid) dbshot = ihdb.fetch_shot(shot) if not dbshot: print "INFO: Creating new shot %s at path %s."%(shot, subbed_shot_dir) dbshot = DB.Shot(shot, subbed_shot_dir, -1, dbseq, None, mainplate_first, mainplate_first + 8, mainplate_last - 8, mainplate_last, mainplate_last - mainplate_first - 15) ihdb.create_shot(dbshot) # useful for creating thumbnails based on a plate, not on the latest comp b_newshot = True print "INFO: Got shot %s object from database with ID of %s."%(dbshot.g_shot_code, dbshot.g_dbid) # grab a toolkit object from the shot entity tk = sgtk.sgtk_from_entity('Shot', int(dbshot.g_dbid)) # retrive object from database for main plate mainplate_base = os.path.basename(plates[0]) dbplate = ihdb.fetch_plate(mainplate_base, dbshot) shot_thumb_dir = os.path.join(subbed_shot_dir, g_shot_thumb_dir.format(pathsep=os.path.sep)) b_new_shot_thumb = False existing_thumb_list = glob.glob(os.path.join(shot_thumb_dir, "%s_comp_v*.png"%shot)) if len(existing_thumb_list) == 0: print "INFO: No comp version thumbnails exist for shot %s in folder %s."%(shot, shot_thumb_dir) b_new_shot_thumb = True if not dbplate: print "INFO: Creating new plate %s for shot %s."%(mainplate_base, shot) plate_name = os.path.basename(plates[0])
def start_engine(self): engine = None try: import tank except Exception as e: print("ERROR: Failed to import tank.\n", file=sys.stderr) return engine # Defaults to tk-rv if no other engine name found in environment. engine_name = os.environ.get("TANK_ENGINE", "tk-rv") if os.environ.get("TANK_CONTEXT"): try: context = tank.context.deserialize( os.environ.get("TANK_CONTEXT")) except Exception as e: err = traceback.format_exc() print( "WARNING: Could not create context! Tank will be disabled: {0}" .format(traceback.format_exc()), file=sys.stderr, ) return engine else: import sgtk # if you want to force a Toolkit-style login, here's how: # # import tank_vendor.shotgun_authentication # sa = tank_vendor.shotgun_authentication.ShotgunAuthenticator() # sa.get_user_from_prompt() # user = sa.get_user() try: import slutils_py # Get default session info from slutils (rv/shotgun licensing) module (url, login, token) = slutils_py.defaultSession() user = ShotgunUser( RVUserImpl(url, login, token, ShotgunToolkit.http_proxy_from_env_vars())) sg_conn = user.create_sg_connection() sgtk.set_authenticated_user(user) # XXX what if previous session is not the server we want ? # XXX this forces restart if we fail here. we instead should # wait for login process to succeed and then continue. except: err = traceback.print_exc() commands.alertPanel( True, commands.ErrorAlert, "Login Session Invalid", "Login with RV Shotgun session token failed; please use the File Menu's " '"License Manager" to log in to the Shotgun server and re-start RV.', "Continue", None, None, ) return None projectName = "Big Buck Bunny" if os.environ.get("TANK_PROJECT_NAME"): projectName = os.environ.get("TANK_PROJECT_NAME") print("DEBUG: find project '%s'.\n" % projectName, file=sys.stderr) project = sg_conn.find("Project", [["name", "is", projectName]]) print("DEBUG: find result '%s'.\n" % str(project), file=sys.stderr) tk = sgtk.sgtk_from_entity(project[0]["type"], project[0]["id"]) context = tk.context_from_entity_dictionary(project[0]) try: print("INFO: Starting TK-RV Engine", sys.stderr) engine = tank.platform.start_engine(engine_name, context.tank, context) except Exception as e: print( "WARNING: Could not start engine: " "{0}".format(traceback.format_exc()), file=sys.stderr, ) return engine # clean up temp env vars for var in ["TANK_ENGINE", "TANK_CONTEXT", "TANK_FILE_TO_OPEN"]: if var in os.environ: del os.environ[var] return engine
def execute(self, shotgun_data, context, **kwargs): """ Gets executed just before a new publish entity is created in Shotgun. :param shotgun_data: All the data which will be passed to the shotgun create call :param context: The context of the publish :returns: return (potentially) modified data dictionary """ # default implementation is just a pass-through. print "before register publish hook" # get the toolkit api import sgtk tk = sgtk.sgtk_from_entity(shotgun_data['entity']['type'], shotgun_data['entity']['id']) path = shotgun_data['path']['local_path'] print path # this code should only be run for publish types: GeoCache and Render Sequence fields = ['code'] filters = [['id', 'is', shotgun_data['published_file_type']['id']]] tankTypeObj = tk.shotgun.find_one("PublishedFileType", filters, fields) tank_type = tankTypeObj['code'] if tank_type in ['GeoCache', 'Render Sequence']: # if it's a file we just grab the file name if os.path.isfile(path): shotgun_data['code'] = os.path.basename(path) # otherwise we need to create a name else: project = tk.shotgun.find_one( "Project", filters=[['id', 'is', shotgun_data['project']['id']]], fields=['tank_name']) projname = project['tank_name'] # extract additional fields from the path given template = tk.template_from_path(path) fields = template.get_fields(path) print fields if 'Shot' in fields: group = fields['Sequence'] entity = fields['Shot'] else: group = fields['sg_asset_type'] entity = fields['Asset'] name = fields['name'] step = fields['Step'] # update the code field, i.e. published file name, with something better than default folder name if tank_type == "GeoCache": type = "geocache" elif tank_type == "Render Sequence": type = fields["render_type"] shotgun_data['code'] = "%s-%s-%s_%s-%s_%s" % ( projname, group, entity, name, step, type) # for some reason shotgun processes paths for publishes that is not sequences in a special way # and the easiest way to make this work is to convert all paths to '\\' sgPath = path.replace('/', '\\') shotgun_data['path']['local_path'] = sgPath print shotgun_data return shotgun_data
def _get_published_file_from_entity(self, entity_type, entity_id): """ Return the published file associated with the given entity. Supported entity types: the published entity type defined by the pipeline configuration, "Version" and "Playlist". published entity type: The object for `entity_type` and `entity_id` will be returned. "Version": The published file with the highest version will be returned "Playlist": No published file object will be returned :param entity_type: The entity type :param entity_id: The entity id """ published_file = None published_file_entity_type = sgtk.util.get_published_file_entity_type( self.sgtk) if entity_type == published_file_entity_type: published_file = self.shotgun.find_one( published_file_entity_type, [["id", "is", entity_id]], fields=["id", "path"], ) elif entity_type == "Version": filters = [["version", "is", {"type": "Version", "id": entity_id}]] # Attempt to get the filter for Published File Types from the tk-vred engine settings. If an error # occurs, or no such settings was found, Published Files of any type will be queried. try: tk = sgtk.sgtk_from_entity(self.context.project["type"], self.context.project["id"]) env = sgtk.platform.engine.get_environment_from_context( tk, self.context) engine_settings = env.get_engine_settings("tk-vred") accepted_published_file_types = engine_settings.get( "accepted_published_file_types") if accepted_published_file_types: filters.append([ "published_file_type.PublishedFileType.code", "in", accepted_published_file_types, ]) except Exception as error: self.logger.warning( "Failed to retrieve 'accepted_published_file_types' filter setting. Retrieving Published Files of any type.\n\n{e}" .format(e=error)) # Retrieve the lastest Published File (highest version) for this Version published_files = self.shotgun.find( published_file_entity_type, filters, fields=["id", "path", "published_file_type"], order=[{ "field_name": "version_number", "direction": "desc" }], ) if not published_files: published_file = { "error": "Version has no published files to load for review." } elif len(published_files) != 1: published_file = { "error": "Failed to load Version for review with VRED because there is more than one PublishedFile entity with the same PublishedFileType associated for this Version." } else: published_file = published_files[0] elif entity_type == "Playlist": # TODO get the last added version to the playlist and open the associatd published file # This requires opening SG Panel with a Playlist context, and then switching to the # Version to automatically start reviewing published_file = {} else: # Unsupported entity type, return error inside dictionary result published_file = { "error": "Sorry, this app only works with entities of type {}, Version or Playlist." .format(published_file_entity_type) } return published_file
commands.alertPanel( True, commands.ErrorAlert, "Login Session Invalid", "Login with RV Shotgun session token failed; please use the File Menu's " "\"License Manager\" to log in to the Shotgun server and re-start RV.", "Continue", None, None) return None projectName = 'Big Buck Bunny' if os.environ.get('TANK_PROJECT_NAME'): projectName = os.environ.get('TANK_PROJECT_NAME') sys.stderr.write("DEBUG: find project '%s'.\n" % projectName) project = sg_conn.find("Project", [["name", "is", projectName]]) sys.stderr.write("DEBUG: find result '%s'.\n" % str(project)) tk = sgtk.sgtk_from_entity(project[0]["type"], project[0]["id"]) context = tk.context_from_entity_dictionary(project[0]) try: sys.stderr.write("INFO: Starting TK-RV Engine") engine = tank.platform.start_engine(engine_name, context.tank, context) except Exception, e: sys.stderr.write("WARNING: Could not start engine: " "{0}".format(traceback.format_exc())) return engine # clean up temp env vars for var in ["TANK_ENGINE", "TANK_CONTEXT", "TANK_FILE_TO_OPEN"]: if var in os.environ:
def execute(self, shotgun_data, context, **kwargs): """ Gets executed just before a new publish entity is created in Shotgun. :param shotgun_data: All the data which will be passed to the shotgun create call :param context: The context of the publish :returns: return (potentially) modified data dictionary """ # default implementation is just a pass-through. print "before register publish hook" # get the toolkit api import sgtk tk = sgtk.sgtk_from_entity(shotgun_data['entity']['type'],shotgun_data['entity']['id']) path = shotgun_data['path']['local_path'] print path # this code should only be run for publish types: GeoCache and Render Sequence fields = ['code'] filters = [['id','is',shotgun_data['published_file_type']['id']]] tankTypeObj = tk.shotgun.find_one("PublishedFileType", filters, fields) tank_type = tankTypeObj['code'] if tank_type in ['GeoCache', 'Render Sequence']: # if it's a file we just grab the file name if os.path.isfile(path): shotgun_data['code'] = os.path.basename(path) # otherwise we need to create a name else: project = tk.shotgun.find_one("Project", filters=[['id', 'is', shotgun_data['project']['id']]], fields=['tank_name']) projname = project['tank_name'] # extract additional fields from the path given template = tk.template_from_path(path) fields = template.get_fields(path) print fields if 'Shot' in fields: group = fields['Sequence'] entity = fields['Shot'] else: group = fields['sg_asset_type'] entity = fields['Asset'] name = fields['name'] step = fields['Step'] # update the code field, i.e. published file name, with something better than default folder name if tank_type == "GeoCache": type = "geocache" elif tank_type == "Render Sequence": type = fields["render_type"] shotgun_data['code'] = "%s-%s-%s_%s-%s_%s"%(projname,group,entity,name,step,type) # for some reason shotgun processes paths for publishes that is not sequences in a special way # and the easiest way to make this work is to convert all paths to '\\' sgPath = path.replace('/', '\\') shotgun_data['path']['local_path'] = sgPath print shotgun_data return shotgun_data