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=shots_service.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=shots_service.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=shots_service.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 import_entry(self, data):
sequence = Entity.get_by(shotgun_id=data["shotgun_id"],
entity_type_id=self.sequence_type["id"])
if sequence is None:
sequence = Entity(**data)
sequence.save()
current_app.logger.info("Sequence created: %s" % sequence)
else:
# Little hack to avoid integrity errors due to
# duplicated data.
similar_sequence = Entity.get_by(
name=data["name"],
parent_id=data["parent_id"],
project_id=data["project_id"],
entity_type_id=self.sequence_type["id"])
if similar_sequence is None:
sequence.update(data)
sequence.save()
else:
sequence.update({
"description": data["description"],
"shotgun_id": data["shotgun_id"]
})
sequence.save()
current_app.logger.info("Sequence updated: %s" % sequence)
return sequence
def import_entry(self, data):
sequence = Entity.get_by(
shotgun_id=data["shotgun_id"],
entity_type_id=self.sequence_type["id"],
)
similar_sequence = Entity.get_by(
name=data["name"],
parent_id=data["parent_id"],
project_id=data["project_id"],
entity_type_id=self.sequence_type["id"],
)
if sequence is None and similar_sequence is None:
sequence = Entity(**data)
sequence.save()
current_app.logger.info("Sequence created: %s" % sequence)
elif sequence is not None:
if similar_sequence is None:
sequence.update(data)
sequence.save()
else:
sequence.update(
{
"description": data["description"],
"shotgun_id": data["shotgun_id"],
}
)
sequence.save()
current_app.logger.info("Sequence updated: %s" % sequence)
return sequence
def test_import_shot(self):
self.load_fixture('projects')
self.load_fixture('sequences')
self.load_fixture('assets')
self.load_fixture('scenes')
api_path = "/import/shotgun/shots"
self.shots = self.post(api_path, [self.sg_shot], 200)
self.assertEqual(len(self.shots), 1)
self.shots = self.get("data/shots/all")
self.assertEqual(len(self.shots), 1)
shot = self.shots[0]
sequence = Entity.get_by(
shotgun_id=self.sg_shot["sg_sequence"]["id"],
entity_type_id=shots_service.get_sequence_type()["id"]
)
entity = Entity.get_by(name=self.sg_shot["assets"][0]["name"])
project = Project.get_by(name=self.sg_shot["project"]["name"])
scene = Entity.get_by(name=self.sg_shot["sg_scene"]["name"])
self.assertEqual(shot["name"], self.sg_shot["code"])
self.assertEqual(shot["data"]["frame_in"], 0)
self.assertEqual(shot["data"]["frame_out"], 122)
self.assertEqual(shot["data"]["sg_custom_field"], "test")
self.assertEqual(shot["parent_id"], str(sequence.id))
self.assertEqual(shot["entities_out"][0], str(entity.id))
self.assertEqual(shot["project_id"], str(project.id))
self.assertEqual(shot["source_id"], str(scene.id))
def import_row(self, row, project_id):
name = row["Name"]
entity_type_name = row["Type"]
description = row["Description"]
self.add_to_cache_if_absent(
self.entity_types,
assets_service.get_or_create_asset_type,
entity_type_name
)
entity_type_id = self.get_id_from_cache(
self.entity_types,
entity_type_name
)
try:
entity = Entity.get_by(
name=name,
project_id=project_id,
entity_type_id=entity_type_id
)
if entity is None:
entity = Entity.create(
name=name,
description=description,
project_id=project_id,
entity_type_id=entity_type_id
)
except IntegrityError:
pass
return entity
def create_edit(project_id, name, data={}, description="", parent_id=None):
"""
Create edit for given project and episode.
"""
edit_type = get_edit_type()
if parent_id is not None and len(parent_id) < 36:
parent_id = None
edit = Entity.get_by(
entity_type_id=edit_type["id"],
parent_id=parent_id,
project_id=project_id,
name=name,
)
if edit is None:
edit = Entity.create(
entity_type_id=edit_type["id"],
project_id=project_id,
parent_id=parent_id,
name=name,
data=data,
description=description,
)
events.emit(
"edit:new",
{
"edit_id": edit.id,
"parent_id": parent_id,
},
project_id=project_id,
)
return edit.serialize(obj_type="Edit")
def import_row(self, row):
name = row["Name"]
project_name = row["Project"]
entity_type_name = row["Category"]
description = row["Description"]
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)
self.add_to_cache_if_absent(self.entity_types,
asset_info.get_or_create_type,
entity_type_name)
entity_type_id = self.get_id_from_cache(self.entity_types,
entity_type_name)
try:
entity = Entity.create(name=name,
description=description,
project_id=project_id,
entity_type_id=entity_type_id)
except IntegrityError:
entity = Entity.get_by(name=name,
project_id=project_id,
entity_type_id=entity_type_id)
return entity
def test_import_sequence(self):
self.load_fixture("projects")
self.load_fixture("episodes")
sg_sequence = {
"project": {"type": "Project", "id": 1, "name": "Agent327"},
"episode": {"type": "Episode", "id": 1, "name": "E01"},
"code": "S04",
"type": "Sequence",
"id": 4,
"description": "test description",
}
api_path = "/import/shotgun/sequences"
self.sequences = self.post(api_path, [sg_sequence], 200)
self.assertEqual(len(self.sequences), 1)
self.sequences = self.get("data/sequences")
self.assertEqual(len(self.sequences), 1)
sequence = self.sequences[0]
project = Project.get_by(name="Agent327")
episode = Entity.get_by(name="E01")
self.assertEqual(sequence["name"], sg_sequence["code"])
self.assertEqual(sequence["description"], sg_sequence["description"])
self.assertEqual(sequence["shotgun_id"], sg_sequence["id"])
self.assertEqual(sequence["project_id"], str(project.id))
self.assertEqual(sequence["parent_id"], str(episode.id))
def get_shot_by_shotgun_id(shotgun_id):
shot_type = get_shot_type()
shot = Entity.get_by(entity_type_id=shot_type["id"], shotgun_id=shotgun_id)
if shot is None:
raise ShotNotFoundException
return shot.serialize(obj_type="Shot")
def create_sequence(project_id, episode_id, name):
"""
Create sequence for given project and episode.
"""
sequence_type = get_sequence_type()
if episode_id is not None:
get_episode(episode_id) # raises EpisodeNotFound if it fails.
sequence = Entity.get_by(
entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name,
)
if sequence is None:
sequence = Entity.create(
entity_type_id=sequence_type["id"],
project_id=project_id,
parent_id=episode_id,
name=name,
)
events.emit(
"sequence:new", {"sequence_id": sequence.id}, project_id=project_id
)
return sequence.serialize(obj_type="Sequence")
def create_shot(project_id, sequence_id, name, data={}, nb_frames=0):
"""
Create shot for given project and sequence.
"""
shot_type = get_shot_type()
if sequence_id is not None:
# raises SequenceNotFound if it fails.
sequence = get_sequence(sequence_id)
shot = Entity.get_by(
entity_type_id=shot_type["id"],
parent_id=sequence_id,
project_id=project_id,
name=name,
)
if shot is None:
shot = Entity.create(
entity_type_id=shot_type["id"],
project_id=project_id,
parent_id=sequence_id,
name=name,
data=data,
nb_frames=nb_frames,
)
events.emit(
"shot:new",
{
"shot_id": shot.id,
"episode_id": sequence["parent_id"],
},
project_id=project_id,
)
return shot.serialize(obj_type="Shot")
def create_scene(project_id, sequence_id, name):
"""
Create scene for given project and sequence.
"""
scene_type = get_scene_type()
if sequence_id is not None:
# raises SequenceNotFound if it fails.
sequence = get_sequence(sequence_id)
if sequence["project_id"] != project_id:
raise SequenceNotFoundException
scene = Entity.get_by(
entity_type_id=scene_type["id"],
parent_id=sequence_id,
project_id=project_id,
name=name,
)
if scene is None:
scene = Entity.create(
entity_type_id=scene_type["id"],
project_id=project_id,
parent_id=sequence_id,
name=name,
data={},
)
events.emit("scene:new", {"scene_id": scene.id}, project_id=project_id)
return scene.serialize(obj_type="Scene")
def import_row(self, row, project_id):
asset_name = row["Name"]
entity_type_name = row["Type"]
description = row.get("Description", "")
episode_name = row.get("Episode", None)
episode_id = None
if episode_name is not None:
if episode_name != "MP" and episode_name not in self.episodes:
self.episodes[
episode_name] = shots_service.get_or_create_episode(
project_id, episode_name)["id"]
episode_id = self.episodes.get(episode_name, None)
self.add_to_cache_if_absent(
self.entity_types,
assets_service.get_or_create_asset_type,
entity_type_name,
)
entity_type_id = self.get_id_from_cache(self.entity_types,
entity_type_name)
entity = Entity.get_by(name=asset_name,
project_id=project_id,
entity_type_id=entity_type_id,
source_id=episode_id)
data = {}
for name, field_name in self.descriptor_fields.items():
if name in row:
data[field_name] = row[name]
elif entity is not None \
and entity.data is not None \
and field_name in entity.data:
data[field_name] = entity.data[field_name]
if entity is None:
entity = Entity.create(
name=asset_name,
description=description,
project_id=project_id,
entity_type_id=entity_type_id,
source_id=episode_id,
data=data,
)
events.emit("asset:new", {
"asset_id": str(entity.id),
"episode_id": episode_id
},
project_id=project_id)
elif self.is_update:
entity.update({"description": description, "data": data})
events.emit("asset:update", {
"asset_id": str(entity.id),
"episode_id": episode_id
},
project_id=project_id)
return entity.serialize()
def get_scene_by_shotgun_id(shotgun_id):
scene_type = get_scene_type()
scene = Entity.get_by(entity_type_id=scene_type["id"],
shotgun_id=shotgun_id)
if scene is None:
raise SceneNotFoundException
return scene.serialize(obj_type="Scene")
def get_sequence_by_shotgun_id(shotgun_id):
sequence_type = get_sequence_type()
sequence = Entity.get_by(entity_type_id=sequence_type["id"],
shotgun_id=shotgun_id)
if sequence is None:
raise SequenceNotFoundException
return sequence.serialize(obj_type="Sequence")
def get_episode_by_shotgun_id(shotgun_id):
episode_type = get_episode_type()
episode = Entity.get_by(entity_type_id=episode_type["id"],
shotgun_id=shotgun_id)
if episode is None:
raise EpisodeNotFoundException
return episode.serialize(obj_type="Episode")
def import_row(self, row, project_id):
asset_name = row["Name"]
entity_type_name = row["Type"]
description = row["Description"]
episode_name = row.get("Episode", None)
episode_id = None
if episode_name is not None:
if episode_name != "MP" and episode_name not in self.episodes:
self.episodes[
episode_name
] = shots_service.get_or_create_episode(
project_id, episode_name
)["id"]
episode_id = self.episodes.get(episode_name, None)
self.add_to_cache_if_absent(
self.entity_types,
assets_service.get_or_create_asset_type,
entity_type_name,
)
entity_type_id = self.get_id_from_cache(
self.entity_types, entity_type_name
)
entity = Entity.get_by(
name=asset_name,
project_id=project_id,
entity_type_id=entity_type_id,
source_id=episode_id
)
data = {}
for name, field_name in self.descriptor_fields.items():
if name in row:
data[field_name] = row[name]
elif entity is not None \
and entity.data is not None \
and field_name in entity.data:
data[field_name] = entity.data[field_name]
if entity is None:
try:
entity = Entity.create(
name=asset_name,
description=description,
project_id=project_id,
entity_type_id=entity_type_id,
source_id=episode_id,
data=data,
)
except IntegrityError:
current_app.logger.error("Row import failed", exc_info=1)
elif self.is_update:
entity.update({"description": description, "data": data})
return entity.serialize()
def get_shot_by_shotgun_id(shotgun_id):
"""
Retrieves a shot identifed by its shotgun ID (stored during import).
"""
shot_type = get_shot_type()
shot = Entity.get_by(entity_type_id=shot_type["id"], shotgun_id=shotgun_id)
if shot is None:
raise ShotNotFoundException
return shot.serialize(obj_type="Shot")
def create_episode(project_id, name):
episode_type = get_episode_type()
episode = Entity.get_by(entity_type_id=episode_type["id"],
project_id=project_id,
name=name)
if episode is None:
episode = Entity.create(entity_type_id=episode_type["id"],
project_id=project_id,
name=name)
return episode.serialize(obj_type="Episode")
def get_shot_raw(shot_id):
shot_type = get_shot_type()
try:
shot = Entity.get_by(entity_type_id=shot_type["id"], id=shot_id)
except StatementError:
raise SequenceNotFoundException
if shot is None:
raise ShotNotFoundException
return shot
def get_scene_raw(scene_id):
scene_type = get_scene_type()
try:
scene = Entity.get_by(entity_type_id=scene_type["id"], id=scene_id)
except StatementError:
raise SequenceNotFoundException
if scene is None:
raise SceneNotFoundException
return scene
def get_episode_by_shotgun_id(shotgun_id):
"""
Retrieves an episode identifed by its shotgun ID (stored during import).
"""
episode_type = get_episode_type()
episode = Entity.get_by(entity_type_id=episode_type["id"],
shotgun_id=shotgun_id)
if episode is None:
raise EpisodeNotFoundException
return episode.serialize(obj_type="Episode")
def get_sequence_by_shotgun_id(shotgun_id):
"""
Retrieves a sequence identifed by its shotgun ID (stored during import).
"""
sequence_type = get_sequence_type()
sequence = Entity.get_by(entity_type_id=sequence_type["id"],
shotgun_id=shotgun_id)
if sequence is None:
raise SequenceNotFoundException
return sequence.serialize(obj_type="Sequence")
def get_episode_raw(episode_id):
episode_type = get_episode_type()
try:
episode = Entity.get_by(entity_type_id=episode_type["id"],
id=episode_id)
except StatementError:
raise EpisodeNotFoundException
if episode is None:
raise EpisodeNotFoundException
return episode
def get_or_create_episode(project_id, name):
episode_type = get_episode_type()
episode = Entity.get_by(entity_type_id=episode_type["id"],
project_id=project_id,
name=name)
if episode is None:
episode = Entity(entity_type_id=episode_type["id"],
project_id=project_id,
name=name)
episode.save()
return episode.serialize()
def get_or_create_sequence(project_id, episode_id, name):
sequence_type = get_sequence_type()
sequence = Entity.get_by(entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name)
if sequence is None:
sequence = Entity(entity_type_id=sequence_type["id"],
parent_id=episode_id,
project_id=project_id,
name=name)
sequence.save()
return sequence.serialize()
def get_or_create_episode(project_id, name):
"""
Retrieve episode matching given project and name or create it.
"""
episode_type = get_episode_type()
episode = Entity.get_by(
entity_type_id=episode_type["id"], project_id=project_id, name=name
)
if episode is None:
episode = Entity(
entity_type_id=episode_type["id"], project_id=project_id, name=name
)
episode.save()
return episode.serialize()
def get_scene_raw(scene_id):
"""
Return given scene as an active record.
"""
scene_type = get_scene_type()
try:
scene = Entity.get_by(entity_type_id=scene_type["id"], id=scene_id)
except StatementError:
raise SceneNotFoundException
if scene is None:
raise SceneNotFoundException
return scene
def get_episode_raw(episode_id):
"""
Return given episode as an active record.
"""
episode_type = get_episode_type()
try:
episode = Entity.get_by(entity_type_id=episode_type["id"],
id=episode_id)
except StatementError:
raise EpisodeNotFoundException
if episode is None:
raise EpisodeNotFoundException
return episode
def get_edit_raw(edit_id):
"""
Return given edit as an active record.
"""
edit_type = get_edit_type()
try:
edit = Entity.get_by(entity_type_id=edit_type["id"], id=edit_id)
except StatementError:
raise EditNotFoundException
if edit is None:
raise EditNotFoundException
return edit