def setUp(self): """create test data """ super(StructureViewsUnitTestCase, self).setUp() from stalker import db, FilenameTemplate, Structure self.test_filename_template1 = FilenameTemplate( name='Asset Filename Template 1', target_entity_type='Asset', path='/some/path/template/code', filename='file_name_template_code') db.DBSession.add(self.test_filename_template1) self.test_filename_template2 = FilenameTemplate( name='Asset Filename Template 2', target_entity_type='Asset', path='/some/path/template/code', filename='file_name_template_code') db.DBSession.add(self.test_filename_template2) self.test_filename_template3 = FilenameTemplate( name='Asset Filename Template 3', target_entity_type='Asset', path='/some/path/template/code', filename='file_name_template_code') db.DBSession.add(self.test_filename_template3) self.test_structure1 = Structure( name='Test Structure 1', created_by=self.admin, templates=[ self.test_filename_template1, self.test_filename_template2 ], custom_template='custom template code here', ) db.DBSession.add(self.test_structure1) self.test_structure2 = Structure( name='Test Structure 2', created_by=self.admin, templates=[ self.test_filename_template1, self.test_filename_template2 ], custom_template='custom template code here', ) db.DBSession.add(self.test_structure2) self.test_structure3 = Structure( name='Test Structure 3', created_by=self.admin, templates=[ self.test_filename_template1, self.test_filename_template2 ], custom_template='custom template code here', ) db.DBSession.add(self.test_structure3) db.DBSession.commit()
def setUp(self): """setting up the tests """ super(StructureTester, self).setUp() from stalker import db, Type vers_type = Type(name="Version", code='vers', target_entity_type="FilenameTemplate") db.DBSession.add(vers_type) ref_type = Type(name="Reference", code='ref', target_entity_type="FilenameTemplate") db.DBSession.add(ref_type) db.DBSession.commit() # type templates from stalker import FilenameTemplate self.asset_template = FilenameTemplate(name="Test Asset Template", target_entity_type="Asset", type=vers_type) self.shot_template = FilenameTemplate(name="Test Shot Template", target_entity_type="Shot", type=vers_type) self.reference_template = FilenameTemplate( name="Test Reference Template", target_entity_type="Link", type=ref_type) self.test_templates = [ self.asset_template, self.shot_template, self.reference_template ] self.test_templates2 = [self.asset_template] self.custom_template = "a custom template" self.test_type = Type( name="Commercial Structure", code='comm', target_entity_type='Structure', ) # keyword arguments self.kwargs = { "name": "Test Structure", "description": "This is a test structure", "templates": self.test_templates, "custom_template": self.custom_template, "type": self.test_type, } self.test_structure = Structure(**self.kwargs) db.DBSession.add(self.test_structure) db.DBSession.commit()
def setUp(self): """setting up the tests """ vers_type = Type(name="Version", code='vers', target_entity_type="FilenameTemplate") ref_type = Type(name="Reference", code='ref', target_entity_type="FilenameTemplate") # type templates self.asset_template = FilenameTemplate(name="Test Asset Template", target_entity_type="Asset", type=vers_type) self.shot_template = FilenameTemplate(name="Test Shot Template", target_entity_type="Shot", type=vers_type) self.reference_template = FilenameTemplate( name="Test Reference Template", target_entity_type="Link", type=ref_type) self.test_templates = [ self.asset_template, self.shot_template, self.reference_template ] self.test_templates2 = [self.asset_template] self.custom_template = "a custom template" self.test_type = Type( name="Commercial Structure", code='comm', target_entity_type=Structure, ) # keyword arguments self.kwargs = { "name": "Test Structure", "description": "This is a test structure", "templates": self.test_templates, "custom_template": self.custom_template, "type": self.test_type, } self.test_structure = Structure(**self.kwargs)
def test_path_argument_skipped_path_attribute_is_empty_string(self): """testing if the path attribute is an empty string if the path argument is skipped """ self.kwargs.pop("path") ft = FilenameTemplate(**self.kwargs) assert ft.path == ""
def test_path_argument_is_None_path_attribute_is_empty_string(self): """testing if the path attribute is an empty string when the path argument is None """ self.kwargs["path"] = None ft = FilenameTemplate(**self.kwargs) assert ft.path == ""
def test_filename_argument_is_empty_string(self): """testing if nothing happens when the filename argument is empty string """ self.kwargs["filename"] = "" ft = FilenameTemplate(**self.kwargs) assert isinstance(ft, FilenameTemplate)
def test_path_argument_is_empty_string(self): """testing if nothing happens when the path argument is empty string """ self.kwargs["path"] = "" ft = FilenameTemplate(**self.kwargs) self.assertTrue(isinstance(ft, FilenameTemplate))
def test_filename_template_is_not_strictly_typed(self): """testing if the FilenameTemplate class is not strictly typed """ self.kwargs.pop("type") # no errors ft = FilenameTemplate(**self.kwargs) assert isinstance(ft, FilenameTemplate)
def test_filename_argument_is_None_filename_attribute_is_empty_string( self): """testing if the filename attribute is an empty string when the filename argument is None """ self.kwargs["filename"] = None ft = FilenameTemplate(**self.kwargs) assert ft.filename == ""
def test_target_entity_type_attribute_is_converted_to_a_string_if_given_as_a_class( self): """testing if the target_entity_type attribute is converted when the target_entity_type is given as a class """ self.kwargs["target_entity_type"] = 'Asset' ft = FilenameTemplate(**self.kwargs) assert ft.target_entity_type == "Asset"
def test_filename_argument_skipped_filename_attribute_is_empty_string( self): """testing if the filename attribute is an empty string if the filename argument is skipped """ self.kwargs.pop("filename") ft = FilenameTemplate(**self.kwargs) assert ft.filename == ""
def setUp(self): """set up the test """ db.setup() db.init() self.temp_path = tempfile.mkdtemp() self.repo = Repository( name='Test Repository', linux_path=self.temp_path, windows_path=self.temp_path, osx_path=self.temp_path ) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_cmpl = Status.query.filter_by(code='CMPL').first() self.project_status_list = \ StatusList.query.filter_by(target_entity_type='Project').first() self.task_filename_template = FilenameTemplate( name='Task Filename Template', target_entity_type='Task', path='{{project.code}}/{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}{{extension}}' ) self.project_structure = Structure( name='Project Structure', templates=[self.task_filename_template] ) self.project = Project( name='Test Project', code='TP', status_list=self.project_status_list, repository=self.repo, structure=self.project_structure ) self.task = Task( name='Test Task', project=self.project ) from stalker.db.session import DBSession DBSession.add(self.task) DBSession.commit() self.version = Version( task=self.task ) self.kwargs = { 'name': 'Photoshop', 'extensions': ['psd'], 'structure': ['Outputs'] } self.external_env = ExternalEnv(**self.kwargs)
def test_target_entity_type_argument_is_None(self): """testing if a TypeError will be raised when the target_entity_type argument is given as None """ self.kwargs["target_entity_type"] = None with pytest.raises(TypeError) as cm: FilenameTemplate(**self.kwargs) assert str(cm.value) == \ 'FilenameTemplate.target_entity_type can not be None'
def test_target_entity_type_argument_is_skipped(self): """testing if a TypeError will be raised when the target_entity_type argument is skipped """ self.kwargs.pop("target_entity_type") with pytest.raises(TypeError) as cm: FilenameTemplate(**self.kwargs) assert str(cm.value) == \ 'FilenameTemplate.target_entity_type can not be None'
def accept(self): """the overridden accept method """ target_entity_type = self.target_entity_type_combo_box.currentText() if not self.name_line_edit.is_valid: QtWidgets.QMessageBox.critical(self, 'Error', 'Please fix <b>name</b> field!') return name = self.name_line_edit.text() path = self.path_line_edit.text() if path == '': QtWidgets.QMessageBox.critical(self, 'Error', 'Please fix <b>path</b> field!') return filename = self.filename_line_edit.text() if path == '': QtWidgets.QMessageBox.critical( self, 'Error', 'Please fix <b>filename</b> field!') return logged_in_user = self.get_logged_in_user() from stalker.db.session import DBSession if self.mode == 'Create': try: from stalker import FilenameTemplate # create a new FilenameTemplate ft = FilenameTemplate(name=name, path=path, filename=filename, target_entity_type=target_entity_type, created_by=logged_in_user) self.filename_template = ft DBSession.add(ft) DBSession.commit() except Exception as e: DBSession.rollback() QtWidgets.QMessageBox.critical(self, 'Error', str(e)) return elif self.mode == 'Update': try: self.filename_template.name = name self.filename_template.path = path self.filename_template.filename = filename self.filename_template.updated_by = logged_in_user DBSession.add(self.filename_template) DBSession.commit() except Exception as e: DBSession.rollback() QtWidgets.QMessageBox.critical(self, 'Error', str(e)) return super(MainDialog, self).accept()
def test_target_entity_type_argument_is_None(self): """testing if a TypeError will be raised when the target_entity_type argument is given as None """ self.kwargs["target_entity_type"] = None with self.assertRaises(TypeError) as cm: FilenameTemplate(**self.kwargs) self.assertEqual( str(cm.exception), 'FilenameTemplate.target_entity_type can not be None')
def test_target_entity_type_argument_is_skipped(self): """testing if a TypeError will be raised when the target_entity_type argument is skipped """ self.kwargs.pop("target_entity_type") with self.assertRaises(TypeError) as cm: FilenameTemplate(**self.kwargs) self.assertEqual( str(cm.exception), 'FilenameTemplate.target_entity_type can not be None')
def test_filename_argument_is_not_string(self): """testing if a TypeError will be raised when filename argument is not string """ test_value = list("a list from a string") self.kwargs["filename"] = test_value with pytest.raises(TypeError) as cm: FilenameTemplate(**self.kwargs) assert str(cm.value) == \ 'FilenameTemplate.filename attribute should be string not list'
def test_inequality(self): """testing the inequality of FilenameTemplate objects """ ft1 = FilenameTemplate(**self.kwargs) new_entity = Entity(**self.kwargs) self.kwargs["target_entity_type"] = "Entity" ft2 = FilenameTemplate(**self.kwargs) self.kwargs["path"] = "different path" ft3 = FilenameTemplate(**self.kwargs) self.kwargs["filename"] = "different filename" ft4 = FilenameTemplate(**self.kwargs) self.assertFalse(self.filename_template != ft1) self.assertTrue(self.filename_template != new_entity) self.assertTrue(ft1 != ft2) self.assertTrue(ft2 != ft3) self.assertTrue(ft3 != ft4)
def test_path_argument_is_not_string(self): """testing if a TypeError will be raised when the path argument is not a string """ test_value = list("a list from a string") self.kwargs["path"] = test_value with self.assertRaises(TypeError) as cm: FilenameTemplate(**self.kwargs) self.assertEqual( str(cm.exception), 'FilenameTemplate.path attribute should be string not list')
def test_inequality(self): """testing the inequality of FilenameTemplate objects """ ft1 = FilenameTemplate(**self.kwargs) from stalker import Entity new_entity = Entity(**self.kwargs) self.kwargs["target_entity_type"] = "Entity" ft2 = FilenameTemplate(**self.kwargs) self.kwargs["path"] = "different path" ft3 = FilenameTemplate(**self.kwargs) self.kwargs["filename"] = "different filename" ft4 = FilenameTemplate(**self.kwargs) assert not self.filename_template != ft1 assert self.filename_template != new_entity assert ft1 != ft2 assert ft2 != ft3 assert ft3 != ft4
def test_equality(self): """testing the equality of FilenameTemplate objects """ ft1 = FilenameTemplate(**self.kwargs) from stalker import Entity new_entity = Entity(**self.kwargs) self.kwargs["target_entity_type"] = "Entity" ft2 = FilenameTemplate(**self.kwargs) self.kwargs["path"] = "different path" ft3 = FilenameTemplate(**self.kwargs) self.kwargs["filename"] = "different filename" ft4 = FilenameTemplate(**self.kwargs) self.assertTrue(self.filename_template == ft1) self.assertFalse(self.filename_template == new_entity) self.assertFalse(ft1 == ft2) self.assertFalse(ft2 == ft3) self.assertFalse(ft3 == ft4)
def setUp(self): """setup the test """ self.kwargs = { "name": "Test FilenameTemplate", "type": Type( name="Test Type", code='tt', target_entity_type="FilenameTemplate" ), "path": "ASSETS/{{asset.code}}/{{task.type.code}}/", "filename": "{{asset.code}}_{{version.take}}_{{task.type.code}}_" \ "{{version.version}}_{{user.initials}}", "output_path": "", "target_entity_type": Asset, } self.filename_template = FilenameTemplate(**self.kwargs)
def setUp(self): """setup the test """ super(FilenameTemplateTester, self).setUp() from stalker import db, Type, Asset, FilenameTemplate self.kwargs = { "name": "Test FilenameTemplate", "type": Type( name="Test Type", code='tt', target_entity_type="FilenameTemplate" ), "path": "ASSETS/{{asset.code}}/{{task.type.code}}/", "filename": "{{asset.code}}_{{version.take}}_{{task.type.code}}_" \ "{{version.version}}_{{user.initials}}", "output_path": "", "target_entity_type": Asset, } self.filename_template = FilenameTemplate(**self.kwargs) db.DBSession.add(self.filename_template) db.DBSession.commit()
def setUp(self): """setup the tests """ # ----------------------------------------------------------------- # start of the setUp # create the environment variable and point it to a temp directory db.setup() db.init() self.temp_repo_path = tempfile.mkdtemp() self.user1 = User(name='User 1', login='******', email='*****@*****.**', password='******') db.DBSession.add(self.user1) db.DBSession.commit() # login as self.user1 from stalker import LocalSession local_session = LocalSession() local_session.store_user(self.user1) local_session.save() self.repo1 = Repository(name='Test Project Repository', linux_path=self.temp_repo_path, windows_path=self.temp_repo_path, osx_path=self.temp_repo_path) self.status_new = Status.query.filter_by(code='NEW').first() self.status_wip = Status.query.filter_by(code='WIP').first() self.status_comp = Status.query.filter_by(code='CMPL').first() self.task_template = FilenameTemplate( name='Task Template', target_entity_type='Task', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.asset_template = FilenameTemplate( name='Asset Template', target_entity_type='Asset', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.shot_template = FilenameTemplate( name='Shot Template', target_entity_type='Shot', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.sequence_template = FilenameTemplate( name='Sequence Template', target_entity_type='Sequence', path='{{project.code}}/' '{%- for parent_task in parent_tasks -%}' '{{parent_task.nice_name}}/' '{%- endfor -%}', filename='{{version.nice_name}}' '_v{{"%03d"|format(version.version_number)}}', ) self.structure = Structure(name='Project Struture', templates=[ self.task_template, self.asset_template, self.shot_template, self.sequence_template ]) self.project_status_list = StatusList( name='Project Statuses', target_entity_type='Project', statuses=[self.status_new, self.status_wip, self.status_comp]) self.image_format = ImageFormat(name='HD 1080', width=1920, height=1080, pixel_aspect=1.0) # create a test project self.project = Project(name='Test Project', code='TP', repository=self.repo1, status_list=self.project_status_list, structure=self.structure, image_format=self.image_format) self.task_status_list =\ StatusList.query.filter_by(target_entity_type='Task').first() self.asset_status_list =\ StatusList.query.filter_by(target_entity_type='Asset').first() self.shot_status_list =\ StatusList.query.filter_by(target_entity_type='Shot').first() self.sequence_status_list =\ StatusList.query.filter_by(target_entity_type='Sequence').first() self.character_type = Type(name='Character', code='CHAR', target_entity_type='Asset') # create a test series of root task self.task1 = Task(name='Test Task 1', project=self.project) self.task2 = Task(name='Test Task 2', project=self.project) self.task3 = Task(name='Test Task 3', project=self.project) # then a couple of child tasks self.task4 = Task(name='Test Task 4', parent=self.task1) self.task5 = Task(name='Test Task 5', parent=self.task1) self.task6 = Task(name='Test Task 6', parent=self.task1) # create a root asset self.asset1 = Asset(name='Asset 1', code='asset1', type=self.character_type, project=self.project) # create a child asset self.asset2 = Asset(name='Asset 2', code='asset2', type=self.character_type, parent=self.task4) # create a root Sequence self.sequence1 = Sequence(name='Sequence1', code='SEQ1', project=self.project) # create a child Sequence self.sequence2 = Sequence(name='Sequence2', code='SEQ2', parent=self.task2) # create a root Shot self.shot1 = Shot(name='SH001', code='SH001', project=self.project) # create a child Shot (child of a Sequence) self.shot2 = Shot(name='SH002', code='SH002', parent=self.sequence1) # create a child Shot (child of a child Sequence) self.shot3 = Shot(name='SH003', code='SH003', parent=self.sequence2) # commit everything db.DBSession.add_all([ self.repo1, self.status_new, self.status_wip, self.status_comp, self.project_status_list, self.project, self.task_status_list, self.asset_status_list, self.shot_status_list, self.sequence_status_list, self.task1, self.task2, self.task3, self.task4, self.task5, self.task6, self.asset1, self.asset2, self.shot1, self.shot2, self.shot3, self.sequence1, self.sequence2, self.task_template, self.asset_template, self.shot_template, self.sequence_template ]) db.DBSession.commit() # now create versions def create_version(task, take_name): """Creates a new version :param task: the task :param take_name: the take_name name :return: the version """ # just renew the scene #pymel.core.newFile(force=True) v = Version(task=task, take_name=take_name) v.update_paths() db.DBSession.add(v) db.DBSession.commit() #self.maya_env.save_as(v) return v # asset2 self.version1 = create_version(self.asset2, 'Main') self.version2 = create_version(self.asset2, 'Main') self.version3 = create_version(self.asset2, 'Main') self.version3.description = 'Test Description' self.version4 = create_version(self.asset2, 'Take1') self.version5 = create_version(self.asset2, 'Take1') self.version6 = create_version(self.asset2, 'Take1') # task5 self.version7 = create_version(self.task5, 'Main') self.version8 = create_version(self.task5, 'Main') self.version9 = create_version(self.task5, 'Main') self.version10 = create_version(self.task5, 'Take1') self.version11 = create_version(self.task5, 'Take1') self.version12 = create_version(self.task5, 'Take1') # task6 self.version13 = create_version(self.task6, 'Main') self.version14 = create_version(self.task6, 'Main') self.version15 = create_version(self.task6, 'Main') self.version16 = create_version(self.task6, 'Take1') self.version17 = create_version(self.task6, 'Take1') self.version18 = create_version(self.task6, 'Take1') # shot3 self.version19 = create_version(self.shot3, 'Main') self.version20 = create_version(self.shot3, 'Main') self.version21 = create_version(self.shot3, 'Main') self.version22 = create_version(self.shot3, 'Take1') self.version23 = create_version(self.shot3, 'Take1') self.version24 = create_version(self.shot3, 'Take1') # task3 self.version25 = create_version(self.task3, 'Main') self.version26 = create_version(self.task3, 'Main') self.version27 = create_version(self.task3, 'Main') self.version28 = create_version(self.task3, 'Take1') self.version29 = create_version(self.task3, 'Take1') self.version30 = create_version(self.task3, 'Take1') # asset1 self.version31 = create_version(self.asset1, 'Main') self.version32 = create_version(self.asset1, 'Main') self.version33 = create_version(self.asset1, 'Main') self.version34 = create_version(self.asset1, 'Take1') self.version35 = create_version(self.asset1, 'Take1') self.version36 = create_version(self.asset1, 'Take1') # shot2 self.version37 = create_version(self.shot2, 'Main') self.version38 = create_version(self.shot2, 'Main') self.version39 = create_version(self.shot2, 'Main') self.version40 = create_version(self.shot2, 'Take1') self.version41 = create_version(self.shot2, 'Take1') self.version42 = create_version(self.shot2, 'Take1') # shot1 self.version43 = create_version(self.shot1, 'Main') self.version44 = create_version(self.shot1, 'Main') self.version45 = create_version(self.shot1, 'Main') self.version46 = create_version(self.shot1, 'Take1') self.version47 = create_version(self.shot1, 'Take1') self.version48 = create_version(self.shot1, 'Take1') # +- task1 # | | # | +- task4 # | | | # | | +- asset2 # | | +- Main # | | | +- version1 # | | | +- version2 (P) # | | | +- version3 (P) # | | +- Take1 # | | +- version4 (P) # | | +- version5 # | | +- version6 (P) # | | # | +- task5 # | | +- Main # | | | +- version7 # | | | +- version8 # | | | +- version9 # | | +- Take1 # | | +- version10 # | | +- version11 # | | +- version12 (P) # | | # | +- task6 # | +- Main # | | +- version13 # | | +- version14 # | | +- version15 # | +- Take1 # | +- version16 (P) # | +- version17 # | +- version18 (P) # | # +- task2 # | | # | +- sequence2 # | | # | +- shot3 # | +- Main # | | +- version19 # | | +- version20 # | | +- version21 # | +- Take1 # | +- version22 # | +- version23 # | +- version24 # | # +- task3 # | +- Main # | | +- version25 # | | +- version26 # | | +- version27 # | +- Take1 # | +- version28 # | +- version29 # | +- version30 # | # +- asset1 # | +- Main # | | +- version31 # | | +- version32 # | | +- version33 # | +- Take1 # | +- version34 # | +- version35 # | +- version36 # | # +- sequence1 # | | # | +- shot2 # | +- Main # | | +- version37 # | | +- version38 # | | +- version39 # | +- Take1 # | +- version40 # | +- version41 # | +- version42 # | # +- shot1 # +- Main # | +- version43 # | +- version44 # | +- version45 # +- Take1 # +- version46 # +- version47 # +- version48 # Start Condition: # # version15 # version12 # version5 # version2 -> has new published version (version3) # version5 -> Referenced a second time # version2 -> has new published version (version3) # version12 -> Referenced a second time # version5 # version2 -> has new published version (version3) # version5 # version2 -> has new published version (version3) # version45 -> no change # version48 -> no change # # Expected Final Result # version15A -> Derived from version15 # version12A -> Derived from version12 # version5A -> Derived from version5 # version3 -> has new published version (version3) # version5A -> Derived from version5 # version3 -> has new published version (version3) # version12A -> Derived from version12 - The second reference # version5A -> Derived from version5 # version3 -> has new published version (version3) # version5A -> Derived from version5 # version3 -> has new published version (version3) # version45 -> no change # version48 -> no change # create a deep relation self.version2.is_published = True self.version3.is_published = True # new scene # version5 references version2 self.version5.inputs.append(self.version2) self.version5.is_published = True # version12 references version5 self.version12.inputs.append(self.version5) self.version12.is_published = True # version45 references version48 self.version45.is_published = True self.version48.is_published = True self.version45.inputs.append(self.version48) # version15 references version12 and version48 self.version15.inputs.append(self.version12) self.version15.inputs.append(self.version45) # reference_resolution self.reference_resolution = { 'root': [self.version12, self.version45], 'leave': [self.version48, self.version45], 'update': [self.version2], 'create': [self.version5, self.version12] } # create a buffer for extra created files, which are to be removed self.remove_these_files_buffer = [] self.test_environment = TestEnvironment(name='Test Environment') self.test_environment._version = self.version15 if not QtGui.QApplication.instance(): logger.debug('creating a new QApplication') self.app = QtGui.QApplication(sys.argv) else: logger.debug('using the present QApplication: %s' % QtGui.qApp) # self.app = QtGui.qApp self.app = QtGui.QApplication.instance() self.dialog = version_updater.MainDialog( environment=self.test_environment, reference_resolution=self.reference_resolution)
def test_filename_argument_is_skipped(self): """testing if nothing happens when the filename argument is skipped """ self.kwargs.pop("filename") ft = FilenameTemplate(**self.kwargs) assert isinstance(ft, FilenameTemplate)
# fill in default data db.init() # create a new repository repo = Repository(name='Test Repository', linux_path='/mnt/T/stalker_tests/', osx_path='/Volumes/T/stalker_tests/', windows_path='T:/stalker_tests/') # create a Structure for our flat project flat_task_template = FilenameTemplate( name='Flat Task Template', target_entity_type='Task', path='{{project.code}}', # everything will be under the same folder filename='{{task.nice_name}}_{{version.take_name}}' '_v{{"%03d"|format(version.version_number)}}{{extension}}' # you can customize this as you wish, you can even use a uuid4 # as the file name ) flat_struct = Structure( name='Flat Project Structure', templates=[flat_task_template] # we need another template for Assets, # Shots and Sequences but I'm skipping it # for now ) # query a couple of statuses status_new = Status.query.filter_by(code='NEW').first() status_wip = Status.query.filter_by(code='WIP').first()
def create_empty_project(): """creates empty project test data """ from stalker.db.session import DBSession from stalker import (Task, Asset, Type, Sequence, Shot, Version, FilenameTemplate, Repository, Project, Structure) repo = Repository(name='Test Repository', code='TR', windows_path='T:/', linux_path='/mnt/T/', osx_path='/Volumes/T/') task_filename_template = FilenameTemplate( name='Task Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Task') asset_filename_template = FilenameTemplate( name='Asset Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Asset') shot_filename_template = FilenameTemplate( name='Shot Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Shot') sequence_filename_template = FilenameTemplate( name='Sequence Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Sequence') structure = Structure(name='Default Project Structure', templates=[ task_filename_template, asset_filename_template, shot_filename_template, sequence_filename_template ]) DBSession.add_all([ structure, task_filename_template, asset_filename_template, shot_filename_template, sequence_filename_template ]) DBSession.commit() project = Project( name='Test Project', code='TP', repository=repo, structure=structure, ) DBSession.add(project) DBSession.commit() yield project
def create_project(): """creates test data """ from stalker.db.session import DBSession from stalker import (Task, Asset, Type, Sequence, Shot, Version, FilenameTemplate, Repository, Project, Structure) repo = Repository(name='Test Repository', code='TR', windows_path='T:/', linux_path='/mnt/T/', osx_path='/Volumes/T/') task_filename_template = FilenameTemplate( name='Task Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Task') asset_filename_template = FilenameTemplate( name='Asset Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Asset') shot_filename_template = FilenameTemplate( name='Shot Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Shot') sequence_filename_template = FilenameTemplate( name='Sequence Filename Template', path='$REPO{{project.repository.code}}/{{project.code}}/' '{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}' '/{%- endfor -%}', filename= '{{version.nice_name}}_v{{"%03d"|format(version.version_number)}}', target_entity_type='Sequence') structure = Structure(name='Default Project Structure', templates=[ task_filename_template, asset_filename_template, shot_filename_template, sequence_filename_template ]) DBSession.add_all([ structure, task_filename_template, asset_filename_template, shot_filename_template, sequence_filename_template ]) DBSession.commit() project = Project( name='Test Project', code='TP', repository=repo, structure=structure, ) DBSession.add(project) DBSession.commit() assets_task = Task(name='Assets', project=project) characters_task = Task(name='Characters', parent=assets_task) props_task = Task(name='Props', parent=assets_task) environments_task = Task(name='Environments', parent=assets_task) sequences_task = Task(name='Sequences', project=project) # Asset Types char_type = Type(name='Character', code='Char', target_entity_type='Asset') prop_type = Type(name='Prop', code='Prop', target_entity_type='Asset') exterior_type = Type(name='Exterior', code='Exterior', target_entity_type='Asset') interior_type = Type(name='Interior', code='Interior', target_entity_type='Asset') # Task Types model_type = Type(name='Model', code='Model', target_entity_type='Task') look_dev_type = Type(name='Look Development', code='LookDev', target_entity_type='Task') rig_type = Type(name='Rig', code='Rig', target_entity_type='Task') layout_type = Type(name='Layout', code='Layout', target_entity_type='Task') anim_type = \ Type(name='Animation', code='Animation', target_entity_type='Task') camera_type = Type(name='Camera', code='Camera', target_entity_type='Task') plate_type = Type(name='Plate', code='Plate', target_entity_type='Task') fx_type = Type(name='FX', code='FX', target_entity_type='Task') lighting_type = \ Type(name='Lighting', code='Lighting', target_entity_type='Task') comp_type = Type(name='Comp', code='Comp', target_entity_type='Task') DBSession.add_all([ char_type, prop_type, exterior_type, interior_type, model_type, look_dev_type, rig_type, layout_type, anim_type, camera_type, plate_type, fx_type, lighting_type, comp_type ]) DBSession.commit() # char1 char1 = Asset(name='Char1', code='Char1', parent=characters_task, type=char_type) model = Task(name='Model', type=model_type, parent=char1) look_dev_task = Task(name='LookDev', type=look_dev_type, parent=char1) rig = Task(name='Rig', type=rig_type, parent=char1) DBSession.add_all([char1, model, look_dev_task, rig]) DBSession.commit() # char2 char2 = Asset(name='Char2', code='Char2', parent=characters_task, type=char_type) model = Task(name='Model', type=model_type, parent=char2) look_dev_task = Task(name='LookDev', type=look_dev_type, parent=char2) rig = Task(name='Rig', type=rig_type, parent=char2) DBSession.add_all([char2, model, look_dev_task, rig]) DBSession.commit() # prop1 prop1 = \ Asset(name='Prop2', code='Prop2', parent=props_task, type=prop_type) model = Task(name='Model', type=model_type, parent=prop1) look_dev_task = Task(name='LookDev', type=look_dev_type, parent=prop1) DBSession.add_all([prop1, model, look_dev_task]) DBSession.commit() # prop2 prop2 = \ Asset(name='Prop2', code='Prop2', parent=props_task, type=prop_type) model = Task(name='Model', type=model_type, parent=prop2) look_dev_task = Task(name='LookDev', type=look_dev_type, parent=prop2) DBSession.add_all([prop2, model, look_dev_task]) DBSession.commit() # environments # env1 env1 = Asset(name='Env1', code='Env1', type=exterior_type, parent=environments_task) layout_task = Task(name='Layout', type=layout_type, parent=env1) props_task = Task(name='Props', parent=env1) yapi1_asset = \ Asset(name='Yapi1', code='Yapi1', type=prop_type, parent=props_task) model_task = Task(name='Model', type=model_type, parent=yapi1_asset) look_dev_task = \ Task(name='LookDev', type=look_dev_type, parent=yapi1_asset) DBSession.add_all([ env1, layout_task, props_task, yapi1_asset, model_task, look_dev_task ]) DBSession.commit() # env2 env2 = Asset(name='Env2', code='Env2', type=exterior_type, parent=environments_task) layout_task = Task(name='Layout', type=layout_type, parent=env2) props_task = Task(name='Props', parent=env2) yapi1_asset = \ Asset(name='Yapi2', code='Yapi2', type=prop_type, parent=props_task) model_task = Task(name='Model', type=model_type, parent=yapi1_asset) look_dev_task = \ Task(name='LookDev', type=look_dev_type, parent=yapi1_asset) DBSession.add_all([ env2, layout_task, props_task, yapi1_asset, model_task, look_dev_task ]) DBSession.commit() # sequences and shots seq1 = Sequence(name='Seq1', code='Seq1', parent=sequences_task) edit_task = Task(name='Edit', parent=seq1) shots_task = Task(name='Shots', parent=seq1) DBSession.add_all([seq1, edit_task, shots_task]) DBSession.commit() # shot1 shot1 = Shot(name='Seq001_001_0010', code='Seq001_001_0010', sequences=[seq1], parent=shots_task) anim_task = Task(name='Anim', type=anim_type, parent=shot1) camera_task = Task(name='Camera', type=camera_type, parent=shot1) plate_task = Task(name='Plate', type=plate_type, parent=shot1) fx_task = Task(name='FX', type=fx_type, parent=shot1) lighting_task = Task(name='Lighting', type=lighting_type, parent=shot1) comp_task = Task(name='Comp', type=comp_type, parent=shot1) DBSession.add_all([ shot1, anim_task, camera_task, plate_task, fx_task, lighting_task, comp_task ]) DBSession.commit() # shot2 shot2 = Shot(name='Seq001_001_0020', code='Seq001_001_0020', sequences=[seq1], parent=shots_task) anim_task = Task(name='Anim', type=anim_type, parent=shot2) camera_task = Task(name='Camera', type=camera_type, parent=shot2) plate_task = Task(name='Plate', type=plate_type, parent=shot2) fx_task = Task(name='FX', type=fx_type, parent=shot2) lighting_task = Task(name='Lighting', type=lighting_type, parent=shot2) comp_task = Task(name='Comp', type=comp_type, parent=shot2) DBSession.add_all([ shot2, anim_task, camera_task, plate_task, fx_task, lighting_task, comp_task ]) DBSession.commit() # shot3 shot3 = Shot(name='Seq001_001_0030', code='Seq001_001_0030', sequences=[seq1], parent=shots_task) anim_task = Task(name='Anim', type=anim_type, parent=shot3) camera_task = Task(name='Camera', type=camera_type, parent=shot3) plate_task = Task(name='Plate', type=plate_type, parent=shot3) fx_task = Task(name='FX', type=fx_type, parent=shot3) lighting_task = Task(name='Lighting', type=lighting_type, parent=shot3) comp_task = Task(name='Comp', type=comp_type, parent=shot3) DBSession.add_all([ shot3, anim_task, camera_task, plate_task, fx_task, lighting_task, comp_task ]) DBSession.commit() # Seq2 # sequences and shots seq2 = Sequence(name='Seq2', code='Seq2', parent=sequences_task) edit_task = Task(name='Edit', parent=seq2) shots_task = Task(name='Shots', parent=seq2) DBSession.add_all([seq2, edit_task, shots_task]) DBSession.commit() # shot1 shot1 = Shot(name='Seq002_001_0010', code='Seq002_001_0010', sequences=[seq2], parent=shots_task) anim_task = Task(name='Anim', type=anim_type, parent=shot1) camera_task = Task(name='Camera', type=camera_type, parent=shot1) plate_task = Task(name='Plate', type=plate_type, parent=shot1) fx_task = Task(name='FX', type=fx_type, parent=shot1) lighting_task = Task(name='Lighting', type=lighting_type, parent=shot1) comp_task = Task(name='Comp', type=comp_type, parent=shot1) DBSession.add_all([ shot1, anim_task, camera_task, plate_task, fx_task, lighting_task, comp_task ]) DBSession.commit() # shot2 shot2 = Shot(name='Seq002_001_0020', code='Seq002_001_0020', sequences=[seq2], parent=shots_task) anim_task = Task(name='Anim', type=anim_type, parent=shot2) camera_task = Task(name='Camera', type=camera_type, parent=shot2) plate_task = Task(name='Plate', type=plate_type, parent=shot2) fx_task = Task(name='FX', type=fx_type, parent=shot2) lighting_task = Task(name='Lighting', type=lighting_type, parent=shot2) comp_task = Task(name='Comp', type=comp_type, parent=shot2) DBSession.add_all([ shot2, anim_task, camera_task, plate_task, fx_task, lighting_task, comp_task ]) DBSession.commit() # shot3 shot3 = Shot(name='Seq002_001_0030', code='Seq002_001_0030', sequences=[seq2], parent=shots_task) anim_task = Task(name='Anim', type=anim_type, parent=shot3) camera_task = Task(name='Camera', type=camera_type, parent=shot3) plate_task = Task(name='Plate', type=plate_type, parent=shot3) fx_task = Task(name='FX', type=fx_type, parent=shot3) lighting_task = Task(name='Lighting', type=lighting_type, parent=shot3) comp_task = Task(name='Comp', type=comp_type, parent=shot3) DBSession.add_all([ shot3, anim_task, camera_task, plate_task, fx_task, lighting_task, comp_task ]) DBSession.commit() yield project
def test_target_entity_type_argument_accepts_Classes(self): """testing if the target_entity_type can be set to a class directly """ self.kwargs["target_entity_type"] = 'Asset' new_filenameTemplate = FilenameTemplate(**self.kwargs)