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