def test_sequences_comboBox_is_filled_with_sequences_from_the_current_project(
self):
"""testing if the sequences_comboBox is filled with the correct
sequences from the currently chosen Project instance
"""
project1 = Project("Test Project 1")
project2 = Project("Test Project 2")
project1.create()
project2.create()
project1.save()
project2.save()
seq1 = Sequence(project1, "Test Sequence 1")
seq1.save()
seq2 = Sequence(project1, "Test Sequence 2")
seq2.save()
seq3 = Sequence(project2, "Test Sequence 3")
seq3.save()
seq4 = Sequence(project2, "Test Sequence 4")
seq4.save()
# create dialog
dialog = project_manager.MainDialog()
# self.show_dialog(dialog)
# set the project to project2
index = dialog.projects_comboBox.findText(project2.name)
dialog.projects_comboBox.setCurrentIndex(index)
# check if the sequences_comboBox is filled with correct data
self.assertEqual(dialog.sequences_comboBox.count(), 2)
item_texts = []
for i in range(2):
dialog.sequences_comboBox.setCurrentIndex(i)
item_texts.append(dialog.sequences_comboBox.currentText())
self.assertTrue(seq3.name in item_texts)
self.assertTrue(seq4.name in item_texts)
# set the project to project1
index = dialog.projects_comboBox.findText(project1.name)
dialog.projects_comboBox.setCurrentIndex(index)
# check if the sequences_comboBox is filled with correct data
self.assertEqual(dialog.sequences_comboBox.count(), 2)
item_texts = []
for i in range(2):
dialog.sequences_comboBox.setCurrentIndex(i)
item_texts.append(dialog.sequences_comboBox.currentText())
self.assertTrue(seq1.name in item_texts)
self.assertTrue(seq2.name in item_texts)
def test_code_argument_is_not_unique_for_same_project(self):
"""testing if the code argument is not unique raises IntegrityError
"""
test_project = Project("Test Project for Name Uniqueness")
test_project.save()
test_seq1 = Sequence(test_project, "Seq1A", "SEQ1")
test_seq1.save()
test_seq2 = Sequence(test_project, "Seq1B", "SEQ1")
self.assertRaises(IntegrityError, test_seq2.save)
def test_sequences_comboBox_caches_Sequence_instances_in_sequences_attribute(
self):
"""testing if the sequence_comboBox caches the Sequence instances in
an attribute called Sequence
"""
project1 = Project("Test Project 1")
project1.create()
project2 = Project("Test Project 2")
project2.create()
seq1 = Sequence(project1, "Test Sequence 1")
seq1.save()
seq2 = Sequence(project1, "Test Sequence 2")
seq2.save()
seq3 = Sequence(project2, "Test Sequence 3")
seq3.save()
seq4 = Sequence(project2, "Test Sequence 4")
seq4.save()
seq5 = Sequence(project2, "Test Sequence 5")
seq5.save()
dialog = project_manager.MainDialog()
self.assertTrue(hasattr(dialog.sequences_comboBox, "sequences"))
# set it to project1
index = dialog.projects_comboBox.findText(project1.name)
dialog.projects_comboBox.setCurrentIndex(index)
# check if sequences_comboBox.sequences has 3 elements
self.assertEqual(len(dialog.sequences_comboBox.sequences), 2)
# check if all the sequences are there
self.assertTrue(seq1 in dialog.sequences_comboBox.sequences)
self.assertTrue(seq2 in dialog.sequences_comboBox.sequences)
# set it to project2
index = dialog.projects_comboBox.findText(project2.name)
dialog.projects_comboBox.setCurrentIndex(index)
# check if sequences_comboBox.sequences has 3 elements
self.assertEqual(len(dialog.sequences_comboBox.sequences), 3)
# check if all the sequences are there
self.assertTrue(seq3 in dialog.sequences_comboBox.sequences)
self.assertTrue(seq4 in dialog.sequences_comboBox.sequences)
self.assertTrue(seq5 in dialog.sequences_comboBox.sequences)
def test_add_alternative_shot_is_working_properly(self):
"""testing if the add_alternative_shot method is working properly
"""
new_proj = Project("Test Project")
new_proj.create()
new_seq = Sequence(new_proj, "Test Sequence", "TEST_SEQ1")
new_seq.save()
new_shot = Shot(new_seq, 1)
new_shot.save()
# check if the sequence has only one shot
self.assertEqual(len(new_seq.shots), 1)
# now create an alternative to this shot
new_seq.add_alternative_shot(1)
# now check if the sequence has two shots
self.assertEqual(len(new_seq.shots), 2)
# and the second shots number is 1A
self.assertEqual(new_seq.shots[1].number, "1A")
# add a new alternative
new_seq.add_alternative_shot("1")
# check if there is three shots
self.assertEqual(len(new_seq.shots), 3)
# and the third shots number is 1B
self.assertEqual(new_seq.shots[2].number, "1B")
def test_edit_shot_button_opens_up_shot_editor_with_the_given_shot(self):
"""testing if hitting the edit shot button opens up the shot_editor
dialog
"""
proj1 = Project('Test Project')
proj1.save()
seq1 = Sequence(proj1, 'Test Sequence')
seq1.save()
shot = Shot(seq1, 1, 2, 435)
shot.handle_at_start = 23
shot.handle_at_end = 12
shot.save()
dialog1 = project_manager.MainDialog()
# self.show_dialog(dialog1)
# hit to the edit shot button
# QTest.mouseClick(
# dialog1.edit_shot_pushButton,
# QtCore.Qt.LeftButton
# )
# check if the shot_editor dialog is opened
# HOW ????
self.fail('test is not finished yet')
def new_sequence_pushButton_clicked(self):
"""runs when new_sequence_pushButton is clicked
"""
project = self.get_current_project()
if project is None:
return
dialog = QtGui.QInputDialog()
new_sequence_name, ok = dialog.getText(self, "Add Sequence",
"New Sequence Name")
if ok:
if new_sequence_name != "":
new_sequence = Sequence(project, new_sequence_name)
new_sequence.save()
new_sequence.create()
# update sequence_comboBox
self.update_sequences_comboBox()
# set it to the new project
index = self.sequences_comboBox.findText(new_sequence.name)
self.sequences_comboBox.setCurrentIndex(index)
def test_database_simple_data(self):
"""testing if the database file has the necessary information related to
the Sequence
"""
new_proj = Project(name="TEST_PROJECT")
new_proj.create()
test_seq_name = "TEST_SEQ1"
new_seq = Sequence(new_proj, test_seq_name)
new_seq.save()
new_seq.create()
# fill it with some non default values
description = new_seq.description = "Test description"
new_seq.save()
# now check if the database is created correctly
del new_seq
# create the seq from scratch and let it read the database
new_seq = db.session.query(Sequence).first()
# now check if it was able to get these data
self.assertEqual(description, new_seq.description)
def test_create_project_structure_pushButton_creates_project_structure(
self):
"""testing if using the create_project_pushButton creates the project
structure
"""
# create a project
proj = Project("Test Project")
proj.save()
# create a sequence
seq = Sequence(proj, "Sequence")
seq.save()
# create a shot
shot = Shot(seq, 1)
shot.save()
# check if there is no shot folder
project_path = os.path.join(self.temp_projects_folder,
"Test_Project/Shots/SH001")
self.assertFalse(os.path.exists(project_path))
# hit create_structure_pushButton
dialog = project_manager.MainDialog()
QTest.mouseClick(dialog.create_project_structure_pushButton,
Qt.LeftButton)
# check if the shot folder has been created
self.assertTrue(os.path.exists(project_path))
def test_code_argument_is_not_unique_for_different_projects(self):
"""testing if no code argument is unique for different projects will
not raise IntegrityError
"""
test_project1 = Project("Test Project for Name Uniqueness 1")
test_project1.save()
test_project2 = Project("Test Project for Name Uniqueness 2")
test_project2.save()
test_seq1 = Sequence(test_project1, "SEQ1A", "SEQ1A")
test_seq1.save()
test_seq2 = Sequence(test_project2, "SEQ1B", "SEQ1A")
test_seq2.save() # no Integrity Error
def test_deleting_a_sequence_will_also_delete_the_related_shots(self):
"""testing if deleting a sequence will also delete the related shots
"""
proj1 = Project('Test Project 1')
proj1.save()
seq1 = Sequence(proj1, 'Seq1')
seq1.save()
seq2 = Sequence(proj1, 'Seq2')
seq2.save()
shot1 = Shot(seq1, 1)
shot1.save()
shot2 = Shot(seq1, 2)
shot2.save()
shot3 = Shot(seq2, 1)
shot3.save()
shot4 = Shot(seq2, 2)
shot4.save()
# check if they are in session
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(seq2, db.session)
self.assertIn(shot1, db.session)
self.assertIn(shot2, db.session)
self.assertIn(shot3, db.session)
self.assertIn(shot4, db.session)
# delete seq1
db.session.delete(seq1)
db.session.commit()
# check if all the objects which must be deleted are really deleted
self.assertNotIn(seq1, db.session)
self.assertNotIn(shot1, db.session)
self.assertNotIn(shot2, db.session)
# and others are in
self.assertIn(proj1, db.session)
self.assertIn(seq2, db.session)
self.assertIn(shot3, db.session)
self.assertIn(shot4, db.session)
def test_name_argument_is_working_properly(self):
"""testing if the name attribute is set properly with the given value
for the name argument
"""
test_value = "Test Sequence With Name"
self.kwargs["name"] = test_value
new_seq = Sequence(**self.kwargs)
self.assertEqual(new_seq.name, test_value)
def test_code_argument_is_skipped(self):
"""testing if the code attribute will equal to name argument if it is
skipped
"""
self.kwargs.pop("code")
self.kwargs["name"] = "Test Sequence"
expected_value = "Test_Sequence"
new_seq1 = Sequence(**self.kwargs)
self.assertEqual(new_seq1.code, expected_value)
def test_name_argument_formatting(self):
"""testing if the name will be formatted correctly when creating a
new project.
"""
for test_value in self._name_test_values:
self.kwargs["name"] = test_value[0]
expected_name = test_value[1]
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.name, expected_name)
def test_code_argument_is_None(self):
"""testing if the code argument is given as None the code attribute
will be set to the same value with the name attribute
"""
self.kwargs["code"] = None
self.kwargs["name"] = "Test Sequence"
expected_value = "Test_Sequence"
new_seq1 = Sequence(**self.kwargs)
self.assertEqual(new_seq1.code, expected_value)
def test_creating_two_different_sequences_and_calling_create(self):
"""testing if no error will be raised when creating two different
Sequences for the same Project and calling the Sequences.create()
in mixed order
"""
new_proj = Project(name="TEST_PROJECT")
new_proj.create()
new_seq1 = Sequence(new_proj, "TEST_SEQ1")
new_seq2 = Sequence(new_proj, "TEST_SEQ2")
new_seq1.save()
new_seq2.save()
# print "calling new_seq1.create"
new_seq1.create()
# print "calling new_seq2.create"
new_seq2.create()
def test_code_argument_is_not_unique_for_different_projects_2(self):
"""testing if no code argument is unique for different projects will
not raise IntegrityError
"""
p1 = Project("Migros Kanguru", "MIGROS_KANGURU")
p1.save()
p2 = Project("Migros M-Label", "MIGROS_M_LABEL")
p2.save()
s1 = Sequence(p2, "TVC", "TVC")
s1.save()
p3 = Project("Fairy Obelix Booster", "FAIRY_OBELIX_BOOSTER")
p3.save()
s2 = Sequence(p3, "TVC", "TVC")
s2.save()
def update_sequences_comboBox(self):
"""updates the sequences_comboBox according to the current project
"""
project = self.get_current_project()
sequences = Sequence.query()\
.filter(Sequence.project==project)\
.order_by(Sequence.name.asc())\
.all()
self.sequences_comboBox.sequences = sequences
self.sequences_comboBox.clear()
self.sequences_comboBox.addItems(map(lambda x: x.name, sequences))
def update_sequences_comboBox(self):
"""updates the sequences_comboBox according to the current project
"""
project = self.get_current_project()
sequences = Sequence.query()\
.filter(Sequence.project==project)\
.order_by(Sequence.name.asc())\
.all()
self.sequences_comboBox.sequences = sequences
self.sequences_comboBox.clear()
self.sequences_comboBox.addItems(map(lambda x: x.name, sequences))
def test_code_argument_is_formatted_correctly(self):
"""testing if the code attribute is formatted correctly on Sequence
instance creation
"""
self.kwargs["name"] = "TEST_SEQ1"
for test_value in self._name_test_values:
self.kwargs["code"] = test_value[0]
expected_value = test_value[2]
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.code, expected_value)
def test_database_recreation_of_sequence_object(self):
"""testing if the database file has the necessary information related to
the Sequence
"""
new_proj = Project(name="TEST_PROJECT")
new_proj.create()
test_seq_name = "TEST_SEQ1"
new_seq = Sequence(new_proj, test_seq_name)
new_seq.save()
description = new_seq.description
# now check if the database is created correctly
del new_seq
# create the seq from scratch and let it read the database
new_seq = Sequence(new_proj, test_seq_name)
# now check if it was able to get these data
self.assertEqual(new_seq.description, description)
def test___ne___operator(self):
"""testing the __ne__ (not equal) operator
"""
# create a new project and two sequence
# then create three new sequence objects to compare each of them
# with the other
new_proj = Project("TEST_PROJECT_FOR_NE_TEST")
new_proj.create()
seq1 = Sequence(new_proj, "SEQ1")
seq2 = Sequence(new_proj, "SEQ1")
seq3 = Sequence(new_proj, "SEQ2")
new_proj2 = Project("TEST_PROJECT2")
new_proj2.create()
seq4 = Sequence(new_proj2, "SEQ3")
self.assertFalse(seq1 != seq2)
self.assertTrue(seq1 != seq3)
self.assertTrue(seq1 != seq4)
self.assertTrue(seq3 != seq4)
def test_deleting_a_sequence_will_not_delete_the_related_project(self):
"""testing if deleting a sequence will not delete the related project
"""
proj1 = Project('Test Project 1')
proj1.save()
seq1 = Sequence(proj1, 'Test Sequence 1')
seq1.save()
seq2 = Sequence(proj1, 'Test Sequence 2')
seq2.save()
# check if they are in the session
self.assertIn(proj1, db.session)
self.assertIn(seq1, db.session)
self.assertIn(seq2, db.session)
db.session.delete(seq1)
db.session.commit()
self.assertIn(proj1, db.session)
self.assertNotIn(seq1, db.session)
self.assertIn(seq2, db.session)
def setUp(self):
"""set up the test in class level
"""
# -----------------------------------------------------------------
# start of the setUp
conf.database_url = "sqlite://"
# create the environment variable and point it to a temp directory
self.temp_config_folder = tempfile.mkdtemp()
self.temp_projects_folder = tempfile.mkdtemp()
os.environ["OYPROJECTMANAGER_PATH"] = self.temp_config_folder
os.environ[conf.repository_env_key] = self.temp_projects_folder
self.test_project = Project("Test Project")
self.test_project.save()
self.kwargs = {
"project": self.test_project,
"name": "Test Sequence",
"code": "TEST_SEQUENCE"
}
self.test_sequence = Sequence(**self.kwargs)
self._name_test_values = [
# (input, name, code)
("test sequence", "test sequence", "test_sequence"),
("123 test sequence", "123 test sequence", "123_test_sequence"),
("£#$£#$test£#$£#$sequence", "testsequence", "testsequence"),
("_123test sequence", "_123test sequence", "_123test_sequence"),
("CamelCase", "CamelCase", "CamelCase"),
("234CamelCase", "234CamelCase", "234CamelCase"),
("camelCase", "camelCase", "camelCase"),
("CamelCase", "CamelCase", "CamelCase"),
("minus-sign", "minus-sign", "minus-sign"),
("123432!+!'^+Test_SEquence323^+'^%&+%&324",
"123432Test_SEquence323324", "123432Test_SEquence323324"),
(" ---test 9s_sequence", "test 9s_sequence",
"test_9s_sequence"),
(" ---test 9s-sequence", "test 9s-sequence",
"test_9s-sequence"),
(" multiple spaces are converted to under scores",
"multiple spaces are converted to under scores",
"multiple_spaces_are_converted_to_under_scores"),
("_Sequence_Setup_", "_Sequence_Setup_", "_Sequence_Setup_"),
("_SEQUENCE_SETUP_", "_SEQUENCE_SETUP_", "_SEQUENCE_SETUP_"),
("FUL_3D", "FUL_3D", "FUL_3D"),
]
def test_add_shots_method_creates_shots_based_on_the_given_range_formulat(
self):
"""testing if the add_shots will create shots based on the
shot_range_formula argument
"""
new_proj = Project(name="Test Project")
new_proj.create()
new_seq1 = Sequence(new_proj, "Test Sequence 1", "TEST_SEQ1")
new_seq1.save()
expected_shot_numbers = [
'1', '2', '3', '4', '5', '6', '7', '8', '10', '12', '13', '14',
'15', '304_SB_0403_0040'
]
# assert there is no shots in the sequence
self.assertTrue(len(new_seq1.shots) == 0)
# add a new shot
new_seq1.add_shots("1")
self.assertTrue(len(new_seq1.shots) == 1)
self.assertTrue(new_seq1.shots[0].number in expected_shot_numbers)
# add a couple of shots
new_seq1.add_shots("2,3,4")
self.assertTrue(len(new_seq1.shots) == 4)
self.assertTrue(new_seq1.shots[1].number in expected_shot_numbers)
self.assertTrue(new_seq1.shots[2].number in expected_shot_numbers)
self.assertTrue(new_seq1.shots[3].number in expected_shot_numbers)
# add a couple of more
#new_seq1.add_shots("5-8,10,12-15")
new_seq1.add_shots("5,6,7,8,10,12,13,14,15,304_sb_0403_0040")
self.assertTrue(len(new_seq1.shots) == 14)
self.assertIn(new_seq1.shots[4].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[5].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[6].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[7].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[8].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[9].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[10].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[11].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[12].number, expected_shot_numbers)
self.assertIn(new_seq1.shots[13].number, expected_shot_numbers)
def test_calling_create_multiple_times(self):
"""testing if no error will be raised when calling Sequence.create
multiple times
"""
new_proj = Project(name="TEST_PROJECT")
new_proj.create()
new_seq = Sequence(new_proj, "TEST_SEQ")
new_seq.save()
# now call create multiple times
new_seq.create()
new_seq.create()
new_seq.create()
new_seq.create()
new_seq.create()
def test_add_shots_method_will_remove_the_shot_prefix_if_the_given_shot_starts_with_it(
self):
"""testing if the add_shots method will remove the shot prefix in the
given shot code if it starts with the shot prefix of the project
"""
proj1 = Project('Test Proj1')
proj1.save()
seq1 = Sequence(proj1, 'Test Seq1')
seq1.save()
# now try to add a shot with the name SH001
seq1.add_shots(proj1.shot_number_prefix + "001")
# now check the first shot of the seq1 has a shot number of 1 and the
# code is SH001
self.assertEqual("1", seq1.shots[0].number)
self.assertEqual('SH001', seq1.shots[0].code)
def test_shot_argument_is_a_shot_instance_will_fill_the_ui_with_shot_info(self):
"""testing if the ui is filled with correct info coming from the given
shot
"""
proj1 = Project('Test Project')
proj1.save()
seq1 = Sequence(proj1, 'Test Sequence')
seq1.save()
shot = Shot(seq1, 1, 2, 435)
shot.handle_at_start = 23
shot.handle_at_end = 12
shot.save()
dialog = shot_editor.MainDialog(shot=shot)
# test if the "Editing Shot: SH001" is correctly updated
self.assertEqual(
shot.code,
dialog.shot_name_label.text()
)
# test frame range info
self.assertEqual(
shot.start_frame,
dialog.start_frame_spinBox.value()
)
self.assertEqual(
shot.end_frame,
dialog.end_frame_spinBox.value()
)
self.assertEqual(
shot.handle_at_start,
dialog.handle_at_start_spinBox.value()
)
self.assertEqual(
shot.handle_at_end,
dialog.handle_at_end_spinBox.value()
)
def test_add_shots_is_working_properly_for_projects_with_no_shot_number_prefix(
self):
"""testing if the add_shots method working properly for projects with
no or empty shot_number_prefix
"""
proj1 = Project('proj1', 'proj1')
proj1.shot_number_prefix = ""
proj1.shot_number_padding = 0
proj1.save()
seq1 = Sequence(proj1, 'seq91')
seq1.save()
shot_code = 'VFX91-3'
seq1.add_shots(shot_code)
# should complete without any error
shot = seq1.shots[0]
self.assertEqual(shot.code, shot_code)
def test_shot_info_of_the_given_shot_is_updated_correctly(self):
"""testing if the shot info is updated when clicked to ok
"""
proj1 = Project('Test Project')
proj1.save()
seq1 = Sequence(proj1, 'Test Sequence')
seq1.save()
shot = Shot(seq1, 1, 2, 435)
shot.handle_at_start = 23
shot.handle_at_end = 12
shot.save()
start_frame = 132
end_frame = 250
handle_at_start = 11
handle_at_end = 32
dialog = shot_editor.MainDialog(shot=shot)
# self.show_dialog(dialog)
# now update the values
dialog.start_frame_spinBox.setValue(start_frame)
dialog.end_frame_spinBox.setValue(end_frame)
dialog.handle_at_start_spinBox.setValue(handle_at_start)
dialog.handle_at_end_spinBox.setValue(handle_at_end)
# hit ok
QTest.mouseClick(
dialog.buttonBox.buttons()[0],
QtCore.Qt.LeftButton
)
# now check if the shot is updated
self.assertEqual(start_frame, shot.start_frame)
self.assertEqual(end_frame, shot.end_frame)
self.assertEqual(handle_at_start, shot.handle_at_start)
self.assertEqual(handle_at_end, shot.handle_at_end)
def test_save_as_sets_the_render_file_name_for_Shots(self):
"""testing if the save_as sets the render file name correctly
"""
test_seq = Sequence(self.project, "Test Sequence 1")
test_seq.save()
test_shot = Shot(test_seq, 1)
test_shot.save()
self.kwargs["type"] = self.shot_vtypes[0]
self.kwargs["version_of"] = test_shot
self.version1 = Version(**self.kwargs)
self.mEnv.save_as(self.version1)
# check if the path equals to
expected_path = self.version1.output_path + \
"/<Layer>/"+ self.version1.project.code + "_" + \
self.version1.version_of.sequence.code + "_" + \
self.version1.base_name +"_" + \
self.version1.take_name + \
"_<Layer>_<RenderPass>_<Version>"
image_path = os.path.join(pm.workspace.path,
pm.workspace.fileRules['image']).replace(
"\\", "/")
expected_path = utils.relpath(
image_path,
expected_path,
)
dRG = pm.PyNode("defaultRenderGlobals")
self.assertEqual(expected_path, dRG.getAttr("imageFilePrefix"))
def test_shots_tableWidget_is_filled_with_Shot_data(self):
"""testing if the shots_tableWidget is filled with shot data properly
"""
db.setup()
# create a project
proj1 = Project('Test Project 1')
proj1.save()
proj2 = Project('Test Project 2')
proj2.save()
shot_vtypes = VersionType.query()\
.filter(VersionType.type_for=='Shot')\
.order_by(VersionType.name)\
.all()
admin = User.query().first()
# seqs for proj1
seq1 = Sequence(proj1, 'Test Seq 1')
seq1.save()
seq2 = Sequence(proj1, 'Test Seq 2')
seq2.save()
# seqs for proj2
seq3 = Sequence(proj2, 'Test Seq 3')
seq3.save()
seq4 = Sequence(proj2, 'Test Seq 4')
seq4.save()
# shots for seq1
shot1 = Shot(seq1, 1)
shot1.save()
shot2 = Shot(seq1, 2)
shot2.save()
shot3 = Shot(seq1, 3)
shot3.save()
# shots for seq2
shot4 = Shot(seq2, 4)
shot4.save()
shot5 = Shot(seq2, 5)
shot5.save()
shot6 = Shot(seq2, 6)
shot6.save()
# shots for seq3
shot7 = Shot(seq3, 7)
shot7.save()
shot8 = Shot(seq3, 8)
shot8.save()
# shots for seq4
shot9 = Shot(seq4, 9)
shot9.save()
shot10 = Shot(seq4, 10)
shot10.save()
# versions for shot1
version1 = Version(version_of=shot1,
base_name=shot1.code,
type=shot_vtypes[0],
created_by=admin,
status=conf.status_list[0])
version1.save()
version2 = Version(version_of=shot1,
base_name=shot1.code,
type=shot_vtypes[1],
created_by=admin,
status=conf.status_list[1])
version2.save()
# versions for shot2
version3 = Version(version_of=shot2,
base_name=shot2.code,
type=shot_vtypes[2],
created_by=admin,
status=conf.status_list[2])
version3.save()
version4 = Version(
version_of=shot2,
base_name=shot2.code,
type=shot_vtypes[3],
created_by=admin,
status=conf.status_list[3],
)
version4.save()
# versions for shot3
version5 = Version(
version_of=shot3,
base_name=shot3.code,
type=shot_vtypes[4],
created_by=admin,
status=conf.status_list[4],
)
version5.save()
version6 = Version(
version_of=shot3,
base_name=shot3.code,
type=shot_vtypes[5],
created_by=admin,
status=conf.status_list[4],
)
version6.save()
# versions for shot4
version7 = Version(version_of=shot4,
base_name=shot4.code,
type=shot_vtypes[5],
created_by=admin,
status=conf.status_list[4])
version7.save()
version8 = Version(version_of=shot4,
base_name=shot4.code,
type=shot_vtypes[5],
created_by=admin,
status=conf.status_list[0])
version8.save()
dialog = status_manager.MainDialog()
# self.show_dialog(dialog)
# start tests
# set the project to project1
dialog.projects_comboBox.setCurrentIndex(0)
#self.show_dialog(dialog)
# asset1's vtypes[0] vtypes[1] vtypes[2] vtypes[3]
self.fail('test is not finished yet!')
def fill_shots_tableWidget(self):
"""fills the shots_tableWidget
"""
# TODO: merge cells of the same shot, or at least paint them in some other color
# clear the tableWidget
self.shots_tableWidget.clear()
shot_vtypes = VersionType.query()\
.filter(VersionType.type_for=='Shot')\
.order_by(VersionType.name)\
.all()
shot_vtype_codes = map(lambda x: x.code, shot_vtypes)
labels = ['Thumbnail', 'Sequence', 'Number', 'Take']
labels.extend(map(lambda x: x.code, shot_vtypes))
#logger.debug('shot_tableWidget.labels: %s' % labels)
self.shots_tableWidget.setColumnCount(len(labels))
self.shots_tableWidget.setHorizontalHeaderLabels(labels)
# get the project
project = self.get_current_project()
if project is None:
return
# get all the shots for the sequence
sequences = Sequence.query()\
.filter(Sequence.project==project)\
.order_by(Sequence.name)\
.all()
shot_count = db.query(func.count(Shot.id))\
.join(Sequence)\
.filter(Sequence.id==Shot.sequence_id)\
.filter(Sequence.project==project)\
.all()[0][0]
# set the row count for all shots in that sequence
self.shots_tableWidget.setRowCount(shot_count)
items = []
row = 0
column = 0
for sequence in sequences:
shots = Shot.query()\
.filter(Shot.sequence==sequence)\
.order_by(Shot.number)\
.all()
# sort according to numbers
shots.sort(key=lambda x: utils.embedded_numbers(x.number))
#logger.debug('shots of sequence %s is %s' % (sequence.name, shots))
# feed the shots to the list
previous_shot = None
for shot in shots:
take_names = map(
lambda x: x[0],
db.query(distinct(Version.take_name))
.filter(Version.version_of==shot)
.all()
)
if not len(take_names):
take_names = ['-']
for take_name in take_names:
# add the seq name to the first column
column = 0
item = QtGui.QTableWidgetItem()
item.setTextAlignment(0x0004 | 0x0080)
#set the thumbnail
if os.path.exists(shot.thumbnail_full_path):
thumbnail_full_path = shot.thumbnail_full_path
pixmap = QtGui.QPixmap(thumbnail_full_path)
pixmap = pixmap.scaled(
conf.thumbnail_size[0] / 2,
conf.thumbnail_size[1] / 2,
QtCore.Qt.KeepAspectRatio,
QtCore.Qt.SmoothTransformation
)
brush = QtGui.QBrush(pixmap)
item.has_thumbnail = True
item.setBackground(brush)
else:
item.has_thumbnail = False
items.append(item)
column = 1
item = QtGui.QTableWidgetItem(sequence.name)
item.setTextAlignment(0x0004 | 0x0080)
#self.shots_tableWidget.setItem(row, column, item)
items.append(item)
# add the shot code to the second column
column = 2
item = QtGui.QTableWidgetItem(shot.code)
item.setTextAlignment(0x0004 | 0x0080)
#self.shots_tableWidget.setItem(row, column, item)
items.append(item)
# add the take name to the third column
column = 3
item = QtGui.QTableWidgetItem(take_name)
item.setTextAlignment(0x0004 | 0x0080)
#self.assets_tableWidget.setItem(row, column, item)
items.append(item)
for type_code in shot_vtype_codes:
column += 1
# get the latest version of that type and take
version = Version.query()\
.join(VersionType)\
.filter(Version.version_of==shot)\
.filter(Version.type_id==VersionType.id)\
.filter(VersionType.code==type_code)\
.filter(Version.take_name==take_name)\
.order_by(Version.version_number.desc())\
.first()
if version:
# mark the status of that type in that take
item = QtGui.QTableWidgetItem(
version.status + '\n' + version.created_by.name
)
item.setTextAlignment(0x0004 | 0x0080)
# set the color according to status
index = conf.status_list.index(version.status)
bgcolor = conf.status_bg_colors[index]
fgcolor = conf.status_fg_colors[index]
bg = item.background()
bg.setColor(QtGui.QColor(*bgcolor))
item.setBackground(bg)
fg = item.foreground()
fg.setColor(QtGui.QColor(*fgcolor))
item.setForeground(fg)
try:
item.setBackgroundColor(QtGui.QColor(*bgcolor))
except AttributeError: # for PySide
pass
# set this version to the item
item.version = version
else:
# set the background color to black
item = QtGui.QTableWidgetItem('-')
item.setTextAlignment(0x0004 | 0x0080)
bg = item.background()
bg.setColor(QtGui.QColor(0, 0, 0))
item.setBackground(bg)
try:
item.setBackgroundColor(QtGui.QColor(0, 0, 0))
except AttributeError: # for PySide
pass
# set the version to None for this item
item.version = None
items.append(item)
row += 1
self.shots_tableWidget.setRowCount(row)
item_index = 0
for r in range(row):
for c in range(column + 1):
item = items[item_index]
self.shots_tableWidget.setItem(r, c, item)
item_index += 1
# adjust the row heights accordingly
self.shots_tableWidget.resizeRowsToContents()
# need to pass over the first rows again
# to resize the thumbnail cell
for r in range(row):
item_index = r * (column + 1)
item = items[item_index]
if item.has_thumbnail:
# scale the row height
self.shots_tableWidget.setRowHeight(
r,
conf.thumbnail_size[1] / 2
)
# resize columns to fit the content
self.shots_tableWidget.resizeColumnsToContents()
# set the column width
self.shots_tableWidget.setColumnWidth(0, conf.thumbnail_size[0] / 2)
