def from_edl(self, path):
"""Parses EDL file and returns a Sequence instance which reflects the
whole time line hierarchy.
:param path: The path of the XML file
:return: :class:`.Sequence`
"""
if not isinstance(path, str):
raise TypeError(
'path argument in %s.from_edl should be a string, not %s' %
(self.__class__.__name__, path.__class__.__name__)
)
from anima.env.mayaEnv import Maya
m = Maya()
fps = m.get_fps()
import edl
p = edl.Parser(str(fps))
with open(path) as f:
l = p.parse(f)
seq = Sequence()
seq.from_edl(l)
self.from_seq(seq)
def version_updater(logging_level=logging.WARNING):
"""helper function for version_updater UI for Maya
"""
# connect to db
do_db_setup()
# use PySide for Maya 2014
import pymel
try:
if pymel.versions.current() >= pymel.versions.v2014:
from anima import ui
ui.SET_PYSIDE()
except AttributeError:
pass
from anima.ui import version_updater, models
from anima.env import mayaEnv
reload(mayaEnv)
reload(version_updater)
reload(models)
m = Maya()
m.name = "Maya" + str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
# generate a reference_resolution
version_updater.UI(environment=m)
def check_if_previous_version_references():
"""check if a previous version of the same task is referenced to the scene
"""
from anima.env.mayaEnv import Maya
m = Maya()
ver = m.get_current_version()
if ver is None:
return
same_version_references = []
for ref in pm.listReferences(): # check only 1st level references
ref_version = m.get_version_from_full_path(ref.path)
if ref_version:
if ref_version.task == ver.task \
and ref_version.take_name == ver.take_name:
same_version_references.append(ref)
if len(same_version_references):
print('The following nodes are references to an older version of this '
'scene')
print('\n'.join(
map(lambda x: x.refNode.name(), same_version_references)))
raise PublishError(
'The current scene contains a <b>reference</b> to a<br>'
'<b>previous version</b> of itself.<br><br>'
'Please remove it!!!')
def archive_current_scene(cls):
"""archives the current scene
"""
# before doing anything ask it
response = pm.confirmDialog(
title='Do Archive?',
message='This will create a ZIP file containing\n'
'the current scene and all its references\n'
'\n'
'Is that OK?',
button=['Yes', 'No'],
defaultButton='No',
cancelButton='No',
dismissString='No')
if response == 'No':
return
import os
import shutil
import anima
from anima.env.mayaEnv import Maya
from anima.env.mayaEnv.archive import Archiver
m_env = Maya()
version = m_env.get_current_version()
if version:
path = version.absolute_full_path
arch = Archiver()
task = version.task
if False:
from stalker import Version, Task
assert (isinstance(version, Version))
assert (isinstance(task, Task))
# project_name = version.nice_name
project_name = os.path.splitext(
os.path.basename(version.absolute_full_path))[0]
project_path = arch.flatten(path, project_name=project_name)
# append link file
stalker_link_file_path = \
os.path.join(project_path, 'scenes/stalker_links.txt')
version_upload_link = '%s/tasks/%s/versions/list' % (
anima.defaults.stalker_server_external_address, task.id)
request_review_link = '%s/tasks/%s/view' % (
anima.defaults.stalker_server_external_address, task.id)
with open(stalker_link_file_path, 'w+') as f:
f.write("Version Upload Link: %s\n"
"Request Review Link: %s\n" %
(version_upload_link, request_review_link))
zip_path = arch.archive(project_path)
new_zip_path = os.path.join(version.absolute_path,
os.path.basename(zip_path))
# move the zip right beside the original version file
shutil.move(zip_path, new_zip_path)
# open the zip file in browser
from anima.utils import open_browser_in_location
open_browser_in_location(new_zip_path)
def archive_current_scene(cls):
"""archives the current scene
"""
from anima.env.mayaEnv import Maya
from anima.env.mayaEnv.archive import Archiver
from anima.utils.archive import archive_current_scene
m_env = Maya()
version = m_env.get_current_version()
archiver = Archiver()
archive_current_scene(version, archiver)
def playblast_on_farm(cls):
"""Submits playblast creation jobs to Afanasy
"""
from anima.env.mayaEnv import Maya, afanasy_publisher
m = Maya()
v = m.get_current_version()
if v:
afanasy_publisher.submit_playblast_job(
v.absolute_full_path, project_code=v.task.project.code)
else:
raise RuntimeError("This scene is not a Stalker version!")
def repr(self):
"""the representation name of the related version
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return None
rep = Representation(version=v)
return rep.repr
def __init__(self):
self.mEnv = Maya()
self.width = 265
self.height = 300
self.row_spacing = 3
self.window = None
self.window_name = 'Previz_Window'
self.window_title = "Previz Tools v%s" % anima.__version__
self.edl_checkBox = None
self.mxf_checkBox = None
def __init__(self, version=None):
local_session = LocalSession()
self.logged_in_user = local_session.logged_in_user
if not self.logged_in_user:
raise RuntimeError('Please login first!')
from anima.env.mayaEnv import Maya
self.maya_env = Maya()
self.base_take_name = None
self.version = version
def get_base(self):
"""returns the base version instance
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return True
rep = Representation(version=v)
return rep.find(rep.base_repr_name)
def is_base(self):
"""returns True or False depending to if this is the base
representation for this reference
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return True
rep = Representation(version=v)
return rep.is_base()
def has_repr(self, repr_name):
"""checks if the reference has the given representation
:param str repr_name: The name of the desired representation
:return:
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return False
rep = Representation(version=v)
return rep.has_repr(repr_name)
def list_all_repr(self):
"""Returns a list of strings representing all the representation names
of this FileReference
:return: list of str
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return []
rep = Representation(version=v)
return rep.list_all()
def is_repr(self, repr_name):
"""returns True or False depending to if this is the requested repr
:param str repr_name: The representation name
:return:
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return False
rep = Representation(version=v)
return rep.is_repr(repr_name=repr_name)
def find_repr(self, repr_name):
"""Finds the representation with the given repr_name.
:param str repr_name: The desired repr name
:return: :class:`.Version`
"""
from anima.env.mayaEnv import Maya
m = Maya()
v = m.get_version_from_full_path(self.path)
if v is None:
return
rep = Representation(version=v)
rep_v = rep.find(repr_name)
return rep_v
def version_updater(logging_level=logging.WARNING):
"""helper function for version_updater UI for Maya
"""
# connect to db
do_db_setup()
# set Qt lib
set_qt_lib()
from anima.ui import version_updater, models
from anima.env import mayaEnv
reload(mayaEnv)
reload(version_updater)
reload(models)
m = Maya()
import pymel
m.name = "Maya" + str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
# generate a reference_resolution
version_updater.UI(environment=m)
def version_creator(logging_level=logging.WARNING):
"""Helper function for version_creator UI for Maya
"""
# connect to db
do_db_setup()
# use PySide for Maya 2014
set_qt_lib()
from anima.ui import version_creator, models
from anima.env import mayaEnv
reload(version_creator)
reload(models)
reload(mayaEnv)
m = Maya()
import pymel
m.name = "Maya%s" % str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
version_creator.UI(environment=m)
def generate_repr_of_all_references(cls,
generate_gpu=True,
generate_ass=True,
generate_rs=True,
skip_existing=False):
"""generates all representations of all references of this scene
"""
from anima.ui.progress_dialog import ProgressDialogManager
from anima.env.mayaEnv import Maya, repr_tools, auxiliary
reload(auxiliary)
reload(repr_tools)
paths_visited = []
versions_to_visit = []
versions_cannot_be_published = []
# generate a sorted version list
# and visit each reference only once
from anima.env.mayaEnv import MayaMainProgressBarWrapper
wrp = MayaMainProgressBarWrapper()
pdm = ProgressDialogManager(dialog=wrp)
use_progress_window = False
if not pm.general.about(batch=1):
use_progress_window = True
all_refs = pm.listReferences(recursive=True)
pdm.use_ui = use_progress_window
caller = pdm.register(len(all_refs), 'List References')
for ref in reversed(all_refs):
ref_path = str(ref.path)
caller.step(message=ref_path)
if ref_path not in paths_visited:
v = ref.version
if v is not None:
paths_visited.append(ref_path)
versions_to_visit.append(v)
response = pm.confirmDialog(
title='Do Create Representations?',
message='Create all Repr. for all %s FileReferences?'
% len(versions_to_visit),
button=['Yes', 'No'],
defaultButton='No',
cancelButton='No',
dismissString='No'
)
if response == 'No':
return
# register a new caller
caller = pdm.register(max_iteration=len(versions_to_visit),
title='Generate Reprs')
m_env = Maya()
source_version = m_env.get_current_version()
gen = repr_tools.RepresentationGenerator()
# open each version
from stalker import Version
for v in versions_to_visit:
local_generate_gpu = generate_gpu
local_generate_ass = generate_ass
local_generate_rs = generate_rs
# check if this is a repr
if '@' in v.take_name:
# use the parent
v = v.parent
if not v:
continue
if skip_existing:
# check if there is a GPU or ASS repr
# generated from this version
child_versions = Version.query.filter(Version.parent == v).all()
for cv in child_versions:
if local_generate_gpu is True and '@GPU' in cv.take_name:
local_generate_gpu = False
if local_generate_ass is True and '@ASS' in cv.take_name:
local_generate_ass = False
if local_generate_rs is True and '@RS' in cv.take_name:
local_generate_rs = False
gen.version = v
# generate representations
if local_generate_gpu:
try:
gen.generate_gpu()
except RuntimeError:
if v not in versions_cannot_be_published:
versions_cannot_be_published.append(v)
if local_generate_ass:
try:
gen.generate_ass()
except RuntimeError:
if v not in versions_cannot_be_published:
versions_cannot_be_published.append(v)
if local_generate_rs:
try:
gen.generate_rs()
except RuntimeError:
if v not in versions_cannot_be_published:
versions_cannot_be_published.append(v)
caller.step()
# now open the source version again
m_env.open(source_version, force=True, skip_update_check=True)
# and generate representation for the source
gen.version = source_version
# generate representations
if not versions_cannot_be_published:
if generate_gpu:
gen.generate_gpu()
if generate_ass:
gen.generate_ass()
if generate_rs:
gen.generate_rs()
else:
pm.confirmDialog(
title='Error',
message='The following versions can not be published '
'(check script editor):\n\n%s' % (
'\n'.join(
map(lambda x: x.nice_name,
versions_cannot_be_published)
)
),
button=['OK'],
defaultButton='OK',
cancelButton='OK',
dismissString='OK'
)
pm.error(
'\n'.join(
map(lambda x: x.absolute_full_path,
versions_cannot_be_published)
)
)
def generate_repr_of_scene(cls,
generate_gpu=True,
generate_ass=True,
generate_rs=True,
skip_existing=False):
"""generates desired representations of this scene
"""
from anima.ui.progress_dialog import ProgressDialogManager
from anima.env.mayaEnv import Maya, repr_tools, auxiliary
reload(auxiliary)
reload(repr_tools)
response = pm.confirmDialog(
title='Do Create Representations?',
message='Create all Repr. for this scene?',
button=['Yes', 'No'],
defaultButton='No',
cancelButton='No',
dismissString='No'
)
if response == 'No':
return
# register a new caller
from anima.env.mayaEnv import MayaMainProgressBarWrapper
wrp = MayaMainProgressBarWrapper()
pdm = ProgressDialogManager(dialog=wrp)
m_env = Maya()
source_version = m_env.get_current_version()
gen = repr_tools.RepresentationGenerator()
# open each version
from stalker import Version
if skip_existing:
# check if there is a GPU or ASS repr
# generated from this version
child_versions = \
Version.query.filter(Version.parent == source_version).all()
for cv in child_versions:
if generate_gpu is True and '@GPU' in cv.take_name:
generate_gpu = False
if generate_ass is True and '@ASS' in cv.take_name:
generate_ass = False
if generate_rs is True and '@RS' in cv.take_name:
generate_rs = False
total_number_of_reprs = generate_gpu + generate_ass + generate_rs
caller = pdm.register(total_number_of_reprs, title='Generate Reprs')
gen.version = source_version
# generate representations
if generate_gpu:
gen.generate_gpu()
caller.step()
if generate_ass:
gen.generate_ass()
caller.step()
if generate_rs:
gen.generate_rs()
caller.step()
# now open the source version again
m_env.open(source_version, force=True, skip_update_check=True)
def export_edl():
"""exports edl of animation scenes
"""
from anima.env.mayaEnv import Maya
m = Maya()
current_version = m.get_current_version()
if not current_version:
return
# get sequenceManager1
sm = pm.PyNode('sequenceManager1')
seqs = sm.sequences.get()
if not len(seqs):
return
seq1 = seqs[0]
edl_path = tempfile.gettempdir()
edl_file_name = '%s_v%03i.edl' % (current_version.nice_name,
current_version.version_number)
edl_file_full_path = os.path.join(edl_path, edl_file_name)
# convert to MXF
from anima.ui.progress_dialog import ProgressDialogManager
pdm = ProgressDialogManager()
#shots = seq1.shots.get()
shots = pm.ls(type='shot')
shot_count = len(shots)
# before doing a playblast set all shot handles to 48
for shot in pm.ls(type='shot'):
if shot.hasAttr('handle'):
shot.handle.set(48)
caller = pdm.register(shot_count, title='Converting To MXF')
# update shot outputs to the correct place first
# there should be only one shot in the current animation scene
# if there is more than one shot, the other publisher will already warn the
# user so the code path will not reach to this point
# we also should already have a video output created by another publisher
playblast_file = None
for output in current_version.outputs:
extension = os.path.splitext(output.full_path)[-1]
if extension in ['.mov', '.avi', '.mp4']:
playblast_file = output
break
if not playblast_file:
return
shot = shots[0]
shot.output.set(playblast_file.full_path)
for i in seq1.metafuze():
caller.step()
# create EDL file
from anima import utils
mm = utils.MediaManager()
l = sm.to_edl()
with open(edl_file_full_path, 'w') as f:
f.write(l.to_string())
with open(edl_file_full_path, 'r') as f:
link = mm.upload_version_output(current_version, f, edl_file_name)
# add the link to database
from stalker import db
db.DBSession.commit()
# revert the handles to 0
for shot in pm.ls(type='shot'):
if shot.hasAttr('handle'):
shot.handle.set(0)
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 generate_sequence_structure(self):
"""Generates a Sequence structure suitable for XML<->EDL conversion
:return: Sequence
"""
import timecode
from anima.env.mayaEnv import Maya
m = Maya()
fps = m.get_fps()
# export only the first sequence, ignore others
sequencers = self.sequences.get()
if len(sequencers) == 0:
return None
sequencer = sequencers[0]
time = pm.PyNode('time1')
seq = Sequence()
seq.name = str(sequencer.get_sequence_name())
seq.rate = Rate(timebase=str(fps), ntsc=False)
seq.timecode = str(timecode.Timecode(
framerate=seq.rate.timebase,
frames=time.timecodeProductionStart.get() + 1
))
seq.duration = sequencer.duration
media = Media()
video = Video()
media.video = video
for shot in sequencer.shots.get():
clip = Clip()
clip.id = str(shot.full_shot_name)
clip.name = str(shot.full_shot_name)
clip.duration = shot.duration + 2 * shot.handle.get()
clip.enabled = True
clip.start = shot.sequenceStartFrame.get()
clip.end = shot.sequenceEndFrame.get() + 1
# clips always start from 0 and includes the shot handle
clip.in_ = shot.handle.get() # handle at start
clip.out = shot.handle.get() + shot.duration # handle at end
clip.type = 'Video' # always video for now
f = File()
f.name = os.path.splitext(
os.path.basename(str(shot.output.get()))
)[0]
f.duration = shot.duration + 2 * shot.handle.get()
f.pathurl = str('file://localhost/%s' % shot.output.get())
clip.file = f
track_number = shot.track.get() - 1 # tracks should start from 0
try:
track = video.tracks[track_number]
except IndexError:
track = Track()
video.tracks.append(track)
track.clips.append(clip)
# set video resolution
video.width = shot.wResolution.get()
video.height = shot.hResolution.get()
seq.media = media
return seq
def version(self):
"""returns the Stalker Version instance related to this reference
"""
from anima.env.mayaEnv import Maya
m = Maya()
return m.get_version_from_full_path(self.path)
