def __init__(self, name, settings=None):
super(ArtellaProject, self).__init__()
self._tray = None
clean_name = self._get_clean_name(name)
# Register project configurations
try:
project_config_mod = importlib.import_module(
'{}.config'.format(clean_name))
tp.ConfigsMgr().register_package_configs(
clean_name, os.path.dirname(project_config_mod.__file__))
except RuntimeError:
artellapipe.logger.warning(
'No Configuration Module found for project: {}'.format(
clean_name))
self._config = tp.ConfigsMgr().get_config(
config_name='artellapipe-project',
package_name=clean_name,
root_package_name='artellapipe',
environment=os.environ.get(
'{}_env'.format(self._get_clean_name(name)), 'DEVELOPMENT'),
config_dict={
'title': clean_name.title(),
'project_lower': clean_name.replace(' ', '').lower(),
'project_upper': clean_name.replace(' ', '').upper(),
})
self._config_data = self._config.data
self._settings = settings
self.init_settings()
def register_configs():
"""
Registers aretellapipe configuration files
"""
import tpDcc as tp
from artellapipe import config
artella_configs_path = os.environ.get('ARTELLA_CONFIGS_PATH', None)
if artella_configs_path and os.path.isdir(artella_configs_path):
tp.ConfigsMgr().register_package_configs('artellapipe',
artella_configs_path)
else:
tp.ConfigsMgr().register_package_configs(
'artellapipe', os.path.dirname(config.__file__))
def __init__(self,
project,
install_path,
paths_to_register=None,
tag=None,
dev=False):
self._logger = None
self._name = None
self._version = None
self._plugins = None
self._install_path = install_path
self._paths_to_register = paths_to_register if paths_to_register else list(
)
self._tag = tag
self._dev = dev
self._set_environment_variables(project)
config = tpDcc.ConfigsMgr().get_config(
config_name='artellapipe-launcher',
package_name=project.get_clean_name(),
root_package_name='artellapipe',
environment=project.get_environment())
super(ArtellaLauncher, self).__init__(project=project,
name='ArtellaLauncherWindow',
title='Launcher',
config=config)
self.init_config()
self._logger = self.create_logger()[1]
self.init()
def config(self):
if not self.__class__._config:
self.__class__._config = tp.ConfigsMgr().get_config(
config_name='artellapipe-assets',
package_name=artellapipe.project.get_clean_name(),
root_package_name='artellapipe',
environment=artellapipe.project.get_environment())
return self.__class__._config
def _create_lib_config(self, project_name, lib_path, project, config_dict):
lib_config = tpDcc.ConfigsMgr().get_config(
config_name=lib_path.replace('.', '-'),
package_name=project_name,
root_package_name='artellapipe',
environment=project.get_environment(),
config_dict=config_dict)
return lib_config
def __init__(self, project, launcher, parent=None):
self._dccs = dict()
self._splash = None
self._departments = dict()
self._selected_dcc = None
self._selected_version = None
self._config = tpDcc.ConfigsMgr().get_config(
config_name='artellapipe-launcher-plugins-dccselector',
package_name=project.get_clean_name(),
root_package_name='artellapipe',
environment=project.get_environment())
super(DCCSelector, self).__init__(project=project,
launcher=launcher,
parent=parent)
def __init__(self, *args, **kwargs):
self._project = kwargs.pop('project')
project_name = self._project.get_clean_name()
config_name = self.FULL_NAME.replace('.', '-')
config_dict = kwargs.get('config_dict', dict())
config_dict.update({
'join': os.path.join,
'user': os.path.expanduser('~'),
'filename': self.FILE_NAME,
'fullname': self.FULL_NAME,
'project': project_name
})
new_config = tpDcc.ConfigsMgr().get_config(
config_name=config_name,
package_name=project_name,
root_package_name='artellapipe',
environment=self._project.get_environment(),
config_dict=config_dict)
kwargs['config'] = new_config
super(ArtellaTool, self).__init__(*args, **kwargs)
def process(self, instance):
if not instance.data.get('publish', False):
return False
project = instance.data.get('project', None)
assert project, 'No valid project defined in current instance: {}'.format(
instance)
shots_config = tp.ConfigsMgr().get_config(
config_name='artellapipe-shots')
assert shots_config, 'No valid shots configuration file found in current instance: {}'.format(
instance)
shot_node = instance.data.get('shot', None)
assert shot_node, 'No valid shot node found in current instance: {}'.format(
instance)
# Retrieve master layout file path
sequence_name = shot_node.get_sequence()
assert sequence_name, 'No valid sequence name found linked to current instance: {}'.format(
instance)
sequence = artellapipe.SequencesMgr().find_sequence(sequence_name)
assert sequence, 'No valid sequence found linked to current instance: {}'.format(
instance)
sequence_file_type = sequence.get_file_type('master')
assert sequence, 'File type "master" not found in current project'
sequence_file_type.open_file()
shot_name = shot_node.get_name()
assert tp.Dcc.object_exists(
shot_name), 'No valid shot found in current instance: {}'.format(
instance)
all_shots = artellapipe.ShotsMgr().find_all_shots()
assert all_shots, 'No shots defined in current project!'
start_frame = shots_config.get('start_frame', default=101)
found = False
for shot in all_shots:
if shot.get_name() == shot_name:
found = True
break
assert found, 'Shot with name: "{}" not found in current sequence!'.format(
shot_name)
new_version = bool(
util.strtobool(
os.environ.get(
'{}_SEQUENCES_PUBLISHER_NEW_VERSION'.format(
project.get_clean_name().upper()), 'False')))
base_comment = '{} | {} | Sequences Publisher > Shot "{}" Export'.format(
timedate.get_current_time(), osplatform.get_user(True), shot_name)
comment = instance.data.get('comment', None)
if comment:
base_comment = '{} | {}'.format(base_comment, comment)
valid_export = artellapipe.ShotsMgr().export_shot(
shot_name,
start_frame=start_frame,
new_version=new_version,
comment=base_comment)
assert valid_export, 'Shot with name "{}" was not exported successfully!'.format(
shot_name)
return True
def create_menus(self, package_name, project=None):
"""
Overrides base ToolsManager create menus function
:param package_name: str
:param project: ArtellaProject
"""
if not project:
if hasattr(artellapipe, 'project') and artellapipe.project:
project = artellapipe.project
if not project:
artellapipe.logger.warning(
'Impossible to create menu because project is not defined!')
return False
self._menu_names[package_name] = project.config.get('menu', 'name')
self._object_menu_names[package_name] = project.config.get(
'menu', 'object_name')
self.remove_previous_menus(project=project, package_name=package_name)
self.create_project_description_menu(package_name=package_name,
project=project)
main_menu = self.create_main_menu(package_name=package_name)
if not main_menu:
artellapipe.logger.warning(
'Impossible to create main menu for "{}"'.format(package_name))
return False
menus_config = tpDcc.ConfigsMgr().get_config(
config_name='artellapipe-menu',
package_name=project.get_clean_name(),
root_package_name='artellapipe',
environment=project.get_environment())
if not menus_config:
artellapipe.logger.warning(
'Impossible to create menu for project "{}" because menu configuration file not found!'
.format(project.get_clean_name()))
return False
menus_config = menus_config.get('menus', default=list())
if menus_config:
for menu_data in menus_config:
for _, data in menu_data.items():
for i in iter(data):
if python.is_string(i) and i == 'separator':
main_menu.addSeparator()
continue
self._menu_creator(main_menu,
i,
project.get_clean_name(),
dev=project.is_dev())
# Tools Menus
tools_menu_data = self.get_tools_menus() or dict()
for pkg_name, menu_data in tools_menu_data.items():
for tool_path, data in menu_data.items():
for i in iter(data):
if python.is_string(i) and i == 'separator':
main_menu.addSeparator()
continue
self._menu_creator(main_menu,
i,
project.get_clean_name(),
dev=project.is_dev())
self.create_tray_menu(project=project)
self.create_bug_tracker_action(package_name=package_name)
return True