def test_get_project_and_type_assets(self):
asset_type = assets_service.get_or_create_asset_type("VFX")
Entity.create(name="Smoke",
entity_type_id=asset_type["id"],
project_id=self.project.id)
path_ids = (self.project.id, self.asset_type.id)
path = "data/projects/%s/asset-types/%s/assets" % path_ids
assets = self.get(path)
self.assertEquals(len(assets), 1)
self.assertDictEqual(assets[0], self.asset_dict)
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_asset(
project_id, asset_type_id, name, description, data, source_id=None
):
"""
Create a new asset from given parameters.
"""
project = projects_service.get_project_raw(project_id)
asset_type = get_asset_type_raw(asset_type_id)
asset = Entity.create(
project_id=project_id,
entity_type_id=asset_type_id,
name=name,
description=description,
data=data,
source_id=source_id,
)
asset_dict = asset.serialize(obj_type="Asset")
events.emit(
"asset:new",
{
"asset_id": asset.id,
"asset_type": asset_type.id,
"project_id": project.id,
},
)
return asset_dict
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 generate_fixture_asset_camera(self):
self.asset_camera = Entity.create(
name="Main camera",
description="Description Camera",
project_id=self.project.id,
entity_type_id=self.asset_type_camera.id,
)
def generate_fixture_sequence_standard(self):
self.sequence_standard = Entity.create(
name="S01",
project_id=self.project_standard.id,
entity_type_id=self.sequence_type.id,
)
return self.sequence_standard
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 generate_fixture_episode(self, name="E01", project_id=None):
if project_id is None:
project_id = self.project.id
self.episode = Entity.create(name=name,
project_id=project_id,
entity_type_id=self.episode_type.id)
return self.episode
def test_get_sequence_from_shot_no_sequence(self):
self.shot_noseq = Entity.create(name="P01NOSEQ",
project_id=self.project.id,
entity_type_id=self.shot_type.id)
self.assertRaises(SequenceNotFoundException,
shots_service.get_sequence_from_shot,
self.shot_noseq)
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 generate_fixture_asset(self,
name="Tree",
description="Description Tree"):
self.asset = Entity.create(name=name,
description=description,
project_id=self.project.id,
entity_type_id=self.asset_type.id)
return self.asset
def generate_fixture_asset_character(self,
name="Rabbit",
description="Main char"):
self.asset_character = Entity.create(
name=name,
description=description,
project_id=self.project.id,
entity_type_id=self.asset_type_character.id)
def generate_fixture_edit(self, name="Edit", parent_id=None):
self.edit = Entity.create(
name=name,
description="Description of the Edit",
project_id=self.project.id,
entity_type_id=self.edit_type.id,
parent_id=parent_id,
)
return self.edit
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 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 generate_fixture_shot_standard(self, name="SH01"):
self.shot_standard = Entity.create(
name=name,
description="Description Shot 01",
data={"fps": 25, "frame_in": 0, "frame_out": 100},
project_id=self.project_standard.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence_standard.id,
)
return self.shot_standard
def generate_fixture_shot(self, name="P01", nb_frames=0):
self.shot = Entity.create(
name=name,
description="Description Shot 01",
data={"fps": 25, "frame_in": 0, "frame_out": 100},
project_id=self.project.id,
entity_type_id=self.shot_type.id,
parent_id=self.sequence.id,
nb_frames=nb_frames,
)
return self.shot
def create_episode(project_id, name):
"""
Create episode for given project.
"""
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)
events.emit("episode:new", {"episode_id": episode.id})
return episode.serialize(obj_type="Episode")
def generate_fixture_sequence(self,
name="S01",
episode_id=None,
project_id=None):
if episode_id is None and hasattr(self, "episode"):
episode_id = self.episode.id
if project_id is None:
project_id = self.project.id
self.sequence = Entity.create(name=name,
project_id=project_id,
entity_type_id=self.sequence_type.id,
parent_id=episode_id)
def create_sequence(project_id, episode_id, name):
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)
return sequence.serialize(obj_type="Sequence")
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_row(self, row, project_id):
episode_name = row["Episode"]
sequence_name = row["Sequence"]
shot_name = row["Name"]
description = row["Description"]
frame_in = row["Frame In"]
frame_out = row["Frame Out"]
episode_key = "%s-%s" % (project_id, episode_name)
if episode_key not in self.episodes:
self.episodes[episode_key] = \
shots_service.get_or_create_episode(project_id, episode_name)
sequence_key = "%s-%s-%s" % (project_id, episode_name, sequence_name)
if sequence_key not in self.sequences:
episode = self.episodes[episode_key]
self.sequences[sequence_key] = \
shots_service.get_or_create_sequence(
project_id,
episode["id"],
sequence_name
)
sequence_id = self.get_id_from_cache(self.sequences, sequence_key)
shot_type = shots_service.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={
"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.serialize()
def generate_fixture_scene(self,
name="SC01",
project_id=None,
sequence_id=None):
if project_id is None:
project_id = self.project.id
if sequence_id is None:
sequence_id = self.sequence.id
self.scene = Entity.create(name=name,
description="Description Scene 01",
data={},
project_id=project_id,
entity_type_id=self.scene_type.id,
parent_id=self.sequence.id)
return self.scene
def create_shot(project_id, sequence_id, name, data={}):
shot_type = get_shot_type()
if sequence_id is not None:
get_sequence(sequence_id) # raises SequenceNotFound if it fails.
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)
return shot.serialize(obj_type="Shot")
def run_import(self, file_path, project_id):
result = []
self.check_permissions()
self.prepare_import()
xml_file = etree.parse(file_path)
root = xml_file.getroot()
episode = shots_service.get_or_create_first_episode(project_id)
shot_type = shots_service.get_shot_type()
clips = root.iter('clipitem')
for clip in clips:
sequence_name = clip.find('name').text.split('_')[0]
shot_name = clip.find('name').text.split('_')[1]
start = clip.find('start').text
end = clip.find('end').text
if start == '-1':
if clip.getprevious().tag == 'transitionitem':
start = clip.getprevious().find('start').text
if end == '-1':
if clip.getnext().tag == 'transitionitem':
end = clip.getnext().find('end').text
duration = int(end) - int(start)
self.sequences[sequence_name] = shots_service.get_or_create_sequence(project_id, episode['id'], sequence_name)
sequence_id = self.get_id_from_cache(self.sequences, sequence_name)
try:
entity = Entity.create(
name=shot_name,
project_id=project_id,
parent_id=sequence_id,
entity_type_id=shot_type["id"],
nb_frames=str(duration)
)
except IntegrityError:
entity = Entity.get_by(
name=shot_name,
project_id=project_id,
parent_id=sequence_id,
entity_type_id=shot_type["id"]
)
result.append(entity.serialize())
return result
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:
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
)
data = {}
for name, field_name in self.descriptor_fields.items():
if name in row:
data[field_name] = row[name]
try:
entity = Entity.get_by(
name=asset_name,
project_id=project_id,
entity_type_id=entity_type_id,
source_id=episode_id
)
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,
)
else:
entity.update({"description": description, "data": data})
except IntegrityError:
pass
return entity.serialize()
def create_scene(project_id, sequence_id, name):
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={})
return scene.serialize(obj_type="Scene")
