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')