def guess_shot(project, episode_name, sequence_name, shot_name):
episode_id = None
if len(episode_name) > 0:
episode = Entity.get_by(name=episode_name,
entity_type_id=shot_info.get_episode_type().id,
project_id=project.id)
if episode is not None:
episode_id = episode.id
sequence_id = None
if len(sequence_name) > 0:
sequence = Entity.get_by(
name=sequence_name,
entity_type_id=shot_info.get_sequence_type().id,
parent_id=episode_id,
project_id=project.id)
if sequence is not None:
sequence_id = sequence.id
else:
sequence_id = None
if len(shot_name) > 0:
shot = Entity.get_by(name=shot_name,
entity_type_id=shot_info.get_shot_type().id,
parent_id=sequence_id,
project_id=project.id)
else:
raise WrongPathFormatException("Shot name was not found in given path")
return shot
def get_assets(criterions={}):
shot_type = shot_info.get_shot_type()
sequence_type = shot_info.get_sequence_type()
episode_type = shot_info.get_episode_type()
query = Entity.query.filter_by(**criterions)
return query.filter(~Entity.entity_type_id.in_(
[shot_type.id, sequence_type.id, episode_type.id])).all()
def build_query(self):
shot_type = shot_info.get_shot_type()
Sequence = aliased(Entity, name='sequence')
query = self.model.query.filter_by(entity_type_id=shot_type.id)
query = query.join(Project)
query = query.join(Sequence, Sequence.id == Entity.parent_id)
query = query.add_columns(Project.name)
query = query.add_columns(Sequence.name)
query = query.order_by(Project.name, Sequence.name, Entity.name)
return query
def is_asset_type(asset_type):
shot_type = shot_info.get_shot_type()
sequence_type = shot_info.get_sequence_type()
episode_type = shot_info.get_episode_type()
return asset_type.id not in [
shot_type.id,
sequence_type.id,
episode_type.id,
]
def is_asset(entity):
shot_type = shot_info.get_shot_type()
sequence_type = shot_info.get_sequence_type()
episode_type = shot_info.get_episode_type()
return entity.entity_type_id not in [
shot_type.id,
sequence_type.id,
episode_type.id,
]
def build_query(self):
shot_type = shot_info.get_shot_type()
sequence_type = shot_info.get_sequence_type()
episode_type = shot_info.get_episode_type()
query = self.model.query.filter(~Entity.entity_type_id.in_(
[shot_type.id, sequence_type.id, episode_type.id]))
query = query.join(Project)
query = query.join(EntityType)
query = query.add_columns(Project.name)
query = query.add_columns(EntityType.name)
query = query.order_by(Project.name, EntityType.name, Entity.name)
return query
def import_row(self, row):
project_name = row["Project"]
episode_name = row["Episode"]
sequence_name = row["Sequence"]
shot_name = row["Name"]
description = row["Description"]
fps = row["FPS"]
frame_in = row["Frame In"]
frame_out = row["Frame Out"]
self.add_to_cache_if_absent(self.projects, project_info.get_or_create,
project_name)
project_id = self.get_id_from_cache(self.projects, project_name)
episode_key = "%s-%s" % (project_id, episode_name)
if episode_key not in self.episodes:
project = self.projects[project_name]
self.episodes[episode_key] = \
shot_info.get_or_create_episode(project, episode_name)
sequence_key = "%s-%s" % (project_id, sequence_name)
if sequence_key not in self.sequences:
project = self.projects[project_name]
episode = self.episodes[episode_key]
self.sequences[sequence_key] = \
shot_info.get_or_create_sequence(project, episode, sequence_name)
sequence_id = self.get_id_from_cache(self.sequences, sequence_key)
shot_type = shot_info.get_shot_type()
try:
entity = Entity.create(name=shot_name,
description=description,
project_id=project_id,
parent_id=sequence_id,
entity_type_id=shot_type.id,
data={
"fps": fps,
"frame_in": frame_in,
"frame_out": frame_out
})
except IntegrityError:
entity = Entity.get_by(name=shot_name,
project_id=project_id,
parent_id=sequence_id,
entity_type_id=shot_type.id)
return entity
def import_entry(self, data):
shot = Entity.get_by(shotgun_id=data["shotgun_id"],
entity_type_id=shot_info.get_shot_type().id)
if shot is None:
shot = Entity(**data)
shot.save()
current_app.logger.info("Shot created: %s" % shot)
else:
if shot.data is None:
shot.data = {}
shot.update(data)
shot.data.update(data["data"])
shot.save()
current_app.logger.info("Shot updated: %s" % shot)
return shot
def all_assets(criterions={}):
shot_type = shot_info.get_shot_type()
sequence_type = shot_info.get_sequence_type()
episode_type = shot_info.get_episode_type()
query = Entity.query.filter_by(**criterions)
query = query.filter(~Entity.entity_type_id.in_(
[shot_type.id, sequence_type.id, episode_type.id]))
query = query.join(Project)
query = query.join(EntityType)
query = query.add_columns(Project.name)
query = query.add_columns(EntityType.name)
data = query.all()
assets = []
for (asset_model, project_name, asset_type_name) in data:
asset = asset_model.serialize()
asset["project_name"] = project_name
asset["asset_type_name"] = asset_type_name
assets.append(asset)
return assets
def extract_data(self, sg_shot):
(frame_in, frame_out) = self.extract_frame_range(sg_shot)
custom_fields = self.extract_custom_data(sg_shot)
project_id = self.get_project(sg_shot, self.project_map)
sequence_id = self.get_sequence(sg_shot, self.sequence_map)
assets = self.extract_assets(sg_shot, self.asset_map)
shot_type = shot_info.get_shot_type()
data = {
"name": sg_shot["code"],
"shotgun_id": sg_shot["id"],
"project_id": project_id,
"entity_type_id": shot_type.id,
"parent_id": sequence_id,
"entities_out": assets
}
data_field_content = {
"frame_in": frame_in,
"frame_out": frame_out,
}
custom_fields.update(data_field_content)
data["data"] = custom_fields
return data
def prepare_import(self):
self.shot_type = shot_info.get_shot_type()
self.project_map = Project.get_id_map(field="name")
self.asset_map = self.get_asset_map()
self.sequence_map = self.get_sequence_map()
def test_get_shot_type(self):
shot_type = shot_info.get_shot_type()
self.assertEqual(shot_type.name, "Shot")
def test_import_version(self):
sg_version = {
"code": "S01_Animation",
"description": "description test",
"id": 2,
"user": {
"id": 1,
"name": "Jhon Doe",
"type": "HumanUser"
},
"entity": {
"id": 1,
"name": "SH01",
"type": "Shot"
},
"project": {
"id": 1,
"name": "Cosmos Landromat",
"type": "Project"
},
"sg_task": {
"id": 1,
"name": "Animation",
"type": "Task"
},
"sg_uploaded_movie": {
"content_type": "video/mp4",
"id": 1,
"link_type": "upload",
"name": "movie_new.mp4",
"type": "Attachment",
"url": "https://sg-media.amazonaws.com/9e73/movie_new.mp4"
},
"type": "Version"
}
api_path = "data/import/shotgun/versions"
self.preview_files = self.post(api_path, [sg_version], 200)
self.assertEqual(len(self.preview_files), 1)
self.preview_files = self.get("data/preview_files")
self.assertEqual(len(self.preview_files), 1)
preview_file = self.preview_files[0]
task = Task.get_by(shotgun_id=sg_version["sg_task"]["id"])
person = Person.get_by(shotgun_id=sg_version["user"]["id"])
entity = Entity.get_by(
shotgun_id=sg_version["entity"]["id"],
entity_type_id=shot_info.get_shot_type().id
)
self.assertEqual(preview_file["name"], sg_version["code"])
self.assertEqual(preview_file["source"], "Shotgun")
self.assertEqual(preview_file["entity_id"], str(entity.id))
self.assertEqual(preview_file["task_id"], str(task.id))
self.assertEqual(preview_file["name"], sg_version["code"])
self.assertEqual(preview_file["description"], sg_version["description"])
self.assertEqual(preview_file["shotgun_id"], sg_version["id"])
self.assertEqual(
preview_file["uploaded_movie_url"],
sg_version["sg_uploaded_movie"]["url"]
)
self.assertEqual(
preview_file["uploaded_movie_url"],
sg_version["sg_uploaded_movie"]["url"]
)
self.assertEqual(preview_file["person_id"], str(person.id))
