def query_depend_fp(self, db, showobj, file_selected):
from dsk.base.db_helper.db_helper_funct import ShotgunQuery as SQ
result = None
if db is None or showobj is None:
return result
for x in self.downstream_published_files:
if x['name'] == file_selected:
entity_publish_id = x['id']
result = SQ.published_file_query_one(showobj.id,
entity_publish_id,
conn=db.get_conn())
if len(result) == 1:
return result[0]
return None
for x in self.upstream_published_files:
if x['name'] == file_selected:
entity_publish_id = x['id']
result = SQ.published_file_query_one(showobj.id,
entity_publish_id,
conn=db.get_conn())
if len(result) == 1:
return result[0]
return None
return result
def test_get_devshow():
a = ShotgunQuery.show_id_by_name(conn, 'dev_show')
assert 'id' in a
shotlist = ShotgunQuery.shot_list_with_id(a['id'], conn)
assert len(shotlist) > 0
assetList = ShotgunQuery.asset_list_with_id(a['id'], conn)
assert len(assetList) > 0
def update_media_version_shot_info(self,
showobj,
shotobj,
version_type=None,
force=True):
"""Version stuff for asset
:param showobj: ShowInfoDb object
:param shotobj: ShotInfoDb object
:param version_type: default None, a list of version type
example: ['deadlineNukeRender', 'publishedNukeRender']
:param force: bool force the query
"""
if force == False and shotobj.is_version_set():
return shotobj.get_media_version()
#steplist = map(lambda x: x ,filter(lambda x: x.active == True,steplist))
res = list()
if showobj.id != -1 and shotobj.id != -1:
res = SQ.query_shot_media_versions(showobj.id,
shotobj.id,
VersionInfoDb.VF,
version_type=version_type,
conn=self.get_conn())
versions = shotobj.set_media_version(res)
return versions
def load_asset_if_not(self, db, asset_names):
"""Load none asset loaded into show
:param:
asset_names (list/str): a valid code name for asset
"""
from dsk.base.db_helper.db_helper_funct import ShotgunQuery as SQ
if isinstance(asset_names, basestring):
asset_names = [asset_names]
assets = self.get_assets()
in_all_ready = assets.childNames()
to_query = list()
all_ready_there = list()
for s in asset_names:
if s not in in_all_ready:
to_query.append(s)
else:
ch = assets.getChildByName(s)
if ch is None:
log.error("cannot retrieve asset: %s", s)
else:
all_ready_there.append(ch)
asset_list = list()
if len(to_query) > 0:
asset_list = SQ.assets_with_id(self.id, to_query, db.get_conn())
self.init_with_assets(asset_list)
return asset_list + all_ready_there
def update_media_version_asset_info(self,
showobj,
assetobj,
version_type=None,
force=False):
"""Version stuff for asset
:param showobj: ShowInfoDb object
:param assetobj: AssetInfoDb object
:param version_type: default None, a list of version type
example: ['deadlineNukeRender', 'publishedNukeRender']
:param force: bool force the query
"""
if force == False and assetobj.is_version_set():
return assetobj.get_media_version()
res = list()
if showobj.id != -1 and assetobj.id != -1:
res = SQ.query_asset_media_versions(showobj.id,
assetobj.id,
VersionInfoDb.VF,
version_type=version_type,
conn=self.get_conn())
versions = assetobj.set_media_version(res)
return versions
def test_file_type_filter():
ft = SQ.filter_fpt_by_name('maya_model_file', conn=conn)
for f in ft:
print("--------->", f.getName(), pformat(f))
dbc = DbCache()
print(pformat(dbc.get_file_type_names()))
def cache_file_type(self):
"""Build a dico to map short_name filetype to name
"""
ft = SQ.fpt_by_name(conn=self.get_conn())
fpt = self['FPT']
for f in ft:
fpt.addChild(f)
fpt.cache()
def get_lasted_version_for_show(self, showobj, limit=10):
"""Return a list a limit number of the last version for a show
No cache for now
"""
res = SQ.get_lasted_version_for_show(showobj.id,
VersionInfoDb.VF,
limit=limit,
conn=self.get_conn())
return res
def set_show(self, show_name, seq_name=""):
"""Set show: load all the assets and/or shots"""
if show_name in self.get_show_names():
showobj = self['Shows'][show_name]
if showobj.get_sequences().nbOfChildren(
) == 0 and self._asset_only == False:
showobj.init_with_shots(
sorted(SQ.shot_list_with_id(showobj.id, self.get_conn()),
ShotInfoDb.compare))
if seq_name != None:
showobj.set_current_sequence(seq_name)
else:
showobj.set_current_sequence("")
if showobj.get_assets().nbOfChildren(
) == 0 and self._shot_only == False:
showobj.init_with_assets(
sorted(SQ.asset_list_with_id(showobj.id, self.get_conn()),
AssetInfoDb.compare))
self._currentshow = show_name
return True
return False
def test_db_cache_shot_devshow():
dbc = DbCache(shot_only=False, asset_only=False)
dbc.init_with_current_shows()
dbc.set_show("dev_show")
showobj = dbc.get_current_show_obj()
assert showobj
assert len(showobj.get_assetlist_names()) != 0
# sequence
ids = list()
seqs = showobj.get_sequences()
pformat(dbc.get_file_type_names())
VER_TYPE = None #['deadlineNukeRender', 'deadlineMayaRender']
#fts = SQ.filter_fpt_by_name(VER_TYPE,conn=dbc.get_conn())
for seq in seqs.getChildren():
#print(seq.getName(),seq.get_shot_names())
for shotobj in seq.getChildren():
#print("shotname",shotobj.getName(),"show id", showobj.id, "shot id", shotobj.id)
#ids.append(shotobj)
res = dbc.update_media_version_shot_info(showobj,
shotobj,
VER_TYPE,
force=True)
print("nb of shot version", len(res))
ver_type = [x.getName() for x in res]
ver_type = filter(lambda x: x != "No_Type", ver_type)
#if ver_type:
if 0:
print(ver_type)
res2 = ShotgunQuery.query_shot_media_latest(
showobj.id, shotobj.id, VersionInfoDb.VF, ver_type)
# asset
#print "xxxx"
assets = showobj.get_assets()
#print "xxxx",assets
for assetobj in assets.getChildren():
#print assetobj
#print "assetname",assetobj.getName(),"show id", showobj.id, "asset id", assetobj.id
ids.append(assetobj)
res = dbc.update_media_version_asset_info(showobj, assetobj, VER_TYPE)
print "nb of asset version", len(res)
ver_type = [x.getName() for x in res]
ver_type = filter(lambda x: x != "No_Type", ver_type)
print ver_type
"""
def _do_users(self):
""" query and cache step info
"""
SW.start()
conn = self.get_conn()
if self.verbose:
log.warning("login to shotgun, to get user")
step = SQ.user_info_with_id(conn=conn)
parent = self['Users']
for s in step:
parent.addChild(s, withRename=False)
SW.stop()
if self.verbose:
log.info("user_query in {}".format(SW.elapsed()))
def init_with_current_shows(self, with_shotgun=True):
"""Initialisation of shows
:param with_shotgun: default True, will load all the show in shotgun
(minus an exception list) if False load the show define in envi_info instead
:note: only show header are read... id, sgtk_name, no other data
"""
s = self['Shows']
if with_shotgun == True:
conn = self.get_conn()
cpl = SQ.get_current_projects(conn=conn)
for cp in cpl:
s.addChild(cp)
else:
conn = self.get_conn()
from dskenv.api.dsk_studio import DskStudio
envi_info = DskStudio()
envi_info.reset(os.environ.get(dskenv_constants.DSK_ENV_PATH_KEY))
envi_info.load_data()
sgtks_names = envi_info.get_projects()
cpl = SQ.get_current_projects(conn=conn, sgtk_names=sgtks_names)
for cp in cpl:
s.addChild(cp)
def get_current_confpipe(self, db=None):
"""Set to the first found"""
if self._current_configpipe == "":
ass = self.get_configpipe()
if ass.nbOfChildren() > 0:
cas = ass.getChildren()[0]
self._current_configpipe = cas.getName()
elif db:
from dsk.base.db_helper.db_helper_funct import ShotgunQuery
res = ShotgunQuery.pipeline_config_with_id(self.id,
conn=db.get_conn())
self.init_with_pipeline_config(res)
ass = self.get_configpipe()
if ass.nbOfChildren() > 0:
cas = ass.getChildren()[0]
self._current_configpipe = cas.getName()
return self._current_configpipe
def get_usertask_list(self, db, userlogin):
from dsk.base.db_helper.db_helper_funct import ShotgunQuery as SQ
user = db.get_user_dict(userlogin)
res = list()
if user:
ch = self['TaskAssign'].getChildren()
if len(ch) == 0:
task_list = SQ.tasks_by_name(self.id, conn=db.get_conn())
self.init_with_Task(task_list)
ch = self['TaskAssign'].getChildren()
idu = int(user['id'])
for x in ch:
if idu in x.assigned_ids():
res.append("%s" % x.id)
return list(set(res))
def assetid_filepub_query(self, showobj, assetid, file_type_list):
"""
:param showobj:
:param assetid:
:param file_type_list: (list) pft Short name interface
:return list: list of PfInfoDb
"""
file_type_list_id = [
self.get_ftid_from_short_name(x) for x in file_type_list
]
file_type_list_id = filter(lambda x: x != '', file_type_list_id)
pft_list = SQ.entity_asset_query_versions(
showobj.id,
assetid,
file_type_list_id=file_type_list_id,
conn=self.get_conn())
return pft_list
def load_shot(self, show_name, shot_names):
"""Load a list of shots into db under showname
:param show_name: (str), valid sgtk name
:param shot_names: (list or str): a valid code name for shot
"""
showobj = None
if show_name in self.get_show_names():
showobj = self['Shows'][show_name]
if showobj == None:
return []
if isinstance(shot_names, basestring):
shot_names = [shot_names]
shot_list = SQ.shots_with_id(showobj.id, shot_names, self.get_conn())
showobj.init_with_shots(shot_list)
self._currentshow = show_name
return shot_list
def load_asset(self, show_name, asset_names):
"""Load a single asset into db under showname
:param show_name: (str), valid sgtk name
:param asset_names: (list/str): a valid code name for asset
"""
showobj = None
if show_name in self.get_show_names():
showobj = self['Shows'][show_name]
if showobj == None:
return list()
if isinstance(asset_names, basestring):
asset_names = [asset_names]
asset_list = SQ.assets_with_id(showobj.id, asset_names,
self.get_conn())
showobj.init_with_assets(asset_list)
self._currentshow = show_name
return asset_list
def _do_steps(self):
"""Query and cache step info
"""
conn = self.get_conn()
if conn == None:
return
SW.start()
if self.verbose:
log.warning("login to shotgun, to get default step settings")
steps = SQ.step_list_with_id(conn)
parent = self['Steps']
steps_name = dict()
for s in steps:
if not s.getName() in steps_name:
steps_name[s.getName()] = s
for s in steps_name:
parent.addChild(steps_name[s], withRename=False)
SW.stop()
if self.verbose:
log.info("step_query in {}".format(SW.elapsed()))
def shotid_filepubobj_query(self, showobj, shotobj, file_type_object_list):
"""
:param showobj:
:param shotobj:
:param file_type_list: (list) pft Short name interface
:return list: list of PfInfoDb
"""
file_type_list_id = [x.id for x in file_type_object_list]
file_type_list_id = filter(lambda x: x != '', file_type_list_id)
pf_list = SQ.entity_shot_query_versions(
showobj.id,
shotobj.id,
file_type_list_id=file_type_list_id,
conn=self.get_conn())
res = list()
for ftol in file_type_object_list:
res.append(
[x for x in pf_list if x.published_file_type["id"] == ftol.id])
return res
return pf_list
def get_departments(self):
""" query and cache department info
"""
if len(self._dept_shot) + len(self._dept_asset) > 0:
return self._dept_shot + self._dept_asset
#if not self._use_coffer:
conn = self.get_conn()
log.warning("login to shotgun, to get default department settings")
dept = SQ.dept_list_with_id(conn)
for i in dept:
#print i.getName(),i.__dict__
if i.is_shot():
self._dept_shot.append(i)
elif i.is_asset():
self._dept_asset.append(i)
else:
pass # we ignore production (prod) for now
#log.warning('unknown department type %r' % i.dept_type)
self._dept_shot = sorted(self._dept_shot, DeptInfoDb.compare)
self._dept_asset = sorted(self._dept_asset, DeptInfoDb.compare)
return self._dept_shot + self._dept_asset
def test_all_show():
a = ShotgunQuery.get_current_projects(conn)
print([(x.getName(), x.id) for x in a])
assert len(a) > 0
def download_icon(self, image_url, dest):
SW.start()
SQ.download_icon(image_url, dest, self.get_conn())
SW.stop()
if self.verbose:
log.info("download icon in {}".format(SW.elapsed()))
def test_get_setting():
a = ShotgunQuery.show_id_by_name(conn, 'dev_show')
assert 'id' in a
settinglist = ShotgunQuery.query_settings(a['id'], conn)
for s in settinglist:
print(s)
def test_db_asset_for_build_shot():
dbc = DbCache(shot_only=False, asset_only=True)
showobj = dbc.get_showobj('dev_show')
assert showobj != None
M_SHADER_SF = 'maya_shader_src_file'
M_RIG_SF = 'maya_rig_src_file'
file_type_list = [M_SHADER_SF, M_RIG_SF] #,'maya_model_file']
#file_type_list = ['maya_rig_src_file'] #,'maya_model_file']
#pft_list = dbc.asset_maya_build_query(showobj, assetobj, file_type_list)
fts = SQ.filter_fpt_by_name(file_type_list, conn=dbc.get_conn())
shd_src_pub_type = None
rig_src_pub_type = None
for f in fts:
if f.getName() == M_RIG_SF:
rig_src_pub_type = f
elif f.getName() == M_SHADER_SF:
shd_src_pub_type = f
assert shd_src_pub_type != None
assert rig_src_pub_type != None
shot_list = dbc.load_shot('dev_show', ['007_0200', '051_0200'])
assert len(shot_list) > 0
for shotobj in shot_list:
print("SHOT", shotobj.code, shotobj.assets)
assets_id = shotobj.get_asset_ids()
assets_name = shotobj.get_asset_names()
for as_id, as_name in zip(assets_id, assets_name):
print("asset name:", as_name)
ass = AssetInfoDb()
ass.setName(as_name)
ass.setdata(as_id)
SW = StopWatch()
SW.start()
#pf_list = dbc.assetid_filepub_query(showobj, as_id, file_type_list)
pf_list = dbc.assetid_filepubobj_query(
showobj, ass, [rig_src_pub_type, shd_src_pub_type])
rig_srcs = pf_list[0]
shd_srcs = pf_list[1]
SW.stop()
print("assetid_filepub_query in %f" % SW.elapsed())
""" much slower
SW.start()
a = dbc.assetid_filepub_query(showobj, as_id, [file_type_list[0]])
SW.stop()
print("assetid_filepub_query1 in %f" % SW.elapsed())
SW.start()
b = dbc.assetid_filepub_query(showobj, as_id, [file_type_list[1]])
SW.stop()
print("assetid_filepub_query2 in %f" % SW.elapsed())
"""
rig_mod_ids = []
rig_rig_ids = []
printinfo = True
for pf in rig_srcs:
if printinfo: print("VERSION RIG", pf.version_number)
x = pf.get_upstream_model()
if x != None:
if printinfo:
print("\tRIG model version",
pf.get_upstream_model_version(), x['id'])
rig_mod_ids.append(x['id'])
x = pf.get_downstream_rig()
if x:
if printinfo:
print("\tRIG rig version",
pf.get_downstream_rig_version(), x['id'])
rig_rig_ids.append(x['id'])
shd_mod_ids = []
shd_cfx_ids = []
shd_shd_ids = []
for pf in shd_srcs:
if printinfo: print("VERSION SHADER", pf.version_number)
x = pf.get_upstream_model()
if x != None:
if printinfo:
print("\tshader model version",
pf.get_upstream_model_version(), x['id'])
shd_mod_ids.append(x['id'])
x = pf.get_upstream_cfx()
if x != None:
if printinfo:
print("\tshader cfx version",
pf.get_upstream_cfx_version(), x['id'])
shd_cfx_ids.append(x['id'])
x = pf.get_downstream_shader()
if x != None:
if printinfo:
print("\tshader shader version",
pf.get_downstream_shader_version(), x['id'])
shd_shd_ids.append(x['id'])
#print "shader model", shd_mod_ids
#print "shader cfx", shd_cfx_ids
#print "shader shader",shd_shd_ids
#entity_publish_id = rig_mod_ids + rig_rig_ids + shd_mod_ids + shd_cfx_ids + shd_shd_ids
# check cfx model version
"""
entity_publish_id = shd_cfx_ids
if len(entity_publish_id) > 0:
print("Q" * 100, entity_publish_id)
res = ShotgunQuery.published_file_query(showobj.id, entity_publish_id , conn = dbc.get_conn())
print ("return res",res)
for pf in res:
x = pf.get_upstream_model()
if x:
print(x)
print("\t\t\tfound model on cfx at version" % pf.get_upstream_model_version())
#print(pf.getName(),r.get_file_local_path())
"""
"""
