def version_creator(logging_level=logging.WARNING): """Helper function for version_creator UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide for Maya 2014 # and PySide2 for Maya 2017 set_qt_lib() from anima.ui import version_creator from anima.env import mayaEnv m = mayaEnv.Maya() import pymel m.name = "Maya%s" % str(pymel.versions.current())[0:4] logger.setLevel(logging_level) # global version_creator_dialog # if version_creator_dialog is None: # version_creator_dialog = version_creator.UI(environment=m) # else: # version_creator_dialog.show() # set the parent object to the maya main window version_creator.UI(environment=m, parent=mayaEnv.get_maya_main_window())
def version_dialog(): """Helper function for version_dialog UI for Nuke """ # connect to db from anima.utils import do_db_setup do_db_setup() # set PySide or PySide2 set_qt_lib() from anima.ui import version_dialog from anima.env import nukeEnv import nuke n = nukeEnv.Nuke() n.name = "nuke%s.%s" % (nuke.NUKE_VERSION_MAJOR, nuke.NUKE_VERSION_MINOR) # display only warning messages import logging logging.getLogger(version_dialog.__name__).setLevel(logging.WARNING) logging.getLogger("anima.ui").setLevel(logging.WARNING) logging.getLogger("anima.ui.models").setLevel(logging.WARNING) logging.getLogger("anima.env.nuke").setLevel(logging.WARNING) logging.getLogger("stalker.db").setLevel(logging.WARNING) version_dialog.UI(environment=n)
def version_updater(logging_level=logging.WARNING): """helper function for version_updater UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # set Qt lib set_qt_lib() from anima.ui import version_updater from anima.env import mayaEnv m = mayaEnv.Maya() import pymel m.name = "Maya%s" % str(pymel.versions.current())[0:4] logger.setLevel(logging_level) # generate a reference_resolution # global version_updater_dialog # if version_updater_dialog is None: # version_updater_dialog = version_updater.UI(environment=m) # else: # version_updater_dialog.show() # set the parent object to the maya main window version_updater.UI(environment=m, parent=mayaEnv.get_maya_main_window())
def version_creator(lib='PyQt4', logging_level=logging.WARNING): """Helper function for version_creator UI for Fusion It uses with PySide by default you can opt to use PyQt4 instead by setting the ``lib`` argument to "PyQt4". :param str lib: choose a lib, one of ["PySide", "PyQt4"] :return: None """ # connect to db do_db_setup() from anima.ui import SET_PYSIDE, SET_PYQT4 if lib == 'PySide': SET_PYSIDE() elif lib == 'PyQt4': SET_PYQT4() from anima.env import fusion reload(fusion) fusion_env = fusion.Fusion() fusion_env.name = 'Fusion' from anima.ui import version_creator logger.setLevel(logging_level) version_creator.UI(environment=fusion_env)
def version_creator(lib='PySide'): """Helper function for version_creator UI for Photoshop It uses with PySide by default you can opt to use PyQt4 instead by setting the ``lib`` argument to "PyQt4". :param str lib: choose a lib, one of ["PySide", "PyQt4"] :return: None """ # connect to db do_db_setup() from anima.ui import SET_PYSIDE, SET_PYQT4 if lib == 'PySide': SET_PYSIDE() elif lib == 'PyQt4': SET_PYQT4() from anima.env import photoshop reload(photoshop) p = photoshop.Photoshop() from anima.ui import version_creator reload(version_creator) # display only warning messages import logging logging.getLogger(version_creator.__name__).setLevel(logging.WARNING) logging.getLogger("anima.ui").setLevel(logging.WARNING) logging.getLogger("anima.ui.models").setLevel(logging.WARNING) logging.getLogger("anima.env.photoshop").setLevel( logging.WARNING) logging.getLogger("stalker.db").setLevel(logging.WARNING) version_creator.UI(environment=p)
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 version_dialog(lib='PySide', logging_level=logging.WARNING, parent=None): """Helper function for version_dialog UI for Fusion It uses with PySide by default you can opt to use PyQt4 instead by setting the ``lib`` argument to "PyQt4". :param str lib: choose a lib, one of ["PySide", "PyQt4"] :param logging_level: :return: None """ # connect to db from anima.utils import do_db_setup do_db_setup() from anima.ui import SET_PYSIDE, SET_PYQT4 if lib == 'PySide': SET_PYSIDE() elif lib == 'PyQt4': SET_PYQT4() from anima.env import fusion reload(fusion) fusion_env = fusion.Fusion() fusion_env.name = 'Fusion' from anima.ui import version_dialog logger.setLevel(logging_level) version_dialog.UI(environment=fusion_env, parent=parent)
def version_creator(): """Helper function for version_creator UI for Houdini """ # connect to db do_db_setup() import logging from stalker import log log.logging_level = logging.WARNING from anima.ui import version_creator from anima.env import houdini reload(houdini) reload(version_creator) h = houdini.Houdini() logger.setLevel(logging.WARNING) if hou.applicationVersion()[0] <= 13: version_creator.UI( environment=h ) else: version_creator.UI( environment=h, executor=Executor() )
def __init__(self): super(MainDialog, self).__init__() self.setupUi(self) self.media_files_path = '' self.cache_file_full_path = os.path.normpath( os.path.expanduser( os.path.expandvars( os.path.join( anima.local_cache_folder, anima.avid_media_file_path_storage ) ) ) ) self.edl_path_lineEdit = LineEdit() self.formLayout.setWidget( 1, QtWidgets.QFormLayout.FieldRole, self.edl_path_lineEdit ) self.setup_signals() self.restore_media_file_path() # connect to database do_db_setup()
def version_dialog(lib='PySide'): """Helper function for version_dialog UI for Photoshop It uses with PySide by default you can opt to use PyQt4 instead by setting the ``lib`` argument to "PyQt4". :param str lib: choose a lib, one of ["PySide", "PyQt4"] :return: None """ # connect to db do_db_setup() from anima.ui import SET_PYSIDE, SET_PYQT4 if lib == 'PySide': SET_PYSIDE() elif lib == 'PyQt4': SET_PYQT4() from anima.env import photoshop reload(photoshop) p = photoshop.Photoshop() from anima.ui import version_dialog reload(version_dialog) # display only warning messages import logging logging.getLogger(version_dialog.__name__).setLevel(logging.WARNING) logging.getLogger("anima.ui").setLevel(logging.WARNING) logging.getLogger("anima.ui.models").setLevel(logging.WARNING) logging.getLogger("anima.env.photoshop").setLevel(logging.WARNING) logging.getLogger("stalker.db").setLevel(logging.WARNING) version_dialog.UI(environment=p)
def __init__(self): super(MainDialog, self).__init__() self.setupUi(self) self.media_files_path = '' self.cache_file_full_path = os.path.normpath( os.path.expanduser( os.path.expandvars( os.path.join( anima.local_cache_folder, anima.avid_media_file_path_storage ) ) ) ) self.edl_path_lineEdit = LineEdit() self.formLayout.setWidget( 1, QtGui.QFormLayout.FieldRole, self.edl_path_lineEdit ) self.setup_signals() self.restore_media_file_path() # connect to database do_db_setup()
def update_outputs(): """updates outputs in the current script """ do_db_setup() nEnv = nukeEnv.Nuke() version = nEnv.get_current_version() if version: nEnv.create_main_write_node(version)
def version_mover(): """ """ # connect to db do_db_setup() from anima.ui import version_mover as vm vm.UI()
def fill_user_names_lut(): """fills the user_names_lut """ if not user_names_lut: from anima.utils import do_db_setup do_db_setup() from stalker import db, User map(lambda x: user_names_lut.__setitem__(x[0], x[1]), db.DBSession.query(User.id, User.name).all())
def range_from_shot(cls): """sets the range from the shot """ from anima.utils import do_db_setup do_db_setup() from anima.env import fusion fusion_env = fusion.Fusion() version = fusion_env.get_current_version() fusion_env.set_range_from_shot(version)
def update_savers(cls): """updates savers, creates missing ones """ from anima.utils import do_db_setup do_db_setup() from anima.env import fusion fusion_env = fusion.Fusion() v = fusion_env.get_current_version() fusion_env.create_main_saver_node(version=v)
def fill_user_names_lut(): """fills the user_names_lut """ if not user_names_lut: from anima.utils import do_db_setup do_db_setup() from stalker import db, User map( lambda x: user_names_lut.__setitem__(x[0], x[1]), db.DBSession.query(User.id, User.name).all() )
def user_names_lut(self): """fills the _user_names_lut """ if not self._user_names_lut: from anima.utils import do_db_setup do_db_setup() from stalker import User from stalker.db.session import DBSession map(lambda x: self._user_names_lut.__setitem__(x[0], x[1]), DBSession.query(User.id, User.name).all()) return self._user_names_lut
def user_names_lut(self): """fills the _user_names_lut """ if not self._user_names_lut: from anima.utils import do_db_setup do_db_setup() from stalker import User from stalker.db.session import DBSession for result in DBSession.query(User.id, User.name).all(): self._user_names_lut.__setitem__(result.id, result.name) return self._user_names_lut
def update_outputs(): """updates outputs in the current script """ from anima.utils import do_db_setup do_db_setup() from anima.env import nukeEnv nEnv = nukeEnv.Nuke() version = nEnv.get_current_version() if version: nEnv.create_main_write_node(version)
def user_names_lut(self): """fills the _user_names_lut """ if not self._user_names_lut: from anima.utils import do_db_setup do_db_setup() from stalker import User from stalker.db.session import DBSession map( lambda x: self._user_names_lut.__setitem__(x[0], x[1]), DBSession.query(User.id, User.name).all() ) return self._user_names_lut
def fill_status_colors_by_id(): """fills the status_colors_by_id dictionary """ if not status_colors_by_id: from anima.utils import do_db_setup do_db_setup() from stalker import StatusList task_status_list = \ StatusList.query\ .filter(StatusList.target_entity_type == 'Task')\ .first() for status in task_status_list.statuses: status_colors_by_id[status.id] = status_colors[status.code.lower()]
def shot_from_range(cls): """updates the Shot.cut_in and Shot.cut_out attributes from the current range """ from anima.utils import do_db_setup do_db_setup() from anima.env import fusion fusion_env = fusion.Fusion() version = fusion_env.get_current_version() try: fusion_env.set_shot_from_range(version) except BaseException as e: QtWidgets.QMessageBox.critical(None, "Error", "%s" % e) finally: QtWidgets.QMessageBox.information(None, "Success", "Shot Range has been updated successfully!")
def project_manager(logging_level=logging.WARNING): """Helper function for project_manager UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide for Maya 2014 # and PySide2 for Maya 2017 set_qt_lib() from anima.ui import project_manager from anima.env import mayaEnv # set the parent object to the maya main window project_manager.ui_caller(None, None, project_manager.MainWindow)
def version_creator(cls, **args): """version creator """ # from anima.ui.scripts import fusion # fusion.version_creator(*args) from anima.utils import do_db_setup do_db_setup() from anima.env import fusion fusion_env = fusion.Fusion() fusion_env.name = 'Fusion' from anima.ui import version_creator ui_instance = version_creator.MainDialog(environment=fusion_env, **args) ui_instance.show() ui_instance.center_window()
def version_creator(logging_level=logging.WARNING): """Helper function for version_creator UI for MotionBuilder """ # connect to db from anima.utils import do_db_setup do_db_setup() # set Qt library set_qt_lib() from anima.ui import version_creator from anima.env import motion_builder mb = motion_builder.MotionBuilder() logger.setLevel(logging_level) version_creator.UI(environment=mb)
def version_updater(): """Helper function for version_updater UI for Max """ from anima.utils import do_db_setup do_db_setup() from anima import ui ui.SET_PYSIDE() from anima.ui import version_updater from anima.env import max as max_env m = max_env.Max() import MaxPlus max_window = MaxPlus.GetQMaxWindow() version_updater.UI(environment=m, executor=Executor(), parent=max_window)
def __init__(self, *args, **kwargs): super(MainDialog, self).__init__(*args, **kwargs) self.resolve = blackmagic.get_resolve() self.project = self.resolve.GetProjectManager().GetCurrentProject() xml_path = tempfile.gettempdir() xml_file_name = 'conformer___temp__1.8_fcpxml.fcpxml' xml_file_path = os.path.join(xml_path, xml_file_name) self.xml_path = xml_file_path do_db_setup() self._setup_ui() self._setup_signals() self._set_defaults()
def version_dialog(logging_level=logging.WARNING): """Helper function for version_dialog UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide2 from anima import ui ui.SET_PYSIDE2() from anima.ui import version_dialog from anima.env import blender as blender_env b = blender_env.Blender() logger.setLevel(logging_level) # set the parent object to the maya main window version_dialog.UI(environment=b, parent=None)
def version_dialog(logging_level=logging.WARNING, mode=2): """Helper function for version_dialog UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide2 from anima import ui ui.SET_PYSIDE2() from anima.ui import version_dialog from anima.env import equalizer e = equalizer.Equalizer() e.name = tde4.get3DEVersion().split(" ")[0] logger.setLevel(logging_level) # set the parent object to the maya main window version_dialog.UI(environment=e, mode=mode)
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 version_updater(): """Helper function for version_updater UI for Max """ from anima.utils import do_db_setup do_db_setup() from anima import ui ui.SET_PYSIDE() from anima.ui import version_updater from anima.env import max as max_env m = max_env.Max() import MaxPlus max_window = MaxPlus.GetQMaxWindow() version_updater.UI( environment=m, executor=Executor(), parent=max_window )
def version_dialog(logging_level=logging.WARNING, mode=2): """Helper function for version_dialog UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide for Maya 2014 # and PySide2 for Maya 2017 set_qt_lib() from anima.ui import version_dialog from anima.env import mayaEnv m = mayaEnv.Maya() import pymel m.name = "Maya%s" % str(pymel.versions.current())[0:4] logger.setLevel(logging_level) # set the parent object to the maya main window version_dialog.UI(environment=m, parent=mayaEnv.get_maya_main_window(), mode=mode)
def version_creator(): """Helper function for version_creator UI for Houdini """ # connect to db do_db_setup() import logging from stalker import log log.logging_level = logging.WARNING from anima.ui import version_creator from anima.env import houdini reload(houdini) reload(version_creator) h = houdini.Houdini() logger.setLevel(logging.WARNING) if hou.applicationVersion()[0] <= 13: version_creator.UI(environment=h) else: version_creator.UI(environment=h, executor=Executor())
def version_creator(): """Helper function for version_creator UI for Nuke """ # connect to db do_db_setup() # set PySide or PySide2 set_qt_lib() from anima.ui import version_creator from anima.env import nukeEnv n = nukeEnv.Nuke() n.name = "Nuke" # display only warning messages import logging logging.getLogger(version_creator.__name__).setLevel(logging.WARNING) logging.getLogger("anima.ui").setLevel(logging.WARNING) logging.getLogger("anima.ui.models").setLevel(logging.WARNING) logging.getLogger("anima.env.nuke").setLevel(logging.WARNING) logging.getLogger("stalker.db").setLevel(logging.WARNING) version_creator.UI(environment=n)
def version_creator(): """Helper function for version_creator UI for Nuke """ # connect to db do_db_setup() # set PySide or PySide2 set_qt_lib() from anima.ui import version_creator from anima.env import nuke_studioEnv ns = nuke_studioEnv.NukeStudio() ns.name = "NukeStudio" # display only warning messages import logging logging.getLogger(version_creator.__name__).setLevel(logging.WARNING) logging.getLogger("anima.ui").setLevel(logging.WARNING) logging.getLogger("anima.ui.models").setLevel(logging.WARNING) logging.getLogger("anima.env.nuke_studioEnv").setLevel(logging.WARNING) logging.getLogger("stalker.db").setLevel(logging.WARNING) version_creator.UI(environment=ns)
def version_creator(): """Helper function for version_creator UI for Nuke """ # connect to db do_db_setup() # use PySide from anima import ui ui.SET_PYSIDE() from anima.ui import version_creator from anima.env import nukeEnv n = nukeEnv.Nuke() n.name = "Nuke" # display only warning messages import logging logging.getLogger(version_creator.__name__).setLevel(logging.WARNING) logging.getLogger("anima.ui").setLevel(logging.WARNING) logging.getLogger("anima.ui.models").setLevel(logging.WARNING) logging.getLogger("anima.env.nuke").setLevel(logging.WARNING) logging.getLogger("stalker.db").setLevel(logging.WARNING) version_creator.UI(environment=n)
def register(): """register the addon """ # do database setup from anima.utils import do_db_setup do_db_setup() # # generate one class for each menu item # # This is a limitation of Blender, as of 2.71 the ``layout.menu()`` method # is not returning any item to set the property to, so clever guys around # the blender community are suggesting to dynamically generating new # classes which is a very very very very bad practice, which essentially # does nothing better than bloating the python name space. # for project in Project.query.order_by(Project.name).all(): opclass = generate_op_class( project, draw=draw_stalker_project_menu_item ) bpy.utils.register_class(opclass) # append them to the lookup table so we will be able to unregister # them later on registered_menus.append(opclass) # for each project register a sequence menu all_seqs = Sequence.query.\ filter(Sequence.project == project)\ .order_by(Sequence.name).all() for seq in all_seqs: opclass = generate_op_class( seq, draw=draw_stalker_sequence_menu_item ) bpy.utils.register_class(opclass) registered_menus.append(opclass) # for each sequence register a scene menu for sce in seq.children: opclass = generate_op_class( sce, draw=draw_stalker_scene_menu_item ) bpy.utils.register_class(opclass) registered_menus.append(opclass) # generate a "Add From Shots" menu for each of them opclass = generate_op_class( sce, draw=draw_stalker_scene_add_from_shots_menu_item, idpostfix='_add_from_shots_menu', label='Add From Shots' ) bpy.utils.register_class(opclass) registered_menus.append(opclass) # for each Shot generate a menu item for shot in Shot.query.filter(Shot.project == project).all(): opclass = generate_op_class( shot, draw=draw_stalker_shot_menu_item ) bpy.utils.register_class(opclass) registered_menus.append(opclass) bpy.utils.register_class(StalkerMenu) bpy.utils.register_class(StalkerAddFromProjectMenu) bpy.utils.register_class(StalkerSceneAddEverythingOperator) bpy.utils.register_class(StalkerSceneAddStoryboardOperator) bpy.utils.register_class(StalkerSceneAddPrevisOperator) bpy.utils.register_class(StalkerSceneAddAllShotOutputsOperator) bpy.utils.register_class(StalkerSceneAddAllShotPrevisOutputsOperator) bpy.utils.register_class(StalkerSceneAddAllShotAnimationOutputsOperator) bpy.utils.register_class(StalkerSceneAddAllShotLightingOutputsOperator) bpy.utils.register_class(StalkerSceneAddAllShotCompOutputsOperator) bpy.utils.register_class(StalkerShotAddAllTaskOutputsOperator) bpy.utils.register_class(StalkerShotAddPrevisOutputOperator) bpy.utils.register_class(StalkerShotAddAnimationOutputOperator) bpy.utils.register_class(StalkerShotAddLightingOutputOperator) bpy.utils.register_class(StalkerShotAddCompOutputOperator) bpy.types.SEQUENCER_MT_add.append(draw_stalker_menu)
def __init__(self): from anima.utils import do_db_setup from stalker import Type, LocalSession from anima.env import mayaEnv do_db_setup() m = mayaEnv.Maya() local_session = LocalSession() self.logged_in_user = local_session.logged_in_user if not self.logged_in_user: raise RuntimeError('Please login to Stalker') if not m.get_current_version(): raise RuntimeError('This scene is not saved with Stalker') self.anim_type = Type.query.filter(Type.name == "Animation").first() self.prev_type = Type.query.filter(Type.name == "Previs").first() # get current task info self.current_version = m.get_current_version() self.current_task = self.current_version.task self.current_type = self.current_task.type # check task type if self.current_type not in [self.anim_type, self.prev_type]: raise RuntimeError('Task must be either an Animation or Previs Task.') # query sequenceManager if len(pm.ls(type='sequenceManager')) is not 1: raise RuntimeError('There must be just 1 sequenceManager.') self.sm = pm.ls('sequenceManager1')[0] # query sequencer seqs = [seq for seq in pm.ls(type='sequencer') if seq.referenceFile() is None] if len(seqs) is not 1: raise RuntimeError('There must be just 1 sequencer.') self.sequencer = self.sm.sequences.get()[0] # query all shots in sequencer self.shot_list = self.sequencer.shots.get() # query shots in time based descending order shots = self.shot_list shots_sorted = [] shots_mid_frames = [] mid_frames = [] for shot in shots: start = shot.getSequenceStartTime() end = shot.getSequenceEndTime() mid_frame = int(start+((end-start)/2)) shots_mid_frames.append([shot, mid_frame]) mid_frames.append(mid_frame) mid_frames.sort() inc = -1 for frame in mid_frames: inc += 1 for shot in shots_mid_frames: if frame == shot[1]: if shot[0] not in shots_sorted: shots_sorted.append(shot[0]) self.shots_descending = shots_sorted # query all shot tasks from current scene shot_task = None parent_task = None if self.current_type is self.prev_type: parent_task = self.current_task.parent elif self.current_type is self.anim_type: parent_task = self.current_task.parent.parent if parent_task is None: raise RuntimeError('Current Task does not have Proper Parents.') for task in parent_task.walk_hierarchy(): if task.nice_name == 'Shots': shot_task = task break if shot_task is None: raise RuntimeError('Shots Task can not be found.') self.scene_shot_tasks = shot_task.tasks
def setup_db(cls): """setup the db """ from anima.utils import do_db_setup do_db_setup()