def init(import_libs=True):
"""
Initializes tpRigToolkit module
:param import_libs: bool, Whether to import deps libraries by default or not
"""
logger = create_logger()
if import_libs:
dcc_loader.init()
dcc_loader_module = core_dcc.get_dcc_loader_module('tpRigToolkit.dccs')
if dcc_loader_module:
dcc_loader_module.init()
register_resources()
# Register configuration files
dev = strings.to_boolean(os.getenv('TPRIGTOOLKIT_DEV', 'False'))
configs.register_package_configs(PACKAGE, os.path.dirname(tpRigToolkit.config.__file__))
core_config = configs.get_config('tpRigToolkit-core', environment='development' if dev else 'production')
if not core_config:
logger.warning(
'tpRigToolkit-core configuration file not found! '
'Make sure that you have tpRigToolkit-config package installed!')
return None
libs_to_load = core_config.get('libs', list())
tools_to_load = core_config.get('tools', list())
with contexts.Timer('Libraries loaded', logger=logger):
libs.LibsManager().register_package_libs(PACKAGE, libs_to_register=libs_to_load)
with contexts.Timer('Tools loaded', logger=logger):
tools.ToolsManager().register_package_tools(PACKAGE, tools_to_register=tools_to_load)
tools_paths = tools.ToolsManager().paths(PACKAGE)
with contexts.Timer('Toolsets loaded', logger=logger):
qt_toolsets.ToolsetsManager().register_package_toolsets(
PACKAGE, os.path.dirname(os.path.abspath(tpRigToolkit.toolsets.__file__)), tools_paths)
with contexts.Timer('Menu created', logger=logger):
main_menu = menus.create_main_menu(
package_name=PACKAGE, force_creation=True, icon=resources.icon('tpRigToolkit'))
if main_menu:
hub_action = QAction(resources.icon('tpRigToolkit'), 'Hub', main_menu)
main_menu.addAction(hub_action)
hub_action.triggered.connect(run_hub)
menus.create_menus(package_name=PACKAGE, dev=dev, force_main_menu_creation=False)
def init(dev=False):
"""
Initializes module
:param dev: bool, Whether tpDcc-core is initialized in dev mode or not
"""
if dev:
os.environ['TPDCC_DEV'] = str(dev)
logger = create_logger(dev=dev)
# Get DCC loader module
dcc_loader_module = core_dcc.get_dcc_loader_module()
logger.info('DCC loader module found: "{}"'.format(dcc_loader_module))
if dcc_loader_module:
dcc_loader_module.init_dcc()
# After that, we initialize Qt library (we must do it after tpDcc one because tpDcc-libs-qt depends on tpDcc-core)
# NOTE: DCC UI modules are automatically loaded by tpDcc-libs-qt
qt_loader.init(dev=dev)
configs.register_package_configs(PACKAGE,
os.path.dirname(tpDcc.config.__file__))
core_config = configs.get_config(
'tpDcc-core', environment='development' if dev else 'production')
if not core_config:
logger.warning(
'tpDcc-core configuration file not found! Make sure that you have tpDcc-config package installed!'
)
return None
libs_to_load = core_config.get('libs', list())
tools_to_load = core_config.get('tools', list())
with contexts.Timer('Libraries loaded', logger=logger):
libs.LibsManager().register_package_libs(PACKAGE,
libs_to_register=libs_to_load,
dev=dev)
libs.LibsManager().load_registered_libs(PACKAGE)
with contexts.Timer('Tools loaded', logger=logger):
tools.ToolsManager().register_package_tools(
PACKAGE, tools_to_register=tools_to_load, dev=dev)
tools.ToolsManager().load_registered_tools(PACKAGE)
with contexts.Timer('Toolsets loaded', logger=logger):
toolsets.ToolsetsManager().register_path(
PACKAGE, os.path.dirname(toolsets.__file__))
toolsets.ToolsetsManager().load_registered_toolsets(
PACKAGE, tools_to_load=tools_to_load)
def run_hub():
"""
Runs tpRigToolkit hub
"""
tools.ToolsManager().launch_tool_by_id(
'tpDcc-tools-hub', title='tpRigToolkit - Hub', icon='tprigtoolkit_hub', icon_hover='tprigtoolkit_hub_hover')
def get_logger(plugin_id=None):
"""
Returns logger associated with given tool
:param plugin_id: str
:return:
"""
if not plugin_id:
return logging.getLogger('tpDcc-core')
plugin_data = None
if '-tools-' in plugin_id:
plugin_data = tools.ToolsManager().get_tool_data_from_id(plugin_id)
elif '-libs-' in plugin_id:
plugin_data = libs.LibsManager().get_library_data_from_id(plugin_id)
if not plugin_data:
logger.warning(
'No logger found for: {}. Using tpDcc-core logger as fallback.'.
format(plugin_id))
return logging.getLogger('tpDcc-core')
logging_file = plugin_data.get('logging_file', None)
if not logging_file:
return logging.getLogger('tpDcc-core')
logging.config.fileConfig(logging_file, disable_existing_loggers=False)
# tool_logger_level_env = '{}_LOG_LEVEL'.format(pkg_loader.fullname.replace('.', '_').upper())
return logging.getLogger(plugin_id)
def _on_open_naming_manager(self):
# naming_manager_tool = tools.ToolsManager().launch_tool_by_id(
# 'tpRigToolkit-tools-namemanager', project=self._project)
naming_manager_tool = tools.ToolsManager().launch_tool_by_id(
'tpDcc-tools-nameit', naming_lib=self._project.naming_lib)
attacher = naming_manager_tool.attacher
attacher.closed.connect(self.update_rules)
def _launch_tool_by_id(tool_id, **kwargs):
"""
Internal function that launch a tool by its ID
:param tool_id: str
:param kwargs: dict
"""
do_reload = kwargs.get('do_reload', False)
tools.ToolsManager().launch_tool_by_id(tool_id,
do_reload=do_reload)
def _on_open_renamer_tool(self):
"""
Internal function that is used by toolbar to open Renamer Tool
"""
try:
tools.ToolsManager().launch_tool_by_id(
'tpDcc-tools-renamer',
naming_file=self._naming_lib.naming_file)
except Exception:
logger.warning('tpDcc-tools-renamer is not available!')
return None
def orient_tool(self):
cmd = {'cmd': 'setup_orient_joint_client'}
reply_dict = self.send(cmd)
if not self.is_valid_reply(reply_dict):
return False
# Once client is up and running in DCC, we can launch the tool
tools.ToolsManager().launch_tool_by_id(
'tpRigToolkit-tools-jointorient')
return reply_dict['success']
def open_symmetry_tool():
out_dict = {'success': False, 'result': None}
try:
tool = tools.ToolsManager().launch_tool_by_id(
'tpRigToolkit-tools-symmesh')
out_dict['result'] = tool
except Exception as exc:
out_dict['msg'] = 'Was not to open symmetry tool : {} '.format(exc)
return out_dict
out_dict['success'] = True
return out_dict
def _add_tool_action(item_info, parent):
tool_id = item_info.get('id', None)
tool_type = item_info.get('type', 'tool')
tool_data = tools.ToolsManager().get_tool_data_from_id(tool_id)
if tool_data is None:
LOGGER.warning(
'Menu : Failed to find Tool: {}, type {}'.format(
tool_id, tool_type))
return
tool_config = tool_data['config']
if not tool_config:
return
tool_menu_ui_data = tool_data['config'].data.get('menu_ui', {})
tool_icon_name = tool_menu_ui_data.get('icon', '')
if not tool_icon_name:
tool_icon_name = tool_data['config'].data.get('icon', None)
if not tool_icon_name:
tool_icon_name = 'tpDcc'
tool_icon = resources.icon(tool_icon_name)
if not tool_icon or tool_icon.isNull():
tool_icon = resources.icon('tpDcc')
label = tool_menu_ui_data.get('label', 'No_label')
tagged_action = menu.SearchableTaggedAction(label=label,
icon=tool_icon,
parent=parent)
is_checkable = tool_menu_ui_data.get('is_checkable', False)
is_checked = tool_menu_ui_data.get('is_checked', False)
if is_checkable:
tagged_action.setCheckable(is_checkable)
tagged_action.setChecked(is_checked)
# tagged_action.connect(partial(self._launch_tool, tool_data))
tagged_action.toggled.connect(
partial(_launch_tool_by_id, tool_id))
else:
tagged_action.triggered.connect(
partial(_launch_tool_by_id, tool_id))
icon = tool_menu_ui_data.get('icon', 'tpDcc')
if icon:
pass
tagged_action.tags = set(tool_data['config'].data.get('tags', []))
parent.addAction(tagged_action)
def get_tool_config(tool_id, package_name=None):
# Import here to avoid circular imports
from tpDcc.managers import tools
package_name = package_name or tool_id.replace('.', '-').split('-')[0]
tool_class = tools.ToolsManager().get_plugin_from_id(
tool_id, package_name=package_name)
if not tool_class:
return None
config_dict = tool_class.config_dict() or dict()
return get_config(tool_id,
package_name=package_name,
extra_data=config_dict)
def __init__(self, config=None, names_config=None, naming_config=None):
super(RenamerModel, self).__init__()
self._config = config if config else tools.ToolsManager(
).get_tool_config('tpDcc-tools-renamer')
self._names_config = names_config if names_config else configs.get_config(
config_name='tpDcc-naming')
self._naming_config = naming_config
self._selection_type = 0
self._hierarchy_check = False
self._rename_shape = True
self._filter_type = ''
self._rules = list()
self._active_rule = None
self._tokens = list()
self._unique_id_auto = True
self._last_joint_end_auto = True
def _on_close_window(self):
"""
Internal callback function that is called when the user clicks on close button
"""
from tpDcc.managers import tools
closed = False
if hasattr(self._window, 'WindowId'):
closed = tools.ToolsManager().close_tool(self._window.WindowId,
force=False)
if not closed:
if hasattr(self._window, 'docked'):
if self._window.docked():
self._window.fade_close()
else:
self.window().fade_close()
else:
self._window.fade_close()
def set_frameless_enabled(self, frameless=False):
"""
Enables/Disables frameless mode or OS system default
:param frameless: bool
"""
from tpDcc.managers import tools
tool_inst = tools.ToolsManager().get_tool_by_plugin_instance(
self._window)
if not tool_inst:
return
offset = QPoint()
if self._window.docked():
rect = self._window.rect()
pos = self._window.mapToGlobal(QPoint(-10, -10))
rect.setWidth(rect.width() + 21)
self._window.close()
else:
rect = self.window().rect()
pos = self.window().pos()
offset = QPoint(3, 15)
self.window().close()
tool_inst._launch(launch_frameless=frameless)
new_tool = tool_inst.latest_tool()
QTimer.singleShot(
0,
lambda: new_tool.window().setGeometry(pos.x() + offset.x(),
pos.y() + offset.y(),
rect.width(), rect.height()))
new_tool.framelessChanged.emit(frameless)
QApplication.processEvents()
return new_tool
def get_tools_menus():
"""
Returns dictionary with the menu info for all the registered tools
:return: dict
"""
tool_menus = dict()
for package_name, package_data in tools.ToolsManager().plugins.items():
for tool_name, tool_data in package_data.items():
tool_config = tool_data['config']
if not tool_config:
continue
menu_data = tool_config.data.get('menu', None)
if not menu_data:
continue
if package_name not in tool_menus:
tool_menus[package_name] = dict()
tool_menus[package_name][tool_name] = menu_data
return tool_menus
['tpRigToolkit', 'interpolate', 'animation', 'state', 'pose'],
'menu_ui': {
'label': 'Interpolate It',
'load_on_startup': False,
'color': '',
'background_color': ''
},
'size': [425, 600]
}
base_tool_config.update(tool_config)
return base_tool_config
def launch(self, *args, **kwargs):
return self.launch_frameless(*args, **kwargs)
if __name__ == '__main__':
import tpRigToolkit.loader
from tpDcc.managers import tools
tool_path = os.path.abspath(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
if tool_path not in sys.path:
sys.path.append(tool_path)
tpRigToolkit.loader.init()
tools.ToolsManager().launch_tool_by_id(InterpolateItTool.ID)
'is_checkable': False,
'is_checked': False,
'menu_ui': {
'label': 'SymMesh',
'load_on_startup': False,
'color': '',
'background_color': ''
}
}
base_tool_config.update(tool_config)
return base_tool_config
def launch(self, *args, **kwargs):
return self.launch_frameless(*args, **kwargs)
if __name__ == '__main__':
import tpRigToolkit.loader
from tpDcc.managers import tools
tool_path = os.path.abspath(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
if tool_path not in sys.path:
sys.path.append(tool_path)
tpRigToolkit.loader.init(dev=True)
tools.ToolsManager().launch_tool_by_id(consts.TOOL_ID)
Creates logger for current tpRigToolkit-tools-jointorient package
"""
logger_directory = os.path.normpath(
os.path.join(os.path.expanduser('~'), 'tpRigToolkit', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(
os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpRigToolkit-tools-jointorient')
dev = os.getenv('TPRIGTOOLKIT_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpRigToolkit.loader
from tpDcc.managers import tools
tpRigToolkit.loader.init()
tools.ToolsManager().launch_tool_by_id('tpRigToolkit-tools-jointorient')
"""
logger_directory = os.path.normpath(
os.path.join(os.path.expanduser('~'), 'tpDcc', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(
os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpDcc-tools-datalibrary')
dev = os.getenv('TPDCC_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpDcc.loader
from tpDcc.managers import tools
tpDcc.loader.init(dev=False)
tools.ToolsManager().launch_tool_by_id('tpDcc-tools-datalibrary')
'is_checkable': False,
'is_checked': False,
'menu_ui': {
'label': 'Data Library',
'load_on_startup': False,
'color': '',
'background_color': ''
},
}
base_tool_config.update(tool_config)
return base_tool_config
def launch(self, *args, **kwargs):
return self.launch_frameless(*args, **kwargs)
if __name__ == '__main__':
import tpDcc.loader
from tpDcc.managers import tools
tool_path = os.path.abspath(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
if tool_path not in sys.path:
sys.path.append(tool_path)
tpDcc.loader.init()
tools.ToolsManager().launch_tool_by_id(DataLibraryTool.ID)
# tools.ToolsManager().launch_tool_by_id(consts.TOOL_ID)
from tpDcc.tools.renamer.core import model, view, controller
renamer_model = model.RenamerModel(config=self.CONFIG,
names_config=self._names_config,
naming_config=self._naming_config)
renamer_controller = controller.RenamerController(
naming_lib=self._naming_lib,
client=self._client,
model=renamer_model)
renamer_view = view.RenamerView(model=renamer_model,
controller=renamer_controller,
parent=self)
return [renamer_view]
if __name__ == '__main__':
import os
import sys
import tpDcc.loader
from tpDcc.managers import tools
tool_path = os.path.abspath(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
if tool_path not in sys.path:
sys.path.append(tool_path)
tpDcc.loader.init()
tools.ToolsManager().launch_tool_by_id(TOOL_ID)
Creates logger for current tpRigToolkit-tools-rigtoolbox package
"""
logger_directory = os.path.normpath(
os.path.join(os.path.expanduser('~'), 'tpRigToolkit', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(
os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpRigToolkit-tools-rigtoolbox')
dev = os.getenv('TPRIGTOOLKIT_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpRigToolkit.loader
from tpDcc.managers import tools
tpRigToolkit.loader.init()
tools.ToolsManager().launch_tool_by_id('tpRigToolkit-tools-rigtoolbox')
"""
Creates logger for current tpRigToolkit-tools-musclespline package
"""
logger_directory = os.path.normpath(os.path.join(os.path.expanduser('~'), 'tpRigToolkit', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpRigToolkit-tools-musclespline')
dev = os.getenv('TPRIGTOOLKIT_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpRigToolkit.loader
from tpDcc.managers import tools
tpRigToolkit.loader.init()
tools.ToolsManager().launch_tool_by_id('tpRigToolkit-tools-musclespline')
'is_checkable': False,
'is_checked': False,
'menu_ui': {
'label': 'NameIt',
'load_on_startup': False,
'color': '',
'background_color': ''
},
}
base_tool_config.update(tool_config)
return base_tool_config
def launch(self, *args, **kwargs):
return self.launch_frameless(*args, **kwargs)
if __name__ == '__main__':
import tpDcc.loader
from tpDcc.managers import tools
tool_path = os.path.abspath(
os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
if tool_path not in sys.path:
sys.path.append(tool_path)
tpDcc.loader.init(dev=False)
tools.ToolsManager().launch_tool_by_id(NameItTool.ID)
Creates logger for current tpDcc-tools-nameit package
"""
logger_directory = os.path.normpath(os.path.join(os.path.expanduser('~'), 'tpDcc', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpDcc-tools-nameit')
dev = os.getenv('TPDCC_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpDcc.loader
from tpDcc.managers import tools
tpDcc.loader.init(dev=False)
tools.ToolsManager().launch_tool_by_id('tpDcc-tools-nameit')
Creates logger for current tpRigToolkit-tools-symmesh package
"""
logger_directory = os.path.normpath(
os.path.join(os.path.expanduser('~'), 'tpRigToolkit', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(
os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpRigToolkit-tools-symmesh')
dev = os.getenv('TPRIGTOOLKIT_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpRigToolkit.loader
from tpDcc.managers import tools
tpRigToolkit.loader.init()
tools.ToolsManager().launch_tool_by_id('tpRigToolkit-tools-symmesh')
import tpDcc.loader
from tpDcc.managers import tools
if __name__ == '__main__':
tpDcc.loader.init(dev=False)
tools.ToolsManager().launch_tool_by_id('tpDcc-tools-scripteditor', dev=True)
Creates logger for current tpDcc-tools-renamer package
"""
logger_directory = os.path.normpath(os.path.join(os.path.expanduser('~'), 'tpDcc', 'logs', 'tools'))
if not os.path.isdir(logger_directory):
os.makedirs(logger_directory)
logging_config = os.path.normpath(os.path.join(os.path.dirname(__file__), '__logging__.ini'))
logging.config.fileConfig(logging_config, disable_existing_loggers=False)
logger = logging.getLogger('tpDcc-tools-renamer')
dev = os.getenv('TPDCC_DEV', dev)
if dev:
logger.setLevel(logging.DEBUG)
for handler in logger.handlers:
handler.setLevel(logging.DEBUG)
return logger
create_logger()
if __name__ == '__main__':
import tpDcc.loader
from tpDcc.managers import tools
tpDcc.loader.init(dev=False)
tools.ToolsManager().launch_tool_by_id('tpDcc-tools-renamer')
