def published_file_query_one(cls, project_id, entity_publish_id, query_fields=PfInfoDb.PFS, call_default=pf_default, conn=None): """ :param project_id: project_id :param entity_publish_id: int or -1 :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = list() if project_id != -1: filters.append( ['project', 'is', { 'type': 'Project', 'id': project_id }]) filters.append(['id', 'is', entity_publish_id]) res = conn.find_one('PublishedFile', filters=filters, fields=query_fields) if res != None: return [call_default(res)] return list()
def playlist_query_versions(cls, project_id=-1, conn=None): """Return list of shotgun playlist info relative to a project :param project_id: project id :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = list() if project_id != -1: filters.append( ['project', 'is', { 'type': 'Project', 'id': project_id }]) fields = ScreenRoomInfoDb.PLF #fields = [] res = conn.find('Playlist', filters=filters, fields=fields, order=[{ 'field_name': 'created_at', 'direction': 'desc' }]) result = list() for x in res: # lot of playlist are empty so with filter them out here vers = x.get('versions', list()) if len(vers) > 0: result.append(screenroom_default(x)) return result
def db_group_user(project_name, group_name, conn=None): """Filter through the group :param conn: the active shotgun connection, default None :param project_name: what show :param group_name: name of a shotgun group :return : list of users in shotgun group """ # set variables user_list = list() # Get sg conn if conn == None: conn = connect_to_shotgun() # Get users from group groups = conn.find_one('Group', [['code', 'is', group_name]], ['users']) if groups and 'users' in groups: users = groups['users'] else: return user_list for user in users: # Get user_name user_name = user['name'] # Get sg human user from user_name human_user = conn.find_one('HumanUser', [['name', 'is', user_name]], ['login']) if human_user != []: # Get email login = human_user['login'] # Append email to email_list user_list.append(login) return user_list
def get_lasted_version_for_show(cls, showid, query_field, limit=10, conn=None): """Return a list a limit number of the last version for a show :param showid: a show id :param query_field: see VersionInfoDb.VC :param limit: a number to get how many :param conn: a shotgun connection """ if conn is None: conn = connect_to_shotgun() status_list_except = ['qd', 'sbmt', 'fld'] filters = [['project', 'is', {'type': 'Project', 'id': showid}]] filters.append(('sg_status_list', 'not_in', status_list_except)) order = [{'direction': 'desc', 'field_name': 'id'}] res = conn.find('Version', filters, query_field, order, limit=limit) result = list() for x in res: v = version_default(x) result.append(v) return result
def query_shot_media_versions(project_id, shot_id, query_field, version_type=None, conn=None): """Return list of version info relative to a shot :param project_id: a valid project id :param shot_id: a valid shot id :param query_field: the field to query :param version_type: a list of version type :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = [['project', 'is', {'type': 'Project', 'id': project_id}]] filters.append(['entity', 'is', {'type': 'Shot', 'id': shot_id}]) if version_type != None: filters.append(["sg_version_type", 'in', version_type]) res = conn.find('Version', filters=filters, fields=query_field, order=[{ 'field_name': 'id', 'direction': 'desc' }]) result = list() for x in res: v = version_default(x) result.append(v) return result
def user_info_with_id(conn=None, call_default=user_default): # Get sg conn if conn == None: conn = connect_to_shotgun() res = conn.find('HumanUser', [], UserInfoDb.UF) res = [call_default(x) for x in res] return filter(lambda x: x != None, res)
def query_asset_media_latest(cls, show_id, asset_id, query_field, version_type, conn=None): """Return list of the lasted version for each type for asset :param project_id: a valid project id :param shot_id: a valid shot id :param query_field: the field to query :param version_type: a list of version type :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = [['project', 'is', {'type': 'Project', 'id': show_id}]] filters.append(['entity', 'is', {'type': 'Asset', 'id': asset_id}]) if version_type: filters.append(['sg_version_type', 'in', version_type]) result = cls._summary_asset_version(conn, filters, query_field) return result
def get_conn(cls): """Create and store a shotgun api connection """ if cls.__Conn == None: try: cls.__Conn = connect_to_shotgun() except: cls.__Conn = None return cls.__Conn
def show_id_by_name(conn, project_name): """find one show from tank_name :param conn: a shotgun connection, default None :param project_name: tank_name for the show :return project entity dict: """ if conn == None: conn = connect_to_shotgun() return conn.find_one("Project", [['tank_name', 'is', project_name]], None)
def db_user(conn=None, fields=['login', 'firstname', 'lastname']): """Query user information :param conn: the active shotgun connection, default None :param fields: a list of field. optional default=['login','firstname','lastname'] """ # Get sg conn if conn == None: conn = connect_to_shotgun() return conn.find('HumanUser', [], fields)
def entity_asset_query_versions(cls, project_id, entity_asset_id, file_type_list_id=None, call_default=pf_default, conn=None): """Return a list of publishFiled sorted with version number for asset :param project_id: project_id :param entity_asset_id: a asset id :param file_type_list_id: a list of file_type_id :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = list() if project_id != -1: filters.append( ['project', 'is', { 'type': 'Project', 'id': project_id }]) if entity_asset_id != -1: filters.append( ['entity', 'is', { 'type': 'Asset', 'id': entity_asset_id }]) if len(file_type_list_id) > 0: filters.append([ "published_file_type.PublishedFileType.id", "in", file_type_list_id ]) query_fields = PfInfoDb.PFS res = conn.find('PublishedFile', filters=filters, fields=query_fields, order=[{ 'field_name': 'version_number', 'direction': 'desc' }]) result = list() for x in res: v = call_default(x) if v: result.append(v) return result
def step_list_with_id(conn=None, call_default=step_default): """ departments are not show dependent return a list of StepIndfoDb """ if conn == None: conn = connect_to_shotgun() res = conn.find('Step', [], StepInfoDb.SF) # clean when label = is blank or "-" res = filter(lambda x: not x['short_name'] in ['', None, '-'], res) res = filter(lambda x: not x['code'] in ['', None, '-'], res) return [call_default(x['code'], x['id'], x) for x in res]
def pipeline_config_with_id(show_id, call_default=pipeconfig_default, conn=None): """query owner task assign """ if conn == None: conn = connect_to_shotgun() filters = list() filters.append(['project', 'is', {'type': 'Project', 'id': show_id}]) fields = PipeConfigInfoDb.PCF res = conn.find("PipelineConfiguration", filters, fields) res = [call_default(x) for x in res] return filter(lambda x: x != None, res)
def list_version_status(conn=None): """List all the possible the version status :param conn: the active shotgun connection, default None example:: from dsk.base.db_helper.db_helper_funct import ShotgunQuery ShotgunQuery.list_version_status() """ if conn is None: conn = connect_to_shotgun() X = conn.schema_field_read('Version') return X['sg_status_list']['properties']['valid_values']['value']
def download_icon(image_url, dest, conn=None): """Download an image from the server to local disk :param image_url: a valid address for the image :param dest: a fullpath to image on disk. directory needs to exist :return : bool, True if success """ from sgtk.util.shotgun import download_url if conn is None: conn = connect_to_shotgun() try: download_url(conn, image_url, dest) except: return False return True
def dept_list_with_id(conn=None, call_default=dept_default): """ departments are not show dependent return a list of DeptIndfoDb """ if conn == None: conn = connect_to_shotgun() res = conn.find( 'Department', [], # not project specific ['code', 'name', 'id', 'department_type']) return [ call_default(x['code'], x['id'], x['department_type'], x['name']) for x in res ]
def fpt_by_name(cls, call_default=pft_default, conn=None): """Query for PublishedFileType :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() ft = conn.find("PublishedFileType", [["sg_status_list", "is", "act"]], PftInfoDb.PFT) result = list() for f in ft: v = call_default(f) if v: result.append(v) return result
def asset_list_with_id(show_id, conn=None, call_default=asset_default): """ return all asset for a given show """ if conn == None: conn = connect_to_shotgun() bad_statuses = ['omt'] res = conn.find('Asset', [['project', 'is', { 'type': 'Project', 'id': show_id }], ['sg_status_list', 'not_in', bad_statuses]], ['code', 'sg_asset_type', 'sg_status_list']) return [ call_default(x['code'], x['id'], x['sg_asset_type'], x['sg_status_list']) for x in res ]
def step_names(conn=None): """ from shotgun utils Returns a list of short names for the Step, e.g. 'anm' for 'Animation' etc. return dept_shorts a list of Step short names. """ if conn == None: conn = connect_to_shotgun() res = conn.find('Step', [], ['code']) res = [x['code'] for x in res] # remove duplicate res = list(set(res)) res.sort() return res
def asset_id_by_code(conn, project_id, asset_list_code): """query a asset list dictionary :param conn: a shotgun connection, default None :param asset_list_code: list of asset code :param project_id: project id :return list: list of shot entity dict """ if conn == None: conn = connect_to_shotgun() list_id = list() for s in asset_list_code: list_id.append( conn.find_one( 'Asset', [['code', 'is', s], ['project', 'is', project_id]], None)) return list_id
def filter_fpt_by_name(cls, list_of_short_name, call_default=pft_default, conn=None): if conn == None: conn = connect_to_shotgun() if isinstance(list_of_short_name, basestring): list_of_short_name = [list_of_short_name] ft = conn.find("PublishedFileType", [["short_name", "in", list_of_short_name], ["sg_status_list", "is", "act"]], PftInfoDb.PFT) result = list() for f in ft: v = call_default(f) if v: result.append(v) return result
def _summary_shot_media_version(cls, conn, filters, query_field): """Call summary to get the lasted, see query_shot_media_latest :param conn: a shotgun connection :param filters: a filter list :param query_field: the field to query """ if conn == None: conn = connect_to_shotgun() filters.append(['entity', 'type_is', 'Shot']) summary = conn.summarize('Version', filters, summary_fields=[{ 'field': 'id', 'type': 'maximum' }], grouping=[{ 'field': 'entity', 'type': 'exact', 'direction': 'asc' }, { 'field': 'sg_version_type', 'type': 'exact', 'direction': 'asc' }]) ver_id_list = [] if summary.has_key('groups'): for shot_summary in summary['groups']: if shot_summary.has_key('groups'): for v in shot_summary['groups']: ver_id_list.append(v['summaries']['id']) if len(ver_id_list) == 0: return ver_id_list res = conn.find('Version', [['id', 'in', ver_id_list]], query_field) result = list() for x in res: v = version_default(x) result.append(v) return result
def query_settings(cls, project_id, conn=None): """Return list of setting info relative to a project """ if conn == None: conn = connect_to_shotgun() filters = list() filters.append( ['project', 'is', { 'type': 'Project', 'id': project_id }]) fields = SettingsInfoDb.SF res = conn.find(cls._settings["project_settings"], filters=filters, fields=fields) result = list() for x in res: result.append(settings_default(x)) return result
def shots_with_id(show_id, shot_names, conn=None, call_default=shot_default): """ return a list of shot for a given show and code list """ if conn == None: conn = connect_to_shotgun() bad_statuses = ['omt'] res = conn.find('Shot', [['project', 'is', { 'type': 'Project', 'id': show_id }], ["code", "in", shot_names], ['sg_status_list', 'not_in', bad_statuses]], ['code', 'sg_cut_order', 'assets', 'sg_status_list']) return [ call_default(x['code'], x['id'], x['sg_cut_order'], x['assets'], x['sg_status_list']) for x in res ]
def search_video_version_query(conn, project_id, entity_list, submit_login_list=None, status_list=None, version_type=VersionInfoDb.VC, fields=VersionInfoDb.VF, limit=10): """Search the version matching a certain criteria (not finish) :param project_id: a project id :param entity_list: a list of entity id :param submit_login_list: :param entity_list: can provide directly the entity list, otherwise it will be derived from the entity type and code """ if conn == None: conn = connect_to_shotgun() filters = [('sg_version_type', 'in', version_type), ('project', 'is', project_id), ('entity', 'is_not', None)] filters.append(('entity', 'in', entity_list)) if submit_login_list: filters.append(('sg_login', 'in', submit_login_list)) if status_list: filters.append(('sg_status_list', 'in', status_list)) res = conn.find('Version', filters=filters, fields=fields, order=[{ 'field_name': 'created_at', 'direction': 'desc' }], limit=limit) return res
def published_file_query(cls, project_id, entity_publish_id, query_fields=PfInfoDb.PFS, call_default=pf_default, conn=None): """shogun api find PublishedFile :param project_id: project_id :param entity_publish_id: entity_publish_id: int, list of id or -1 :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = list() if project_id != -1: filters.append( ['project', 'is', { 'type': 'Project', 'id': project_id }]) if isinstance(entity_publish_id, list): filters.append(['id', 'in', entity_publish_id]) elif entity_publish_id != -1: filters.append([ 'entity', 'is', { 'type': 'PublishedFile', 'id': entity_publish_id } ]) res = conn.find('PublishedFile', filters=filters, fields=query_fields) result = list() for x in res: v = call_default(x) result.append(v) return result
def get_current_projects(cls, conn=None, tank_names=None, call_default=show_default): """ return all the current project, tank_names can be a list of show """ result = list() if conn == None: conn = connect_to_shotgun() prj = cls.project_list(conn, tank_names) for k in prj: if k['tank_name'] in CurrentProjects: result.append(call_default(k['tank_name'], k['id'], k['name'])) elif k['name'] != None and not k[ 'tank_name'] in IgnoreProject and not 'emplate' in k[ 'name']: if k['tank_name'] != None: result.append( call_default(k['tank_name'], k['id'], k['name'])) return result
def tasks_by_name(cls, project_id, call_default=task_default, conn=None): """Query for Tash :param conn: a shotgun connection, default None """ if conn == None: conn = connect_to_shotgun() filters = list() filters.append( ['project', 'is', { 'type': 'Project', 'id': project_id }]) fields = list(['code', 'task_assignees', 'sg_status_list']) res = conn.find("Task", filters=filters, fields=fields) result = list() for f in res: v = call_default(f) if v: result.append(v) return result
import pytest import os from dsk.base.db_helper.shotgun_script import connect_to_shotgun from dsk.base.db_helper.db_cache import DbCache from dsk.base.db_helper.db_helper_funct import ShotgunQuery as SQ from dsk.base.resources.get_pix_version import get_pixmap from dsk.shot_info.resources.icon_gen_mt import IconGenQueue from dsk.base.db_helper.version_info_db import VersionInfoDb from dsk.shot_info.resources.shotinfo_constant import TEMP_ICON_DIRECTORY,BASE_RES from dsk.base.utils.time_utils import StopWatch conn = connect_to_shotgun() @pytest.mark.skipif(True, reason="too long") def test_media(): dbc = DbCache(shot_only=True, asset_only=False) showobj = dbc.get_showobj('dev_show') VER_TYPE = None shot_list = dbc.load_shot('dev_show',['125_3600', '007_0300','036_0200', '110_0500','036_1100', '125-4500']) for shotobj in shot_list: res = dbc.update_media_version_shot_info(showobj, shotobj, VER_TYPE, force = True) for x in res: