def test_sequences_attribute_is_working_properly(self):
"""testing if the sequences attribute is working properly
"""
self.kwargs['code'] = 'NewShot'
seq1 = Sequence(name='seq1',
code='seq1',
project=self.test_project1,
status_list=self.test_sequence_status_list)
seq2 = Sequence(name='seq2',
code='seq2',
project=self.test_project1,
status_list=self.test_sequence_status_list)
seq3 = Sequence(name='seq3',
code='seq3',
project=self.test_project1,
status_list=self.test_sequence_status_list)
new_shot = Shot(**self.kwargs)
new_shot.sequences = [seq1]
new_shot.sequences.append(seq2)
new_shot.sequences.append(seq3)
seqs = [seq1, seq2, seq3]
self.assertEqual(sorted(new_shot.sequences, key=lambda x: x.name),
sorted(seqs, key=lambda x: x.name))
def test_sequences_attribute_is_working_properly(self):
"""testing if the sequences attribute is working properly
"""
self.kwargs['code'] = 'NewShot'
from stalker import Sequence
seq1 = Sequence(
name='seq1',
code='seq1',
project=self.test_project1,
)
seq2 = Sequence(
name='seq2',
code='seq2',
project=self.test_project1,
)
seq3 = Sequence(
name='seq3',
code='seq3',
project=self.test_project1,
)
new_shot = Shot(**self.kwargs)
new_shot.sequences = [seq1]
new_shot.sequences.append(seq2)
new_shot.sequences.append(seq3)
seqs = [seq1, seq2, seq3]
assert \
sorted(new_shot.sequences, key=lambda x: x.name) == \
sorted(seqs, key=lambda x: x.name)
def test_inequality(self):
"""testing the inequality of sequences
"""
new_seq1 = Sequence(**self.kwargs)
new_seq2 = Sequence(**self.kwargs)
new_entity = Entity(**self.kwargs)
self.kwargs["name"] = "a different sequence"
new_seq3 = Sequence(**self.kwargs)
self.assertFalse(new_seq1 != new_seq2)
self.assertTrue(new_seq1 != new_seq3)
self.assertTrue(new_seq1 != new_entity)
def test_equality(self):
"""testing the equality of sequences
"""
from stalker import Entity, Sequence
new_seq1 = Sequence(**self.kwargs)
new_seq2 = Sequence(**self.kwargs)
new_entity = Entity(**self.kwargs)
self.kwargs["name"] = "a different sequence"
new_seq3 = Sequence(**self.kwargs)
self.assertTrue(new_seq1 == new_seq2)
self.assertFalse(new_seq1 == new_seq3)
self.assertFalse(new_seq1 == new_entity)
def test_inequality(self):
"""testing the inequality of sequences
"""
from stalker import Entity, Sequence
new_seq1 = Sequence(**self.kwargs)
new_seq2 = Sequence(**self.kwargs)
new_entity = Entity(**self.kwargs)
self.kwargs["name"] = "a different sequence"
new_seq3 = Sequence(**self.kwargs)
assert not new_seq1 != new_seq2
assert new_seq1 != new_seq3
assert new_seq1 != new_entity
def test_ReferenceMixin_initialization(self):
"""testing if the ReferenceMixin part is initialized correctly
"""
from stalker import Type, Link, Sequence
link_type_1 = Type(
name="Image",
code='image',
target_entity_type="Link"
)
link1 = Link(
name="Artwork 1",
full_path="/mnt/M/JOBs/TEST_PROJECT",
filename="a.jpg",
type=link_type_1
)
link2 = Link(
name="Artwork 2",
full_path="/mnt/M/JOBs/TEST_PROJECT",
filename="b.jbg",
type=link_type_1
)
references = [link1, link2]
self.kwargs["references"] = references
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.references, references)
def setUp(self):
"""setup the test
"""
super(SequenceTester, self).setUp()
# create a test project, user and a couple of shots
from stalker import Type
self.project_type = Type(
name="Test Project Type",
code='test',
target_entity_type='Project',
)
from stalker.db.session import DBSession
DBSession.add(self.project_type)
# create a repository
self.repository_type = Type(
name="Test Type",
code='test',
target_entity_type='Repository'
)
DBSession.add(self.repository_type)
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
DBSession.add(self.test_repository)
# create projects
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code='tp1',
type=self.project_type,
repository=self.test_repository,
)
DBSession.add(self.test_project)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.project_type,
repository=self.test_repository,
)
DBSession.add(self.test_project2)
# the parameters
self.kwargs = {
"name": "Test Sequence",
'code': 'tseq',
"description": "A test sequence",
"project": self.test_project,
}
# the test sequence
from stalker import Sequence
self.test_sequence = Sequence(**self.kwargs)
DBSession.commit()
def test_ProjectMixin_initialization(self):
"""testing if the ProjectMixin part is initialized correctly
"""
from stalker import Status, StatusList
status1 = Status(name="On Hold", code="OH")
project_status_list = StatusList(
name="Project Statuses", statuses=[status1],
target_entity_type='Project'
)
from stalker import Type
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
from stalker import Project
new_project = Project(
name="Test Project",
code='tp',
status=project_status_list[0],
status_list=project_status_list,
type=project_type,
repository=self.test_repository
)
from stalker import Sequence
self.kwargs["project"] = new_project
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.project, new_project)
def test_TaskableEntity_initialization(self):
"""testing if the TaskableEntity part is initialized correctly
"""
from stalker import Status, StatusList
status1 = Status(name="On Hold", code="OH")
project_status_list = StatusList(
name="Project Statuses", statuses=[status1],
target_entity_type='Project',
)
from stalker import Type, Project, Sequence, Task
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
new_project = Project(
name="Commercial",
code='comm',
status_list=project_status_list,
type=project_type,
repository=self.test_repository,
)
self.kwargs["new_project"] = new_project
new_sequence = Sequence(**self.kwargs)
task1 = Task(
name="Modeling",
status=0,
project=new_project,
parent=new_sequence,
)
task2 = Task(
name="Lighting",
status=0,
project=new_project,
parent=new_sequence,
)
tasks = [task1, task2]
self.assertEqual(
sorted(new_sequence.tasks, key=lambda x: x.name),
sorted(tasks, key=lambda x: x.name)
)
def create_sequence(request):
"""runs when adding a new sequence
"""
logged_in_user = get_logged_in_user(request)
name = request.params.get('name')
code = request.params.get('code')
status_id = request.params.get('status_id')
status = Status.query.filter_by(id=status_id).first()
project_id = request.params.get('project_id')
project = Project.query.filter_by(id=project_id).first()
logger.debug('project_id : %s' % project_id)
if name and code and status and project:
# get descriptions
description = request.params.get('description')
# get the status_list
status_list = StatusList.query.filter_by(
target_entity_type='Sequence').first()
# there should be a status_list
# TODO: you should think about how much possible this is
if status_list is None:
return HTTPServerError(detail='No StatusList found')
new_sequence = Sequence(name=name,
code=code,
description=description,
status_list=status_list,
status=status,
created_by=logged_in_user,
project=project)
DBSession.add(new_sequence)
else:
logger.debug('there are missing parameters')
logger.debug('name : %s' % name)
logger.debug('code : %s' % code)
logger.debug('status : %s' % status)
logger.debug('project : %s' % project)
HTTPServerError()
return HTTPOk()
def test_ProjectMixin_initialization(self):
"""testing if the ProjectMixin part is initialized correctly
"""
from stalker import Type
project_type = Type(name="Commercial",
code='comm',
target_entity_type='Project')
from stalker import Project
new_project = Project(name="Test Project",
code='tp',
type=project_type,
repository=self.test_repository)
from stalker import Sequence
self.kwargs["project"] = new_project
new_sequence = Sequence(**self.kwargs)
assert new_sequence.project == new_project
def test_initialization_of_task_part(self):
"""testing if the Task part is initialized correctly
"""
from stalker import Type, Project, Sequence, Task
project_type = Type(
name="Commercial",
code='comm',
target_entity_type='Project'
)
new_project = Project(
name="Commercial",
code='comm',
type=project_type,
repository=self.test_repository,
)
self.kwargs["project"] = new_project
new_sequence = Sequence(**self.kwargs)
task1 = Task(
name="Modeling",
status=0,
project=new_project,
parent=new_sequence,
)
task2 = Task(
name="Lighting",
status=0,
project=new_project,
parent=new_sequence,
)
tasks = [task1, task2]
assert \
sorted(new_sequence.tasks, key=lambda x: x.name) == \
sorted(tasks, key=lambda x: x.name)
def setUp(self):
"""setup the test
"""
db.setup()
db.init()
# statuses
self.status_new = Status.query.filter_by(code='NEW').first()
self.status_wfd = Status.query.filter_by(code='WFD').first()
self.status_rts = Status.query.filter_by(code='RTS').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_prev = Status.query.filter_by(code='PREV').first()
self.status_hrev = Status.query.filter_by(code='HREV').first()
self.status_drev = Status.query.filter_by(code='DREV').first()
self.status_oh = Status.query.filter_by(code='OH').first()
self.status_stop = Status.query.filter_by(code='STOP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
# status lists
self.test_project_status_list = StatusList(
name="Project Status List",
statuses=[self.status_new, self.status_wip, self.status_cmpl],
target_entity_type=Project,
)
self.test_sequence_status_list = \
StatusList.query.filter_by(target_entity_type='Sequence').first()
self.test_shot_status_list = \
StatusList.query.filter_by(target_entity_type='Shot').first()
self.test_asset_status_list = \
StatusList.query.filter_by(target_entity_type='Asset').first()
# types
self.test_commercial_project_type = Type(
name="Commercial Project",
code='comm',
target_entity_type=Project,
)
self.test_character_asset_type = Type(
name="Character",
code='char',
target_entity_type=Asset,
)
self.test_repository_type = Type(name="Test Repository Type",
code='test',
target_entity_type=Repository)
# repository
self.test_repository = Repository(
name="Test Repository",
type=self.test_repository_type,
)
# image format
self.test_image_format1 = ImageFormat(name='Test Image Format 1',
width=1920,
height=1080,
pixel_aspect=1.0)
self.test_image_format2 = ImageFormat(name='Test Image Format 2',
width=1280,
height=720,
pixel_aspect=1.0)
# project and sequences
self.test_project1 = Project(name='Test Project1',
code='tp1',
type=self.test_commercial_project_type,
status_list=self.test_project_status_list,
repository=self.test_repository,
image_format=self.test_image_format1)
self.test_project2 = Project(name='Test Project2',
code='tp2',
type=self.test_commercial_project_type,
status_list=self.test_project_status_list,
repository=self.test_repository,
image_format=self.test_image_format1)
self.test_sequence1 = Sequence(
name="Test Seq1",
code='ts1',
project=self.test_project1,
status_list=self.test_sequence_status_list,
)
self.test_sequence2 = Sequence(
name="Test Seq2",
code='ts2',
project=self.test_project1,
status_list=self.test_sequence_status_list,
)
self.test_sequence3 = Sequence(
name="Test Seq3",
code='ts3',
project=self.test_project1,
status_list=self.test_sequence_status_list,
)
self.test_scene1 = Scene(
name='Test Sce1',
code='tsc1',
project=self.test_project1,
)
self.test_scene2 = Scene(
name='Test Sce2',
code='tsc2',
project=self.test_project1,
)
self.test_scene3 = Scene(name='Test Sce3',
code='tsc3',
project=self.test_project1)
self.test_asset1 = Asset(
name="Test Asset1",
code='ta1',
project=self.test_project1,
status_list=self.test_asset_status_list,
type=self.test_character_asset_type,
)
self.test_asset2 = Asset(
name="Test Asset2",
code='ta2',
project=self.test_project1,
status_list=self.test_asset_status_list,
type=self.test_character_asset_type,
)
self.test_asset3 = Asset(
name="Test Asset3",
code='ta3',
project=self.test_project1,
status_list=self.test_asset_status_list,
type=self.test_character_asset_type,
)
self.kwargs = dict(
name='SH123',
code='SH123',
description='This is a test Shot',
project=self.test_project1,
sequences=[self.test_sequence1, self.test_sequence2],
scenes=[self.test_scene1, self.test_scene2],
cut_in=112,
cut_out=149,
source_in=120,
source_out=140,
record_in=85485,
status=0,
status_list=self.test_shot_status_list,
image_format=self.test_image_format2)
# create a mock shot object
self.test_shot = Shot(**self.kwargs)
db.DBSession.add(self.test_project1)
db.DBSession.commit()
def setUp(self):
"""setup the test
"""
super(SequenceTester, self).setUp()
# get statuses
from stalker import Status, StatusList
self.status_new = Status.query.filter_by(code='NEW').first()
self.status_wfd = Status.query.filter_by(code='WFD').first()
self.status_rts = Status.query.filter_by(code='RTS').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_prev = Status.query.filter_by(code='PREV').first()
self.status_hrev = Status.query.filter_by(code='HREV').first()
self.status_drev = Status.query.filter_by(code='DREV').first()
self.status_oh = Status.query.filter_by(code='OH').first()
self.status_stop = Status.query.filter_by(code='STOP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
self.sequence_status_list = \
StatusList.query.filter_by(target_entity_type='Sequence').first()
# create a test project, user and a couple of shots
from stalker import db, Type
self.project_type = Type(
name="Test Project Type",
code='test',
target_entity_type='Project',
)
db.DBSession.add(self.project_type)
# create a status list for project
self.project_status_list = StatusList(
name="Project Statuses",
statuses=[
self.status_new,
self.status_wip,
self.status_cmpl,
],
target_entity_type='Project',
)
db.DBSession.add(self.project_status_list)
# create a repository
self.repository_type = Type(
name="Test Type",
code='test',
target_entity_type='Repository'
)
db.DBSession.add(self.repository_type)
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
db.DBSession.add(self.test_repository)
# create projects
from stalker import Project
self.test_project = Project(
name="Test Project 1",
code='tp1',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
db.DBSession.add(self.test_project)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
db.DBSession.add(self.test_project2)
# the parameters
self.kwargs = {
"name": "Test Sequence",
'code': 'tseq',
"description": "A test sequence",
"project": self.test_project,
"status_list": self.sequence_status_list
}
# the test sequence
from stalker import Sequence
self.test_sequence = Sequence(**self.kwargs)
db.DBSession.commit()
new_project.image_format = ImageFormat(name="HD 1080", width=1920, height=1080)
new_project.fps = 25
local_tz = tzlocal.get_localzone()
new_project.end = datetime.datetime(2014, 5, 15, tzinfo=local_tz)
new_project.users.append(me)
DBSession.add(new_project)
DBSession.commit()
from stalker import Sequence
seq1 = Sequence(
name="Sequence 1",
code="SEQ1",
project=new_project,
)
from stalker import Shot
sh001 = Shot(name='SH001', code='SH001', project=new_project, sequences=[seq1])
sh002 = Shot(code='SH002', project=new_project, sequences=[seq1])
sh003 = Shot(code='SH003', project=new_project, sequences=[seq1])
DBSession.add_all([sh001, sh002, sh003])
DBSession.commit()
sh004 = Shot(code='SH004', project=new_project, sequences=[seq1])
DBSession.add(sh004)
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 setUp(self):
"""create test data
"""
database_url = 'sqlite:///:memory:'
db.setup({'sqlalchemy.url': database_url})
db.init()
self.temp_repo_path = tempfile.mkdtemp()
self.user1 = User(name='User 1',
login='******',
email='*****@*****.**',
password='******')
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.query.filter_by(target_entity_type='Project').first()
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)
# create task hierarchy
#
# ASSETS
#
self.assets = Task(name='Assets',
project=self.project,
responsible=[self.user1])
#
# SEQUENCES
#
self.sequences = Task(name='Sequences',
project=self.project,
responsible=[self.user1])
self.seq001 = Sequence(name='Seq001',
code='Seq001',
parent=self.sequences)
self.scene_task = Task(name='001_IST', parent=self.seq001)
self.scene_previs_type = Type(name='Scene Previs',
code='Scene Previs',
target_entity_type='Task')
self.scene_previs = Task(name='Scene Previs',
parent=self.scene_task,
type=self.scene_previs_type)
self.shots = Task(name='Shots', parent=self.scene_task)
self.shot1 = Shot(name='Seq001_001_IST_0010',
code='Seq001_001_IST_0010',
parent=self.shots)
# create shot tasks
self.previs = Task(name='Previs', parent=self.shot1)
self.camera = Task(name='Camera', parent=self.shot1)
self.animation = Task(name='Animation', parent=self.shot1)
self.scene_assembly = Task(name='SceneAssembly', parent=self.shot1)
self.lighting = Task(name='Lighting', parent=self.shot1)
self.comp = Task(name='Comp', parent=self.shot1)
# create maya files
self.maya_env = Maya()
pm.newFile(force=True)
sm = pm.PyNode('sequenceManager1')
seq1 = sm.create_sequence('001_IST')
# create 3 shots
shot1 = seq1.create_shot('shot1')
shot2 = seq1.create_shot('shot2')
shot3 = seq1.create_shot('shot3')
# set shot ranges
shot1.startFrame.set(1)
shot1.endFrame.set(100)
shot2.startFrame.set(101)
shot2.endFrame.set(200)
shot2.sequenceStartFrame.set(101)
shot3.startFrame.set(201)
shot3.endFrame.set(300)
shot3.sequenceStartFrame.set(201)
# save the file under scene previs
v = Version(task=self.scene_previs)
self.maya_env.save_as(v)
pm.newFile(force=1)
print(v.absolute_full_path)
def setUp(self):
"""setup the test
"""
db.setup()
db.init()
# users
self.test_user1 = User(
name='User1',
login='******',
password='******',
email='*****@*****.**'
)
self.test_user2 = User(
name='User2',
login='******',
password='******',
email='*****@*****.**'
)
# statuses
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
# status lists
self.project_status_list = StatusList(
name="Project Status List",
target_entity_type=Project,
statuses=[
self.status_cmpl,
self.status_wip
]
)
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()
# types
self.commercial_project_type = Type(
name="Commercial Project",
code='commproj',
target_entity_type=Project,
)
self.asset_type1 = Type(
name="Character",
code='char',
target_entity_type=Asset
)
self.asset_type2 = Type(
name="Environment",
code='env',
target_entity_type=Asset
)
self.repository_type = Type(
name="Test Repository Type",
code='testrepo',
target_entity_type=Repository,
)
# repository
self.repository = Repository(
name="Test Repository",
type=self.repository_type,
)
# project
self.project1 = Project(
name="Test Project1",
code='tp1',
type=self.commercial_project_type,
status_list=self.project_status_list,
repositories=[self.repository],
)
# sequence
self.seq1 = Sequence(
name="Test Sequence",
code='tseq',
project=self.project1,
status_list=self.sequence_status_list,
responsible=[self.test_user1]
)
# shots
self.shot1 = Shot(
code="TestSH001",
status_list=self.shot_status_list,
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
self.shot2 = Shot(
code="TestSH002",
status_list=self.shot_status_list,
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
self.shot3 = Shot(
code="TestSH003",
status_list=self.shot_status_list,
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
self.shot4 = Shot(
code="TestSH004",
status_list=self.shot_status_list,
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
self.kwargs = {
"name": "Test Asset",
'code': 'ta',
"description": "This is a test Asset object",
"project": self.project1,
"type": self.asset_type1,
"status": 0,
"status_list": self.asset_status_list,
'responsible': [self.test_user1]
}
self.asset1 = Asset(**self.kwargs)
# tasks
self.task1 = Task(
name="Task1",
parent=self.asset1,
status_list=self.task_status_list
)
self.task2 = Task(
name="Task2",
parent=self.asset1,
status_list=self.task_status_list
)
self.task3 = Task(
name="Task3",
parent=self.asset1,
status_list=self.task_status_list
)
def test_shots_attribute_defaults_to_empty_list(self):
"""testing if the shots attribute defaults to an empty list
"""
#self.kwargs.pop("shots")
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.shots, [])
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 setUp(self):
"""setup the test
"""
db.setup()
# db.init()
# we just need statuses so create them instead of initializing the db
db.create_entity_statuses(entity_type='Task',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Asset',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Shot',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Sequence',
status_names=defaults.task_status_names,
status_codes=defaults.task_status_codes)
db.create_entity_statuses(entity_type='Review',
status_names=defaults.review_status_names,
status_codes=defaults.review_status_codes)
# get statuses
self.status_new = Status.query.filter_by(code='NEW').first()
self.status_wfd = Status.query.filter_by(code='WFD').first()
self.status_rts = Status.query.filter_by(code='RTS').first()
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_prev = Status.query.filter_by(code='PREV').first()
self.status_hrev = Status.query.filter_by(code='HREV').first()
self.status_drev = Status.query.filter_by(code='DREV').first()
self.status_oh = Status.query.filter_by(code='OH').first()
self.status_stop = Status.query.filter_by(code='STOP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
# create a test project, user and a couple of shots
self.project_type = Type(
name="Test Project Type",
code='test',
target_entity_type=Project,
)
# create a status list for project
self.project_status_list = StatusList(
name="Project Statuses",
statuses=[
self.status_new,
self.status_wip,
self.status_cmpl,
],
target_entity_type=Project,
)
# create a repository
self.repository_type = Type(name="Test Type",
code='test',
target_entity_type=Repository)
self.test_repository = Repository(
name="Test Repository",
type=self.repository_type,
)
# create projects
self.test_project = Project(
name="Test Project 1",
code='tp1',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
self.test_project2 = Project(
name="Test Project 2",
code='tp2',
type=self.project_type,
status_list=self.project_status_list,
repository=self.test_repository,
)
self.sequence_status_list = \
StatusList.query.filter_by(target_entity_type='Sequence').first()
# the parameters
self.kwargs = {
"name": "Test Sequence",
'code': 'tseq',
"description": "A test sequence",
"project": self.test_project,
"status_list": self.sequence_status_list
}
# the test sequence
self.test_sequence = Sequence(**self.kwargs)
normal_struct = Structure(name='Normal Project Structure',
templates=[
normal_task_template, seq_template,
shot_template, asset_template
])
p2 = Project(
name='Normal Project Example',
code='NPE',
status_list=proj_statuses,
repository=repo, # can be freely in the same repo
structure=normal_struct # but uses a different structure
)
# now create new tasks for the normal project
seq1 = Sequence(name='Sequence', code='SEQ001', project=p2)
shot1 = Shot(name='SEQ001_0010',
code='SEQ001_0010',
parent=seq1,
sequences=[seq1])
comp = Task(name='Comp', parent=shot1)
# you probably will supply a different name/code
# it is a good idea to commit the data now
db.DBSession.add(shot1) # this should be enough to add the rest
# now create new maya files for them
comp_v1 = Version(task=comp, take_name='Test')
comp_v1.update_paths()
comp_v1.extension = '.ma'
def setUp(self):
"""setup the test
"""
super(ShotTester, self).setUp()
# statuses
# types
from stalker.db.session import DBSession
from stalker import Type
self.test_commercial_project_type = Type(
name="Commercial Project",
code='comm',
target_entity_type='Project',
)
DBSession.add(self.test_commercial_project_type)
self.test_character_asset_type = Type(
name="Character",
code='char',
target_entity_type='Asset',
)
DBSession.add(self.test_character_asset_type)
self.test_repository_type = Type(
name="Test Repository Type",
code='test',
target_entity_type='Repository'
)
DBSession.add(self.test_repository_type)
# repository
from stalker import Repository
self.test_repository = Repository(
name="Test Repository",
type=self.test_repository_type,
)
DBSession.add(self.test_repository)
# image format
from stalker import ImageFormat
self.test_image_format1 = ImageFormat(
name='Test Image Format 1',
width=1920,
height=1080,
pixel_aspect=1.0
)
DBSession.add(self.test_image_format1)
self.test_image_format2 = ImageFormat(
name='Test Image Format 2',
width=1280,
height=720,
pixel_aspect=1.0
)
DBSession.add(self.test_image_format2)
# project and sequences
from stalker import Project
self.test_project1 = Project(
name='Test Project1',
code='tp1',
type=self.test_commercial_project_type,
repository=self.test_repository,
image_format=self.test_image_format1
)
DBSession.add(self.test_project1)
DBSession.commit()
self.test_project2 = Project(
name='Test Project2',
code='tp2',
type=self.test_commercial_project_type,
repository=self.test_repository,
image_format=self.test_image_format1
)
DBSession.add(self.test_project2)
DBSession.commit()
from stalker import Sequence
self.test_sequence1 = Sequence(
name="Test Seq1",
code='ts1',
project=self.test_project1,
)
DBSession.add(self.test_sequence1)
DBSession.commit()
self.test_sequence2 = Sequence(
name="Test Seq2",
code='ts2',
project=self.test_project1,
)
DBSession.add(self.test_sequence2)
DBSession.commit()
self.test_sequence3 = Sequence(
name="Test Seq3",
code='ts3',
project=self.test_project1,
)
DBSession.add(self.test_sequence3)
DBSession.commit()
from stalker import Scene
self.test_scene1 = Scene(
name='Test Sce1',
code='tsc1',
project=self.test_project1,
)
DBSession.add(self.test_scene1)
DBSession.commit()
self.test_scene2 = Scene(
name='Test Sce2',
code='tsc2',
project=self.test_project1,
)
DBSession.add(self.test_scene2)
DBSession.commit()
self.test_scene3 = Scene(
name='Test Sce3',
code='tsc3',
project=self.test_project1
)
DBSession.add(self.test_scene3)
DBSession.commit()
from stalker import Asset
self.test_asset1 = Asset(
name="Test Asset1",
code='ta1',
project=self.test_project1,
type=self.test_character_asset_type,
)
DBSession.add(self.test_asset1)
DBSession.commit()
self.test_asset2 = Asset(
name="Test Asset2",
code='ta2',
project=self.test_project1,
type=self.test_character_asset_type,
)
DBSession.add(self.test_asset2)
DBSession.commit()
self.test_asset3 = Asset(
name="Test Asset3",
code='ta3',
project=self.test_project1,
type=self.test_character_asset_type,
)
DBSession.add(self.test_asset3)
DBSession.commit()
self.kwargs = dict(
name='SH123',
code='SH123',
description='This is a test Shot',
project=self.test_project1,
sequences=[self.test_sequence1, self.test_sequence2],
scenes=[self.test_scene1, self.test_scene2],
cut_in=112,
cut_out=149,
source_in=120,
source_out=140,
record_in=85485,
status=0,
image_format=self.test_image_format2
)
# create a mock shot object
self.test_shot = Shot(**self.kwargs)
DBSession.add(self.test_project1)
DBSession.commit()
def test_shots_attribute_defaults_to_empty_list(self):
"""testing if the shots attribute defaults to an empty list
"""
from stalker import Sequence
new_sequence = Sequence(**self.kwargs)
self.assertEqual(new_sequence.shots, [])
def setUp(self):
"""setup the test
"""
super(AssetTester, self).setUp()
# users
from stalker import User
from stalker.db.session import DBSession
self.test_user1 = User(
name='User1',
login='******',
password='******',
email='*****@*****.**'
)
DBSession.add(self.test_user1)
self.test_user2 = User(
name='User2',
login='******',
password='******',
email='*****@*****.**'
)
DBSession.add(self.test_user2)
DBSession.commit()
# statuses
from stalker import Status, Project
self.status_wip = Status.query.filter_by(code='WIP').first()
self.status_cmpl = Status.query.filter_by(code='CMPL').first()
# types
from stalker import Type
self.commercial_project_type = Type(
name="Commercial Project",
code='commproj',
target_entity_type='Project',
)
DBSession.add(self.commercial_project_type)
self.asset_type1 = Type(
name="Character",
code='char',
target_entity_type='Asset'
)
DBSession.add(self.asset_type1)
self.asset_type2 = Type(
name="Environment",
code='env',
target_entity_type='Asset'
)
DBSession.add(self.asset_type2)
self.repository_type = Type(
name="Test Repository Type",
code='testrepo',
target_entity_type='Repository',
)
DBSession.add(self.repository_type)
# repository
from stalker import Repository
self.repository = Repository(
name="Test Repository",
type=self.repository_type,
)
DBSession.add(self.repository)
# project
self.project1 = Project(
name="Test Project1",
code='tp1',
type=self.commercial_project_type,
repositories=[self.repository],
)
DBSession.add(self.project1)
DBSession.commit()
# sequence
from stalker import Sequence
self.seq1 = Sequence(
name="Test Sequence",
code='tseq',
project=self.project1,
responsible=[self.test_user1]
)
DBSession.add(self.seq1)
# shots
from stalker import Shot
self.shot1 = Shot(
code="TestSH001",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot1)
self.shot2 = Shot(
code="TestSH002",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot2)
self.shot3 = Shot(
code="TestSH003",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot3)
self.shot4 = Shot(
code="TestSH004",
project=self.project1,
sequences=[self.seq1],
responsible=[self.test_user1]
)
DBSession.add(self.shot4)
self.kwargs = {
"name": "Test Asset",
'code': 'ta',
"description": "This is a test Asset object",
"project": self.project1,
"type": self.asset_type1,
"status": 0,
'responsible': [self.test_user1]
}
from stalker import Asset, Task
self.asset1 = Asset(**self.kwargs)
DBSession.add(self.asset1)
# tasks
self.task1 = Task(
name="Task1",
parent=self.asset1,
)
DBSession.add(self.task1)
self.task2 = Task(
name="Task2",
parent=self.asset1,
)
DBSession.add(self.task2)
self.task3 = Task(
name="Task3",
parent=self.asset1,
)
DBSession.add(self.task3)
DBSession.commit()
def test_naming_case(self):
"""Test the case where naming should contain both Sequence Shot and
other stuff
(this is based on https://github.com/eoyilmaz/anima/issues/23)
"""
from stalker.db.session import DBSession
from stalker import Project, Task, Sequence, Shot, FilenameTemplate, \
Version, Structure
ft = FilenameTemplate(
name='Normal Naming Convention',
target_entity_type='Task',
path=
'$REPO{{project.repository.id}}/{{project.code}}/{%- for parent_task in parent_tasks -%}{{parent_task.nice_name}}/{%- endfor -%}',
filename="""{%- for p in parent_tasks -%}
{%- if p.entity_type == 'Sequence' -%}
{{p.name}}
{%- elif p.entity_type == 'Shot' -%}
_{{p.name}}{{p.children[0].name}}
{%- endif -%}
{%- endfor -%}
{%- set fx = parent_tasks[-2] -%}
_{{fx.name}}_{{version.take_name}}_v{{"%02d"|format(version.version_number)}}""",
)
DBSession.add(ft)
st = Structure(name='Normal Project Structure', templates=[ft])
DBSession.add(st)
test_project = Project(name='test001', code='test001', structure=st)
DBSession.add(test_project)
DBSession.commit()
seq_task = Task(name='seq', project=test_project)
DBSession.add(seq_task)
ep101 = Sequence(name='ep101', code='ep101', parent=seq_task)
DBSession.add(ep101)
shot_task = Task(name='shot', parent=ep101)
DBSession.add(shot_task)
s001 = Shot(name='s001', code='s001', parent=shot_task)
DBSession.add(s001)
c001 = Task(name='c001', parent=s001)
DBSession.add(c001)
effects_scene = Task(name='effectScenes', parent=c001)
DBSession.add(effects_scene)
fxA = Task(name='fxA', parent=effects_scene)
DBSession.add(fxA)
maya = Task(name='maya', parent=fxA)
DBSession.add(maya)
DBSession.commit()
v = Version(task=maya)
v.update_paths()
v.extension = '.ma'
DBSession.add(v)
DBSession.commit()
assert v.filename == 'ep101_s001c001_fxA_Main_v01.ma'